JAVA-继承(CSDN最详细的)

最新推荐文章于 2024-09-04 18:15:00 发布

Lizhihao＿

最新推荐文章于 2024-09-04 18:15:00 发布

阅读量2.7k

点赞数 36

文章标签： java 开发语言

本文链接：https://blog.csdn.net/Lizhihao_/article/details/140948653

版权

一、JAVA中继承的概念

在生活中我们都知道继承的意思，那么在JAVA中继承是怎么体现的呢？

class Cat{
    public String name;
    public int age;
    public String color;

    public void eat(){
        System.out.println(name + "正常吃饭");
    }

    public void sleep(){
        System.out.println(name + "正在睡觉");
    }

    public void bark(){
        System.out.println(name + "正在喵喵喵");
    }

}

class Dog{
    public String name;
    public int age;
    public String color;

    public void eat(){
        System.out.println(name + "正常吃饭");
    }

    public void sleep(){
        System.out.println(name + "正在睡觉");
    }

    public void bark(){
        System.out.println(name + "正在汪汪汪");
    }

}

public class test {

    public static void main(String[] args) {
        //实例化对象
        Dog dog = new Dog();
        Cat cat = new Cat();

        dog.name = "大黄";
        dog.color = "黄色";
        dog.age = 3;
        dog.eat();
        dog.sleep();
        dog.bark();
        System.out.println("===========");

        cat.name = "小灰灰";
        cat.color = "灰白";
        cat.age = 1;
        cat.eat();
        cat.sleep();
        cat.bark();


    }
}

运行结果：

可以明显感觉到，有太多重复的代码：

此时，就可以体现出继承的好处了：

二、继承的语法

在Java中如果要表示类之间的继承关系，需要借助extends关键字,情况如下：

修饰符 class 子类 extends 父类{
    //……
}

升级后的代码：

class Animal{
    public String name;
    public int age;
    public String color;

    public void eat(){
        System.out.println(name + "正常吃饭");
    }

    public void sleep() {
        System.out.println(name + "正在睡觉");
    }
}



class Cat extends Animal{

    public void bark(){
        System.out.println(name + "正在喵喵喵");
    }

}

class Dog extends Animal{

    public void bark(){
        System.out.println(name + "正在汪汪汪");
    }

}

public class test {

    public static void main(String[] args) {
        //实例化对象
        Dog dog = new Dog();
        Cat cat = new Cat();

        dog.name = "大黄";
        dog.color = "黄色";
        dog.age = 3;
        dog.eat();
        dog.sleep();
        dog.bark();
        System.out.println("===========");

        cat.name = "小灰灰";
        cat.color = "灰白";
        cat.age = 1;
        cat.eat();
        cat.sleep();
        cat.bark();
        
    }
}

结果:

注意：

1. 子类会将父类中的成员变量或者成员方法继承到子类中了

2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与父类的不同，否则就没有必要继承了

三、父类成员访问

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

class Base{
    int a;
    int b;
}

class Derived extends Base{
    int c;
    {
        a = 10;//访问父类继承下来的a
        b = 20;//访问父类继承下来的b
        c = 30;//访问父类继承下来的c
    }
}

2.子类和父类存在同名的成员变量

class Base{
    int a;
    int b;
    int c;
}

class Derived extends Base{
    String a;
    char b;
    public Derived(){
        a = "A";//访问的是子类自己的a
        b = 'B';//访问的是子类自己的b
        c = 30;//访问的是父类的成员变量
    }
}

在子类方法中或者通过子类对象访问成员时：

如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

3. 子类和父类成员方法名字不同

class Base{
    public void methodA(){
        System.out.println("父类的方法");
    }
}

class Derived extends Base{
   public void methodB(){
       System.out.println("子类的方法");
   }

   public void methodC(){
       methodA();
       methodB();
   }
}


public class test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.methodC();
    }
}

结果：

4.子类和父类成员方法名相同

class Base{
    public void methodA(){
        System.out.println("父类的方法A");
    }
    public void methodB(){
        System.out.println("父类的方法B");
    }
}

class Derived extends Base{
    public void methodA(int a){
        System.out.println("子类的方法A " + a);
    }
   public void methodB(){
       System.out.println("子类的方法B");
   }

