继承的概述
继承主要解决的问题就是:
共性抽取
继承关系当中的特点:
- 子类可以拥有父类的"内容"
- 子类还可以拥有自己专有的内容
继承的格式
在继承的关系中,子类就是一个父类.
例如:父类是员工,子类是讲师,那么讲师就是一个员工
定义父类的格式
public class 父类名称{
//…
}
定义子类的格式
public class 子类名称 extends 父类名称{
// …
}
创建一个员工父类
package demo1;
public class Employee {
public void method(){
System.out.println("父类方法执行!");
}
}
创建两个个子类,老师和助教
package demo1;
public class Teacher extends Employee {
}
package demo1;
public class Assistant extends Employee{
}
主程序
package demo1;
public class t1 {
public static void main(String[] args) {
//创建子类对象
Teacher teacher = new Teacher();
teacher.method();
Assistant assistant = new Assistant();
assistant.method();
}
}
继承中成员变量的访问特点
创建Fu父类
package demo1;
public class Fu {
int numFu = 10;
int num = 200;
}
创建Zi子类
package demo1;
public class Zi extends Fu{
int numZi = 20;
int num = 100;
}
主程序
package demo1;
public class t1 {
public static void main(String[] args) {
//创建父类对象
Fu fu = new Fu();
System.out.println(fu.numFu); //只能使用父类的东西,没有任何的子类内容
//创建子类对象
Zi zi = new Zi();
System.out.println(zi.numFu); //10
System.out.println(zi.numZi); //20
//父类子类成员变量重名情况
System.out.println(zi.num); //100
}
}
区分子类方法中重名的三种情况
- 局部变量:直接写
- 本类的成员变量:this.成员变量名
- 父类的成员变量:super.成员变量名
创建一个Fu父类
package demo1;
public class Fu {
int num =10;
}
创建一个Zi子类
package demo1;
public class Zi extends Fu{
int num =20;
public void method(){
int num = 30;
System.out.println(num); //30局部变量
System.out.println(this.num); //20本类成员变量
System.out.println(super.num); //10父类成员变量
}
}
主程序
package demo1;
public class t1 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.method();
}
}
继承中成员方法的访问特点
在父子类的继承关系当中,创建子类对象,去访问成员方法的规则:
创建的对象是谁,就优先用谁,如果没有就向上找
创建一个Fu父类
package demo1;
public class Fu {
public void methodFu(){
System.out.println("父类执行");
}
public void method(){
System.out.println("父类重名方法执行");
}
}
创建一个Zi子类
package demo1;
public class Zi extends Fu{
public void methodZi(){
System.out.println("子类执行");
}
public void method(){
System.out.println("子类重名方法执行");
}
}
主程序
package demo1;
public class t1 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.methodFu();
zi.methodZi();
//创建是谁,就优先用谁的方法
zi.method(); //子类重名方法执行
}
}
注意事项:
无论是成员方法还是成员变量,如果没有都是向上找父类绝对不会向下找子类的
继承中方法的覆盖重写概念
重写与重载的概念区分
重写概念:
在继承关系当中,方法的名称一样,参数列表也一样以后直接叫覆盖重写就行,更加容易理解
重载概念:
在继承关系当中,方法的名称一样,参数列表不一样
继承中方法的覆盖重写注意事项
- 必须保证父子类之间方法的名称相同,参数列表也相同
@Override:写在方法前面,用来检测是不是有效的正确覆盖重写
与python的装饰器等同,非侵入式方法 - 子类方法的返回值必须小于等于父类方法的返回值范围
- 子类方法的权限必须大于等于父类方法的权限修饰符
扩展:public > protected > (default) > private
备注:(default)不是关键字default,而是什么都不写,留空
创建Fu父类
package demo1;
public class Fu {
//子类方法的权限必须要大于等于父类权限
Object method(){
return null;
}
}
创建Zi子类
package demo1;
public class Zi extends Fu{
//子类方法的返回值要小于等于父类方法的返回值范围
@Override
public String method(){
return null;
}
}
主程序
package demo1;
public class t1 {
public static void main(String[] args) {
Zi zi = new Zi();
zi.methodFu();
zi.methodZi();
//创建是谁,就优先用谁的方法
zi.method(); //子类重名方法执行
}
}
继承中方法的覆盖重写应用场景
继承使用类似与产生一个新的手机.第一已经投入使用的类,尽量不做修改,重新定义一个新的类,来重复利用其中的共性内容,并添加新的内容
创建一个Phone父类
package demo1;
//本来得老款手机
public class Phone {
public void call(){
System.out.println("打电话");
}
public void send(){
System.out.println("发短线");
}
public void show(){
System.out.println("显示号码");
}
}
创建一个newPhone子类
package demo1;
//定义一个新手机,使用老是偶见作为父类
public class newPhone extends Phone{
@Override
public void show(){
super.show(); //把父类的show方法拿来重复利用
System.out.println("显示头像");
System.out.println("显示姓名");
}
}
主程序
package demo1;
public class t1 {
public static void main(String[] args) {
Phone phone = new Phone();
phone.call();
phone.send();
phone.show();
newPhone newPhone = new newPhone();
newPhone.call();
newPhone.show();
newPhone.send();
}
}
继承中构造方法的访问特点
继承关系中,父子类构造方法的访问特点:
- 子类构造方法当中有一个默认隐含的super()调用,所以一定是先调用的父类构造,后执行的子类构造
- 子类构造可以通过super关键字来调用父类重载构造
- super的父类构造调用,必须是子类构造方法的第一个语句.不能一个子类构造调用多次super构造.
- 子类必须调用父类构造方法,不写增送super().写了则用指定的super调用,super只能有一个,还必须是第一个.
super关键字的三种用法
super关键字的用法有三种:
- 在子类的成员方法中,访问父类的成员变量
- 在子类的成员方法中访问父类的成员方法
- 在子类的构造方法中访问父类的构造方法
创建一个Fu父类
package demo1;
public class Fu {
int num = 10;
public void method(){
System.out.println("父类方法");
}
}
创建一个Zi子类
package demo1;
public class Zi extends Fu{
int num = 20;
public Zi(){
super(); //在子类的构造方法中访问父类的构造方法
}
public void methodZi(){
System.out.println(super.num); //父类中的num
}
public void method(){
super.method(); //访问父类中的method
System.out.println("子类方法");
}
}
this关键字的三种用法
this关键字用来访问本类内容,与python的self等同,三种用法:
- 在本的成员方法中,访问本类的成员变量
- 在本类的成员方法中,访问本类的另一个成员方法
- 在本类的构造方法中,访问本类的另一个构造方法
在第三种用法当中要注意:
A.this(…)调用也必须是构造方法的第一个语句
B.super和this1两种构造调用,不能同时使用
创建Fu父类
package demo1;
public class Fu {
int num = 30;
}
创建Zi子类
package demo1;
public class Zi extends Fu {
int num = 20;
public Zi(){
this(123); //本类的无参构造,调用本类的有参构造
}
public Zi(int n){
}
public void showNum() {
int num = 10;
System.out.println(num);//局部变量
System.out.println(this.num);//本类中的成员变量
System.out.println(super.num); //父类中的成员变量
}
public void methodA(){
System.out.println("AAA");
}
public void methodB(){
//本类的成员方法中,访问本类的另一个成员方法
this.methodA();
System.out.println("BBB");
}
}
super与this关键字内存图情况
java继承的三个特点
Java语言是单继承的:
一个类的直接父类只能有唯一一个
抽象的概念
抽象方法和抽象类的格式
抽象方法:
抽象方法就是加上abstract关键字,然后去掉大括号,直接分号结束
抽象类:
抽象方法所在的类,必须是抽象类才行.在class之前写上abstract即可
创业一个Animal类
package demo1;
public abstract class Animal {
//这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定
public abstract void eat();
//这是普通的方法
public void normalMethod(){
}
}
抽象方法和抽象类的使用
如何使用抽象类和抽象方法
- 不能直接创建new抽象类对象
- 必须用一个子类来继承抽象父类
- 子类必须覆盖重写抽象父类当中所有的抽象方法
覆盖重写(实现):子类去掉抽象方法的abstract关键字,然后补上方法体大括号 - 创建子类对象进行使用
创建一个抽象父类Animal
package demo1;
public abstract class Animal {
//这是一个抽象方法,代表吃东西,但是具体吃什么(大括号的内容)不确定
public abstract void eat();
}
创建子类继承抽象父类,覆盖重写抽象方法
package demo1;
public class Cat extends Animal{
@Override
public void eat(){
System.out.println("猫吃鱼");
}
}
主程序:创建子类对象进行使用
package demo1;
public class t1 {
public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
}
}
抽象方法个抽象类的注意事项
- 抽象类不能创建对象
- 一个抽象类不一定含有抽象方法,只要保证抽象方法所在的类是抽象类,即可
这样没有抽象方法的抽象类,也不能直接创建对象,在一些特殊场景下有用途 - 抽象类的子类,必须重写抽象类中所有的抽象方法.除非子类也是一个抽象类
发红包案例实现
抽象出来一个父类User,抽象出名字和余额
package demo1;
public class User {
private String name;
private int balance;
public User() {
}
public User(String name, int balance) {
this.name = name;
this.balance = balance;
}
//展示用户余额
public void show(){
System.out.println("我叫"+name+"我有多少钱:"+balance);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getBalance() {
return balance;
}
public void setBalance(int balance) {
this.balance = balance;
}
}
创建一个群主子类Manager
package demo1;
import java.util.ArrayList;
import java.util.Random;
public class Manager extends User {
public Manager(){
}
public Manager(String name, int balance) {
super(name, balance);
}
public ArrayList<Integer> send(int totaMoney,int count){
ArrayList<Integer> redList = new ArrayList<>();
int surpluseMoney = super.getBalance();
if (totaMoney<surpluseMoney){
super.setBalance(surpluseMoney-totaMoney);
for (int i = 0; i < count; i++) {
if (i ==count-1){
//把最后剩下的一点碎钱,包在最后一个红包里面
redList.add(totaMoney/count+totaMoney%count);
}
redList.add(totaMoney / count); //整除
}
}
else {
System.out.println("余额不足");
return redList;
}
return redList;
}
}
创建一个Member子类
package demo1;
import java.util.ArrayList;
import java.util.Random;
public class Member extends User {
public Member() {
}
public Member(String name, int balance) {
super(name, balance);
}
public void receive(ArrayList<Integer> redList){
Random rnd = new Random();
int index = rnd.nextInt(redList.size());
int redMoney = redList.remove(index);
int surplus = super.getBalance();
super.setBalance(surplus+redMoney);
}
}
主程序
package demo1;
import java.util.ArrayList;
public class t1 {
public static void main(String[] args) {
Manager manager = new Manager("群主",100);
Member one = new Member("成员A",0);
Member two = new Member("成员B",0);
Member three = new Member("成员C",0);
manager.show(); //100
one.show(); //0
two.show(); //0
three.show(); //0
//群主发红包了
ArrayList<Integer> redList = manager.send(20, 3);
one.receive(redList);
two.receive(redList);
three.receive(redList);
manager.show(); //80
one.show(); //8
two.show(); //6
three.show(); //6
}
}
