Java_继承

苜—

已于 2022-11-19 15:50:43 修改

阅读量74 java 开发语言

于 2022-11-18 11:51:59 首次发布

本文链接：https://blog.csdn.net/m0_68071216/article/details/127901834

总结：

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

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

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

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

如果想访问父类中与自己同名的成员变量，该如何操作？——用关键字super

2）子类中访问父类的成员方法

成员方法名字不同

成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

class Base {
    public int a;
    public int b;
    public int c = 111;

    public void methodBase() {
        System.out.println("Base");
    }
}
class Derived extends Base {
    public int c = 11;

    public void methodDerived() {
        System.out.println("Derived");
    }
    public void func() {
        methodBase();
        methodDerived();
    }
   
}
public class Test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.func();
    }
}

成员方法名字不同

class Base {
    public int a;
    public int b;
    public int c = 111;

    public void methodBase() {
        System.out.println("Base");
    }
}
class Derived extends Base {
    public int c = 11;
 
    public void methodDerived() {
        System.out.println("Derived");
    }
    public void methodBase() {
        System.out.println("Derived");
    }
    public void func() {
        methodBase();
        methodDerived();
        super.methodBase();
    }
    
}
public class Test2 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.func();
    }
}

【说明】

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

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

3.super关键字

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

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

【注意事项】 1. 只能在非静态方法中使用；2. 在子类方法中，访问父类的成员变量和方法。

this和super都不能在静态方法内使用！！！

4.子类构造方法

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

public class Base {
    public Base(){
        System.out.println("Base()");
    }
}
public class Derived extends Base{
    public Derived(){
        // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
        // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
        // 并且只能出现一次
        System.out.println("Derived()");
    }
}
public class Test {
    public static void main(String[] args) {
        Derived d = new Derived();
    }
}
//结果打印：
//Base()
//Derived()

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

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

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

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

5.super和this

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

【相同点】 1. 都是Java中的关键字；2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段；3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在。

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

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

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

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

6.再谈初始化

class Animal {
    public String name;
    public int age;
    
    static {
        System.out.println("静态代码块-Animal static{}");
    }

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

    public Animal() {
        System.out.println("Animal不带参数的构造方法-Animal()");
    }
    
   
    public void eat() {
        System.out.println(name + "正在吃饭！");
    }
}
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

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

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

    public Dog() {
        //super();//编译器默认帮你加上
        System.out.println("Dog不带参数的构造方法-Dog()");
    }
    
    public void wangwang() {
        System.out.println(name + "正在汪汪叫！");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

以上代码的打印结果是：

通过分析执行结果，得出以下结论：

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

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

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

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

7.protected 关键字

注意：父类中private成员变量虽然在子类中不能直接访问，但是也继承到子类中了!!!

什么时候下用哪一种呢?

我们希望类要尽量做到 "封装", 即隐藏内部实现细节, 只暴露出必要的信息给类的调用者。因此我们在使用的时候应该尽可能的使用比较严格的访问权限。例如如果一个方法能用 private, 就尽量不要用 public；另外, 还有一种简单粗暴的做法: 将所有的字段设为 private, 将所有的方法设为 public，不过这种方式属于是对访问权限的滥用。

8.继承方式

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

9.final 关键字

final关键可以用来修饰变量、成员方法以及类。

1）修饰变量或字段，表示常量(即不能修改)

inal int a = 10; //此时a变成常量，不能再修改，一般变量名会改为大写
a = 20; // 编译出错

2）修饰类：表示此类不能被继承

final public class Animal {
...
}
public class Bird extends Animal {
...
}
// 编译出错
Error:(3, 27) java: 无法从最终com.bit.Animal进行

3）修饰方法：表示该方法不能被重写

4）如果是成员变量定义为final，语法规定必须同时给定一个初始值

10.继承与组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果。组合并没有涉及到特殊的语法 (诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段。

继承表示对象之间是is-a的关系，比如：狗是动物，猫是动物；

组合表示对象之间是has-a的关系，比如：汽车；

汽车和其轮胎、发动机、方向盘、车载系统等的关系就应该是组合，因为汽车是有这些部件组成的。

// 轮胎类
class Tire{
// ...
}
// 发动机类
class Engine{
// ...
}
// 车载系统类
class VehicleSystem{
// ...
}
class Car{
    //此时，在一个类里面，将另一个类作为当前类的属性，叫做组合
    private Tire tire; // 可以复用轮胎中的属性和方法
    private Engine engine; // 可以复用发动机中的属性和方法
    private VehicleSystem vs; // 可以复用车载系统中的属性和方法
// ...
}

// 奔驰是汽车
class Benz extend Car{
// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来
}