java后端开发day21--面向对象进阶（二）--继承进阶

（以下内容全部来自上述课程）

1.继承

1.子类到底能继承父类中的哪些内容？

1. 构造方法（纯不能） 非私有：不能 private：不能
   比如：把构造变量看成自己，爹就是爹，儿子就是儿子，不能混着来。
2. 成员变量（纯能） 非私有：能 private：能
   比如：父亲有public武功直接继承给儿子；如果是private武功就是把武功锁起来给儿子，钥匙是setget方法。
3. 成员方法 （最正常） 非私有：能 private：不能
4. 注意：继承不等于能调用！！！！！！

1.误区（错的）

1. 父类私有的东西，子类就无法继承
2. 父类中非私有的成员，就被子类继承下来了。

2.内存图

栈：方法（main）
堆：new出来的成员变量
方法区：字节码文件（类）

1.成员变量为非私有（可继承也可直接使用）

2.成员变量为私有（可继承但不能直接调用）

3.成员方法的虚方法

4.成员方法继承的内存图

2.继承中：成员变量的访问特点

就近原则：谁离我近，我就用谁

package a02loopextendsdemo2;public class Test {public static void main(String[] args) {Zi z = new Zi();z.ziShow();}
}class Fu {String name = "Fu";
}class Zi extends Fu {String name = "Zi";public void ziShow() {String name = "ZiShow";System.out.println(name);  //ZiShow  就近原则:局部位置System.out.println(this.name);  //Zi  本类成员位置System.out.println(super.name);  //Fu  super表示父类}
}

3.继承中：成员方法的访问特点

直接调用满足就近原则：谁离我近，我就用谁
super直接调用，直接访问父类

1.方法的重写

当父类的方法不能满足子类现在的需求时，需要进行方法重写
书写格式：
在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。
@Override重写注解

1. @Override是放在重写后的方法上，校验子类重写时语法是否正确。
2. 加上注解后如果有红色的波浪线，表示语法错误。
3. 建议重写方法都加@Override注解，代码安全，优雅！

2.方法重写的本质

3.方法重写注意事项和要求

1. 重写方法的名称、形参列表必须与父类中的一致。
2. 子类重写父类方法时，访问权限子类必须大于等于父类（空着不写<protected<public）
3. 子类重写父类方法时，返回值类型子类必须小于等于父类
4. 建议：重写的方法尽量和父类保持一致。
5. 只有被添加到虚方法表中的方法才能被重写。

4.方法重写的实例

1.Dog

package a03loopextendsdemo3;public class Dog {public void eat(){System.out.println("狗吃狗粮");}public void drink(){System.out.println("狗喝水");}public void lookHome(){System.out.println("狗看家");}
}

2.Husky

package a03loopextendsdemo3;public class Husky extends Dog {//拆家public void breakHome(){System.out.println("哈士奇拆家");}
}

3.SharPei

package a03loopextendsdemo3;public class SharPei extends Dog{@Overridepublic void eat(){super.eat();System.out.println("狗吃骨头");}
}

4.ChineseDog

package a03loopextendsdemo3;public class ChineseDog extends Dog{@Overridepublic void eat(){System.out.println("狗吃剩饭");}
}

5.DogTest

package a03loopextendsdemo3;public class DogTest {public static void main(String[] args) {//创建对象并调用方法Husky h = new Husky();h.eat();  //狗吃狗粮h.drink(); //狗喝水h.lookHome();  //狗看家h.breakHome();  //    拆家System.out.println("----------------");ChineseDog c = new ChineseDog();c.eat();  //狗吃剩饭c.drink();  //狗喝水c.lookHome();  //狗看家System.out.println("----------------");SharPei s = new SharPei();s.eat(); //狗吃狗粮s.drink();  //狗喝水s.lookHome();  //狗看家System.out.println("----------------");Dog d = new Dog();d.eat();  //狗吃狗粮d.drink();  //狗喝水d.lookHome();  //狗看家System.out.println("----------------");}
}

4.继承中的构造方法的访问特点

• 父类中的构造方法不会被子类继承
• 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己。

为什么？

• 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
• 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化。

怎么调用父类构造方法的？

• 子类构造方法的第一行语句默认都是：super()，不写也存在，且必须在第一行。
• 如果想调用父类有参构造，必须手动写super进行调用。

1.无参

2.有参

3.总结（要看儿子得先看老子）

• 子类不能继承父类的构造方法，但是可以通过super调用。
• 子类构造方法的第一行，有一个默认的super();
• 默认先访问父类中无参的构造方法，再执行自己。
• 如果想要方法文父类有参构造，必须手动手写。

5.this、super关键字

1.this（就一局部变量）

理解为一个变量，表示当前方法调用的地址值。

2.super

代表父类存储空间。

3.this访问本类方法

表示调用本类其他构造方法
细节：虚拟机就不会再添加super();

4.实例

1.Empolyee

package a04loopextendsdemo4;public class Employee {//1.类名见名知意//2.所有的成员变量都需要私有//3.构造方法（空参 带全部参数的构造）//4.get/set方法private String id;private String name;private double salary;public Employee() {}public Employee(String id, String name, double salary) {this.id = id;this.name = name;this.salary = salary;}/*** 获取* @return id*/public String getId() {return id;}/*** 设置* @param id*/public void setId(String id) {this.id = id;}/*** 获取* @return name*/public String getName() {return name;}/*** 设置* @param name*/public void setName(String name) {this.name = name;}/*** 获取* @return salary*/public double getSalary() {return salary;}/*** 设置* @param salary*/public void setSalary(double salary) {this.salary = salary;}public String toString() {return "Employee{id = " + id + ", name = " + name + ", salary = " + salary + "}";}//工作public void work(){System.out.println("员工在工作");}//吃饭public void eat(){System.out.println("员工在吃饭");}
}

2.Manager

package a04loopextendsdemo4;public class Manager extends Employee{private double bonus;//空参public Manager() {}//带全部参数的构造public Manager(String id, String name, double salary, double bonus) {super(id, name, salary);this.bonus = bonus;}//get/set方法public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}@Overridepublic void work() {System.out.println("管理其他人");}}

3.Cook

package a04loopextendsdemo4;public class Cook extends Employee{public Cook() {}public Cook(String id, String name, double salary) {super(id, name, salary);}@Overridepublic void work() {System.out.println("炒菜");}
}

4.Test

package a04loopextendsdemo4;public class Test {public static void main(String[] args) {//创建对象并赋值调用Manager  m= new Manager("001","张三",10000,8000);System.out.println(m.getId()+","+m.getName()+","+m.getSalary()+ ","+m.getBonus());m.work();m.eat();Cook c = new Cook();c.setId("002");c.setName("李四");c.setSalary(20000);System.out.println(c.getId()+","+c.getName()+","+c.getSalary());c.work();c.eat();}
}