javase-10.继承

用户11369350

发布于 2024-11-19 18:44:59

1260

文章被收录于专栏：Java,后端开发,网站开发,数据结构,算法分析.Java,后端开发,网站开发,数据结构,算法分析.

1.继承

1.1什么是继承,为什么需要继承?

继承 (inheritance) 机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能 ，这样产生新的类，称 派生类 。继承呈现了面向对象程序设计的层次结构, 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用 。

public class Dog{
    String name;
    int age;
    float weight;
    public void eat() {
        System.out.println(name+ "正在吃饭");
    }

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

    public void brak() {
        System.out.println(name+ "汪汪汪~~~");
    }
}

public class Cat{
    String name;
    int age;
    float weight;
    public void eat(){
        System.out.println(name + "正在吃饭");
    }
    public void sleep()
    {
        System.out.println(name + "正在睡觉");
    }
    public void mew(){
        System.out.println(name + "喵喵喵~~~");
    }
}

观察上述代码发现,猫和狗的类中存在大量重复的代码

比如:name,age,weight,eat(),sleep().

继承就是专门用来进行共性抽取,实现代码复用的.

1.2继承的语法格式

在Java中如果要表示类之间的继承关系,需要借助extends关键字.

修饰符 class 子类 extends 父类 {

// ...

}

// Animal.java
public class Animal {
    String name;
    int age;

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

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

}

// Dog.java 
public class Dog extends Animal{
    public Dog() {
        super();
    }

    void bark() {
        System.out.println(name+ "汪汪汪~~~");
    }


}

// Cat.Java 
public class Cat extends Animal{
    public Cat() {
        super();
    }

    void mew() {
        System.out.println(name+ "喵喵喵~~~");
    }
}

注意：

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

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

1.3访问父类成员

1.3.1子类中访问父类的成员变量

1.当子类和父类不存在同名变量时

public class Animal {
    String name;
    int age;
}

public class Dog extends Animal{
    double weight;
    String color;


    public Dog(String name,int age,double weight,String color) {
        this.name = name;//从父类中继承下来的name
        this.age = age;//从父类中继承下来的age
        this.weight = weight;
        this.color = color;
    }
}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog("阿狗",3,20.5,"黑色");
        //dog类中并没有定义任何成员变量,name和age属性是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        System.out.println(dog.weight);
        System.out.println(dog.color);
    }
}

2.当子类和父类存在同名变量时

public class Animal {
    String name;
    int age;
    int a = 3;
}

public class Dog extends Animal{
    double weight;
    String color;
    int a = 0;
    
    public void method() {
        System.out.println(a);//此时a是访问父类继承的a还是子类自己的a呢?
    }

}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.method();//输出结果为0,说明method()中的a是子类自己的
    }
}

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

如果访问的成员变量子类中有，优先访问自己的成员变量。

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

如果访问的成员变量与父类中成员变量同名，则优先访问自己的。

总结就是一句话:就近原则,先找自己的,再找父类的.

1.3.2子类中访问父类的成员方法

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

    public void methodB() {
        System.out.println("父类中的B方法");
    }

}

public class Dog extends Animal{
    double weight;
    String color;

    public void methodA(int a) {
        System.out.println("子类中的A(a)方法");
    }

    public void methodB() {
        System.out.println("子类中的B方法");
    }

    public void methodC() {
        methodA();
        methodA(2);
        methodB();
//输出结果:
父类中的A方法
子类中的A(a)方法
子类中的B方法
    }

}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.methodC();
    }
}

【说明】

通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。

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

在父类成员变量与子类成员变量相同时,想要访问父类成员变量时该如何访问呢?

1.4super关键字

如果要在子类方法中访问父类同名成员时，该如何操作？直接访问是无法做到的，Java 提供了 super 关键字，该关键字主要作用：在子类方法中访问父 类的成员 。

public class Animal {
    String name = "父类";
    int age = 1;
    public void methodA() {
        System.out.println("父类中的A方法");
    }

    public void methodB() {
        System.out.println("父类中的B方法");
    }

}

public class Dog extends Animal{
    String name = "子类";
    int age = 2;

    public void methodA(int a) {
        System.out.println("子类中的A(a)方法");
    }

    public void methodB() {
        System.out.println("子类中的B方法");
    }

    public void methodC() {
        System.out.println(name);//访问子类的name,
        System.out.println(age);//访问子类的age
        System.out.println(super.name);//访问父类的name
        System.out.println(super.age);//访问父类的age
    }

}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.methodC();
    }
}

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

【 注意事项 】

1. 只能在非静态方法中使用

2. 在子类方法中，访问父类的成员变量和方法 。

1.5子类构造方法

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

public class Animal {

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

}
public class Dog extends Animal{

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

}
public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog();

    }
}
//输出结果为:父类构造方法
            子类构造方法
说明先调用了基类(父类)构造方法，然后执行子类的构造方法。

注意：

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

public Dog() {
    //super();super();没写时,Java在第一行默认有隐含的super();
    System.out.println("子类构造方法");
}

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

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

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

1.6super和this

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

相同点:

1.都是Java中的关键字

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

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

区别:

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

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

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

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

1.7初始化

public class Animal {
    public int age;
    public Animal(int age) {
        this.age = age;
        System.out.println("构造方法");
    }

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

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



}

public class TestExtend {
    public static void main(String[] args) {  
Animal animal1 = new Animal(2);
System.out.println("==================");
Animal animal2 = new Animal(2);

    }
}
//输出结果
静态代码块
实例代码块
构造方法
==================
实例代码块
构造方法

1. 静态代码块先执行，并且只执行一次，在类加载阶段执行

2. 当有对象创建时，才会执行实例代码块，实例代码块执行完成后，最后构造方法执行

继承关系上的执行顺序

public class Animal {
    public int age;
    public Animal(int age) {
        this.age = age;
        System.out.println("构造方法");
    }

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

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

public class Dog extends Animal{
    public Dog(int age) {
        super(age);
        System.out.println("子类构造方法");
    }

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

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

}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog1 = new Dog(2);
        System.out.println("==================");
        Dog dog2 = new Dog(2);
    }
}
//输出结果:
静态代码块
子类静态代码块
实例代码块
构造方法
子类实例代码块
子类构造方法
==================
实例代码块
构造方法
子类实例代码块
子类构造方法

得出结论:

1.父类静态代码块优先于子类静态代码块执行,且是最早执行

2.父类示例代码块和父类构造方法紧接执行

3、子类的实例代码块和子类构造方法紧接着再执行

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