java 继承与构造函数

这方面总是有点混乱，还是开博客记录一下。

简单来说， 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代码如下

所以，不管子类集成父类，不管有参构造还是无参构造，都会先初始化父类

继承与无参构造函数

1. 在无参实例化子类时，无论如何都会先调用父类的无参构造函数，前提是构造函数为 Public。
2. 父类实例变量为 private 时，子类无法继承父类实例变量。如果父类存在 getter 与 setter 方法，则可调用 super.get()调用父类 private 实例变量。

继承与有参构造

1. 在实例化 B 的有参构造中，如果 B Super()必须在第一行 继承了 A 的有参构造函数，则会先调用 A 的有参构造器，再调用 B 的有参构造器。

2. 如果 B 没有选择继承 A 的有参构造器，则在实例化 B 的过程中，会先调用 A 的无参构造函数。

• A

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class A {
    private String name;
    private String pwd;
    private int count;

    public A(String name, String pwd) {
        System.out.println("A的有参构造");
        this.name = name;
        this.pwd = pwd;
    }

    public A() {
        System.out.println("A的无参构造");
        name = "A";
        pwd = "B";
    }
}

• B

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class B extends A {
    private int b;

    public B() {
        System.out.println("B的无参构造");
    }

    public B(String name, String pwd, int b) {
        super(name, pwd);
        this.b = b;
    }

    public B(int b, String a, String c) {

        this.b = b;
        System.out.println("B的有参构造");
    }
}

继承中的 private final

1. 父类中被 private 修饰的方法 表示该方法只能在父类中可见，子类不可调用。若子类中定义了一个与父类的 private 方法相同的方法，运行编译都没有问题，相当于子类自己定义了一个方法而已。

2. 父类中被 final 修饰的方法 表示该方法不可以被子类重写。直接继承父类中的方法，调用也是直接调用父类的方法。

3. 同时被 private 与 final 修饰 与 private 类似

protect

public > proteced > 默认 > private

1. protect 包内可见，子类可见。 若 A 和 B 在同一个包下：在 B 类中是可以通过 A 直接访问 A 中的 protect 属性 若 A 和 B 在同一个包下，并且 B 继承于 A：在 B 类中也是可以直接访问 A 中的 protect 属性 若 A 和 B 不在同一个包下：在 B 类中是不可以通过 A 来访问 A 中的 protect 属性 若 A 和 B 不在同一个包下，并其 B 继承于 A：在 B 类中是可以访问到 A 中的 protect 属性

接口问题的一点记录

1.接口中的成员变量

接口只是对一类事物的属性和行为更高层次的抽象，所以接口中的属性必然是常量，只能读不能改。

1
2
3

    public static final int i = 3;
    // 类似于
    int i = 3;

2.接口中的默认方法

1
2
3
4

    // 默认方法
    default void method2(){
        System.out.println("method2 ..  默认方法");
    }

子类直接继承，也可以重写。 多继承的菱形问题 当一个子类实现多个父类时，如果多个父类都有一个同名方法，则子类必须重写该方法。

接口中的静态

1
2
3
4

    static void method3(){
        System.out.println("this is a static method");
    }

静态方法，子类不可重写。