   public void methodC(){
        methodA();//访问父类的方法
        methodA(20);//访问子类的方法
        methodB();//访问子类的方法
   }
}

public class test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.methodC();
    }
}

结果：

总结：

通过子类对象访问父类与子类中不同名方法时，优先在子类中找。找到则访问，否则在父类中找，找到则访问。
通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问。
如果父类和子类都没有此方法则报错。

那么有没有，在有相同名字的方法或者变量的时候，去访问父类的呢。答案是有的需要借助super关键字

四、super关键字

由于设计不好，或者因场景需要，子类和父类中可能会存在相同名称的成员，如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java提供了super关键字，该关键字主要作用：在子类方法中访问父类的成员。

class Base{
    int a;
    int b;
    public void methodA(int a){
        System.out.println("父类的方法A "+ a);
    }
    public void methodB(){
        System.out.println("父类的方法B");
    }
}

class Derived extends Base{
    char a;
    char b;
    public void methodA(){
        System.out.println("子类的方法A");
    }
   public void methodB(){
       System.out.println("子类的方法B");
   }

   public void methodC(){
        //
        a = 'A';//访问子类的a
        b = 'B';//访问子类的b

       super.a = 10;//访问父类的a
       super.b = 20;//访问父类的b

       methodA(100);//访问父类的方法,主要原因是重载
       super.methodB();//用super关键字，访问父类的方法
       
       methodA();//访问子类的方法
       methodB();//访问父类的方法

   }
}

public class test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.methodC();
    }
}

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

下面还会将一种在子类构造方法中super的另一种用法。

注意事项：

只能在非静态的方法中使用，非静态代码块中使用

五、子类的构造方法

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

什么意思呢？刚刚怎么没有什么父类子类的构造方法，最多只是有点子类的构造方法，哪里来的父类的构造方法？

其实是有的，默认存在无需你添加：

子类构造方法中的 super()；是用来调用父类构造方法的。并且super()必须在第一句。

他们都默认存在，是隐式的。

并且，如开始所说父子父子，先有父才有子。

所以调用子类，会先调用父类的构造方法，再调用子类的构造方法。

原因是：子类对象中成员是有两部分组成的，父类继承下来的以及子类新增加的部分 。所以在构造子类对象时候，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整。

class Animal{

    public Animal(){
        System.out.println("父类构造方法");
    }

}

class Cat extends Animal{

    public Cat(){
        //super();   如果父类的构造方法是无参的，那么会默认存在一个super();
        System.out.println("子类构造方法");
    }
}

public class test {
    public static void main(String[] args) {
            Cat cat = new Cat();
    }

}

结果：

如果带有参数

如果参数不对则编译失败。

而且，只要你父类自己有了一个构造方法，java就不会再给你提供一个默认的构造方法了：

注意：

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法

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

3. 在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。

4. super(...)只能在子类构造方法中出现一次，并且不能和this同时出现

六、 super和this的区别

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

【相同点】

1. 都是Java中的关键字

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

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

【不同点】

1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用

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

3. 在构造方法中：this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现

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

七、初始化

一般情况下大部分都用构造方法初始化，静态的用静态代码块。偶尔可能会用实例代码块。

不过我们需求了解，他们执行时候的顺序。以便我们能更好的运用他们。

class Animal{
    public Animal(){
        System.out.println("父类:构造方法");
    }

    {
        System.out.println("父类:实例代码看");
    }

    static {
        System.out.println("父类:静态代码块");
    }
}

class Cat extends Animal{
    public Cat(){
        System.out.println("子类:构造方法");
    }

    {
        System.out.println("子类:实例代码块");
    }

    static {
        System.out.println("子类:静态代码块");
    }

}

public class test {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        System.out.println("===============");
        Cat cat2 = new Cat();
    }
}

结果：

根据代码分析：

最早的是父类的静态代码块，紧接着是子类的静态代码块。
父类实例代码块和父类构造方法紧接着执行
子类的实例代码块和子类构造方法紧接着再执行
第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

八、继承方式

但在Java中只支持以下几种继承方式：

注意：Java中不支持多继承。

时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂.

但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.

如果想从语法上进行限制继承, 就可以使用 final 关键字