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

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

1.继承

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

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

1.误区（错的）

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

2.内存图

栈：方法（main）
堆：new出来的成员变量
方法区：字节码文件（类）
1.成员变量为非私有（可继承也可直接利用）

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

3.成员方法的虚方法

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

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

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

1. package a02loopextendsdemo2;
3. public class Test {
4.     public static void main(String[] args) {
5.         Zi z = new Zi();
6.         z.ziShow();
7.     }
8. }
10. class Fu {
11.     String name = "Fu";
12. }
14. class Zi extends Fu {
15.     String name = "Zi";
16.     public void ziShow() {
17.         String name = "ZiShow";
18.         System.out.println(name);  //ZiShow  就近原则:局部位置
19.         System.out.println(this.name);  //Zi  本类成员位置
20.         System.out.println(super.name);  //Fu  super表示父类
21.     }
22. }

复制代码

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

直接调用满足就近原则：谁离我近，我就用谁
super直接调用，直接访问父类
1.方法的重写

当父类的方法不能满足子类如今的需求时，须要举行方法重写
誊写格式：
在继承体系中，子类出现了和父类中千篇同等的方法声明，我们就称子类这个方法是重写的方法。
@Override重写注解

• @Override是放在重写后的方法上，校验子类重写时语法是否准确。
  
• 加上注解后如果有赤色的波浪线，表现语法错误。
  
• 发起重写方法都加@Override注解，代码安全，优雅！
  

2.方法重写的本质

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

• 重写方法的名称、形参列表必须与父类中的划一。
  
• 子类重写父类方法时，访问权限子类必须大于便是父类（空着不写<protected<public）
  
• 子类重写父类方法时，返回值范例子类必须小于便是父类
  
• 发起：重写的方法只管和父类保持划一。
  
• 只有被添加到虚方法表中的方法才华被重写。
  

4.方法重写的实例

1.Dog

1. package a03loopextendsdemo3;
3. public class Dog {
4.     public void eat(){
5.         System.out.println("狗吃狗粮");
6.     }
8.     public void drink(){
9.         System.out.println("狗喝水");
10.     }
12.     public void lookHome(){
13.         System.out.println("狗看家");
14.     }
15. }

复制代码

2.Husky

1. package a03loopextendsdemo3;
3. public class Husky extends Dog {
4.     //拆家
5.     public void breakHome(){
6.         System.out.println("哈士奇拆家");
7.     }
8. }

复制代码

3.SharPei

1. package a03loopextendsdemo3;
3. public class SharPei extends Dog{
4.     @Override
5.     public void eat(){
6.        super.eat();
7.        System.out.println("狗吃骨头");
8.     }
9. }

复制代码

4.ChineseDog

1. package a03loopextendsdemo3;
3. public class ChineseDog extends Dog{
4.     @Override
5.     public void eat(){
6.         System.out.println("狗吃剩饭");
7.     }
8. }

复制代码

5.DogTest

1. package a03loopextendsdemo3;
3. public class DogTest {
4.     public static void main(String[] args) {
5.         //创建对象并调用方法
7.         Husky h = new Husky();
8.         h.eat();  //狗吃狗粮
9.         h.drink(); //狗喝水
10.         h.lookHome();  //狗看家
11.         h.breakHome();  //    拆家
12.         System.out.println("----------------");
13.         ChineseDog c = new ChineseDog();
14.         c.eat();  //狗吃剩饭
15.         c.drink();  //狗喝水
16.         c.lookHome();  //狗看家
17.         System.out.println("----------------");
18.         SharPei s = new SharPei();
19.         s.eat(); //狗吃狗粮
20.         s.drink();  //狗喝水
21.         s.lookHome();  //狗看家
22.         System.out.println("----------------");
23.         Dog d = new Dog();
24.         d.eat();  //狗吃狗粮
25.         d.drink();  //狗喝水
26.         d.lookHome();  //狗看家
27.         System.out.println("----------------");
28.     }
29. }

复制代码

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

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

为什么？

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

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

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

1.无参

2.有参

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

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

5.this、super关键字

1.this（就一局部变量）

明白为一个变量，表现当火线法调用的地点值。
2.super

代表父类存储空间。

3.this访问本类方法

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

4.实例

1.Empolyee

1. package a04loopextendsdemo4;
3. public class Employee {
4.     //1.类名见名知意
5.     //2.所有的成员变量都需要私有
6.     //3.构造方法（空参 带全部参数的构造）
7.     //4.get/set方法
9.     private String id;
10.     private String name;
11.     private double salary;
13.     public Employee() {
14.     }
16.     public Employee(String id, String name, double salary) {
17.         this.id = id;
18.         this.name = name;
19.         this.salary = salary;
20.     }
22.     /**
23.      * 获取
24.      * @return id
25.      */
26.     public String getId() {
27.         return id;
28.     }
30.     /**
31.      * 设置
32.      * @param id
33.      */
34.     public void setId(String id) {
35.         this.id = id;
36.     }
38.     /**
39.      * 获取
40.      * @return name
41.      */
42.     public String getName() {
43.         return name;
44.     }
46.     /**
47.      * 设置
48.      * @param name
49.      */
50.     public void setName(String name) {
51.         this.name = name;
52.     }
54.     /**
55.      * 获取
56.      * @return salary
57.      */
58.     public double getSalary() {
59.         return salary;
60.     }
62.     /**
63.      * 设置
64.      * @param salary
65.      */
66.     public void setSalary(double salary) {
67.         this.salary = salary;
68.     }
70.     public String toString() {
71.         return "Employee{id = " + id + ", name = " + name + ", salary = " + salary + "}";
72.     }
74.     //工作
75.     public void work(){
76.         System.out.println("员工在工作");
77.     }
78.     //吃饭
79.     public void eat(){
80.         System.out.println("员工在吃饭");
81.     }
82. }

复制代码

2.Manager

1. package a04loopextendsdemo4;
3. public class Manager extends Employee{
4.     private double bonus;
6.     //空参
7.     public Manager() {
9.     }
11.     //带全部参数的构造
12.     public Manager(String id, String name, double salary, double bonus) {
13.         super(id, name, salary);
14.         this.bonus = bonus;
15.     }
16.     //get/set方法
17.     public double getBonus() {
18.         return bonus;
19.     }
20.     public void setBonus(double bonus) {
21.         this.bonus = bonus;
22.     }
23.     @Override
24.     public void work() {
25.         System.out.println("管理其他人");
26.     }
28. }

复制代码

3.Cook

1. package a04loopextendsdemo4;
3. public class Cook extends Employee{
4.     public Cook() {
6.     }
7.     public Cook(String id, String name, double salary) {
8.         super(id, name, salary);
9.     }
10.     @Override
11.     public void work() {
12.         System.out.println("炒菜");
13.     }
14. }

复制代码

4.Test

1. package a04loopextendsdemo4;
3. public class Test {
4.     public static void main(String[] args) {
5.         //创建对象并赋值调用
6.         Manager  m= new Manager("001","张三",10000,8000);
7.         System.out.println(m.getId()+","+m.getName()+
8.                 ","+m.getSalary()+ ","+m.getBonus());
9.         m.work();
10.         m.eat();
12.         Cook c = new Cook();
13.         c.setId("002");
14.         c.setName("李四");
15.         c.setSalary(20000);
16.         System.out.println(c.getId()+","+c.getName()+
17.                 ","+c.getSalary());
18.         c.work();
19.         c.eat();
20.     }
21. }

复制代码