【Java初阶】面向对象三大特性之继承

╰+攻爆jí腚メ 2024-03-30 09:31 73阅读 0赞

## 一、继承 ##

理解继承

> Cat继承了Animal类，其中：Animal类称为父类/基类或超类，Cat可以称为Animal的 子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可
> 
> Java中不支持多继承，仅支持A extends B 单继承//A extends B B extends C 多层继承 //A extends C B extends C 不同类继承自同一类。

public class TestExtend {
        public static void main(String[] args) {
           Dog d1 =new Dog();
           d1.name = "xiaocs";
           d1.age = 15;
           Cat c1 = new Cat();
           c1.color = "red";
           c1.type = "波斯";
           c1.friendly();
        }
    }
    /**
    *    Dog未继承animal则无法调用animal中的成员变量和成员方法
    */
    class Dog{
        public  int age;
    
        public String  name;
        
        public void shot(){
            System.out.println("汪汪汪");
        }
    }
    //cat可以直接调用animal中的成员变量和成员方法
    class Cat extends animal{
        public int weight;
    
        public String sex;
        
        public void eat(){
            System.out.println("嘎嘎吃");
        }
    
    }
    class animal{
        public String  color;
    
        public String type;
        
        public void friendly(){
            System.out.println("对人类友好");
        }
    
    }

子类访问父类

子类和父类不存在同名成员变量

public class Base {
        int a;
        int b;
    }
    public class Derived extends Base{
        int c;
        public void method(){
            a = 10; // 访问从父类中继承下来的a
            b = 20; // 访问从父类中继承下来的b
            c = 30; // 访问子类自己的c
        }

子类和父类成员变量同名

public class Base {
        int a;
        int b;
        int c;
    } 
    
    public class Derived extends Base{
        int a; // 与父类中成员a同名，且类型相同
        char b; // 与父类中成员b同名，但类型不同
        public void method(){
            a = 100; 
            b = 101; 
            c = 102; // 子类没有c，访问的肯定是从父类继承下来的c
         // d = 103; // 编译失败，因为父类和子类都没有定义成员变量b
        }
    }

> 成员变量访问遵循就近原则，自己有优先自己的，与父类同名也优先访问自己的，如果没有则向父类中找。
> 
> 成员方法亦然，如果子类有则先访问子类的，子类没有先访问父类的，如果存在方法重载，则根据引用的情况，选择合适的方法

在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可

## 二、super关键字 ##

当父类和子类的成员变量或成员方法相同时，调用父类的成员变量或方法，使用super关键字

class Cat extends animal{
        public int color;
    
        public String type;
    
        public void eat(){
        
        //调用父类的成员变量
            super.color = "red";
            super.type = "波斯";
            super.friendly();
            System.out.println("嘎嘎吃");
        }
    
    }
    class animal{
        public String  color;
        public String type;
    
        public void friendly(){
            System.out.println("对人类友好");
        }
    }
    
    子类的构造方法(无参数)
    
    若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
    
    public class TestExtend {
        public static void main(String[] args) {
            Cat c = new Cat();
        }
    }
    class Cat extends animal{
        public int size;
        public String name;
    
        public Cat(){
            // super(); 
                       //注意子类构造方法中默认会调用基类的无参构造方法：super(), 
                       // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
                       // 并且只能出现一次
            System.out.println("Cat::");
        }
        public void eat(){
            System.out.println("嘎嘎吃");
        }
    
    }
    class animal{
        public String  color;
        public String type;
    
        public animal() {
            System.out.println("animal::");
        }
        public void friendly(){
            System.out.println("对人类友好");
        }
    }

![91d674b6eb62a803a8c484dfa0db0d2d.png][]

> 子类对象构造时，需要先调用父类构造方法，然后执行子类的构造方法。

子类的构造方法(有参数)

如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则会编译失败

public class TestExtend {
       public static void main(String[] args) {
           Cat c = new Cat("red","波斯",45,"xiaos");
       }
    }
    class Cat extends animal{
       public int size;
       public String name;
    
       public Cat(String color, String type, int size, String name) {
           super(color, type);
           this.size = size;
           this.name = name;
       }
       public void eat(){
           System.out.println("嘎嘎吃");
       }
    }
    class animal{
       public String  color;
       public String type;
    
       public animal(String color, String type) {
           this.color = color;
           this.type = type;
       }
       public void friendly(){
           System.out.println("对人类友好");
       }
    
    }

> 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
> 
> super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

## ✅super和this之间的区别？ ##

相同点：

1.都属于java 中的关键字

2.只能在类的非静态方法中使用，用来访问 非静态的方法和字段

3.在构造 方法中使用时必须是构造方法当中的第一条语句，并且二者不能同时存在

不同点：

1.this指的是当前对象的引用，super指的是当前对象对父类部分对象的使用

在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

在构造方法当中，this用于调用本类的构造方法，super调用父类的构造方法，两种调用不能同时在构造方法中出现

构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

## 三、继承关系下的代码块 ##

public class TestExtend {
        public static void main(String[] args) {
            Cat c = new Cat("red","波斯",45,"xiaos");
        }
    }
    class Cat extends animal{
        public int size;
        public String name;
        //5.子类的实例代码块
        {
            System.out.println("cat::实例");
        }
        //2.子类的静态代码块
        static{
            System.out.println("cat::static");
    
        }
        //6.子类的构造方法
        public Cat(String color, String type, int size, String name) {
            super(color, type);
            this.size = size;
            this.name = name;
            System.out.println("cat::构造");
        }
        public void eat(){
            System.out.println("嘎嘎吃");
        }
    }
    class animal{
        public String  color;
        public String type;
    
        //3.父类的实例代码块
        {
            System.out.println("animal::实例");
        }
        //1。父类的静态代码块
        static{
            System.out.println("animal::static");
    
        }
        //4.父类的构造方法
        public animal(String color, String type) {
            this.color = color;
            this.type = type;
            System.out.println("animal::构造");
        }
        public void friendly(){
            System.out.println("对人类友好");
        }

![4a6baf531172c8c9db6b35b325714215.png][]

根据执行结果可以的出以下结论：

> 父类的静态代码块>>子类的静态代码块>>父类的实例代码块>父类的构造方法>>子类的实例代码块>> 子类的构造方法

第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

## 四、protected关键字 ##

访问限定：同一个包中的类和不同包中的子类

package TestDemo2;
    
    public class B {
        private int a;
        protected int b;
        public int c;
        int d;
    }

在不同包中即package TestDemo 中

![54388012672bcf5ae846161365bb8246.png][]

只有public和protected修饰的成员可以访问

## 五、final关键字 ##

修饰变量时： 表示常量即不能修改

final int a = 10; 
    a = 20; // 编译出错

修饰类时： 表示此类不能被继承，即不能作为父类

//final修饰
    final class animal{
        public String  color;
        public String type;
        public animal(String color, String type) {
            this.color = color;
            this.type = type;
            System.out.println("animal::构造");
        }
    }

[91d674b6eb62a803a8c484dfa0db0d2d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/f6d68341e5924037a01029baf95ec5af.png
[4a6baf531172c8c9db6b35b325714215.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7cffbb8d29d64dc1a95542b6a956c3e0.png
[54388012672bcf5ae846161365bb8246.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/22e8e6fc16ed436db180645f86ade682.png