Think In Java笔记（四）

1.继承中，当new出子类，父类的构造器会先被调用，接着才是子类。

Execise5

package reuse;

public class Exercise05 extends A {
    private B b = new B();
    public static void main(String[] args) {
        new Exercise05(); //output A B
    }
}

class A{
    A(){
        System.out.println("A");
    }
}

class B{
    B(){
        System.out.println("B");
    }
}

2.如果父类是有参的，那么调用父类的构造器时需要使用super(variable)。

Exercise8

package reuse;


class X{
    X(int i){
        System.out.println("X");
    }
}

public class Exercise08 extends X{
    Exercise08(int j){
        super(1);
        System.out.println("with arg");
    }
    Exercise08(){
        super(2);
        System.out.println("with no arg");
    }
    public static void main(String[] args) {
        new Exercise08(1);
        new Exercise08();
    }
}

Exercise9

public class Exercise09 extends Root {
    Exercise09(){
        System.out.println("Exercise09");
        Component1 c1 = new Component1();
        Component2 c2 = new Component2();
        Component3 c3 = new Component3();
    }
    public static void main(String[] args) {
        new Exercise09();
    }
}

class Component1{
    Component1(){
        System.out.println("Component1");
    }
}

class Component2{
    Component2(){
        System.out.println("Component2");
    }
}

class Component3{
    Component3(){
        System.out.println("Component3");
    }
}

class Root{
    Root(){
        System.out.println("Root");
        Component1 c1 = new Component1();
        Component2 c2 = new Component2();
        Component3 c3 = new Component3();
    }
}

3.清除对象的顺序应该与创建对象的顺序相反。

4.在java中，如果父类有多个重载的方法，在子类中重新定义这个方法相当于继承了这些重载方法，并不会消失。

可以使用@override来检查是否重写正确。

package c05;

public class Exercise13 extends A{
    @Override void g(String a) { 
        System.out.println("g(String)");
    }
    public static void main(String[] args) {
        Exercise13 e = new Exercise13();
        e.g(1);
        e.g('c');
        e.g(1.0f);
        e.g("a"); //output:The method g(String) of type Exercise13 must override or implement a supertype method
    }
}

class A{
    void g(int i) {
        System.out.println("g(i)");
    }
        
    void g(char i) {
        System.out.println("g(j)");
    }
    void g(float i) {
        System.out.println("g(k)");
    }
}

5.protected方法仅包内的继承子类可用。

package c05;

public class Exercise15 extends G {
    public void change(int set) {
        set(set);
    }
    public String toString() {
        return super.toString();
    }
    public static void main(String[] args) {
        Exercise15 e = new Exercise15();
        System.out.println(e);
        e.change(1);
        System.out.println(e);
    }
}

class G{
    private int i;
    protected void set(int j) {
        i = j;
    }
    public G() {
        System.out.println("A");
    }
    public String toString() {
        return "A set to" + i;
    }
}

6.upcasting 

Exercise16

package c05;

public class Frog extends Amphibian{
    public static void main(String[] args) {
        Frog a = new Frog();
        Amphibian.jump(a);
    }
}

class Amphibian{
    static void jump(Amphibian a) {
        System.out.println("Amphibian works");
    }
}

7.fina 关键字。对基本数据类型来说，final相当于常数。final static相当于这一片存储空间无法被改变。引用前加static说明此引用无法指向另一个对象。如果final的数据在数据成员区域未初始化，则在构造器里必须执行初始化。也能为参数列表赋值为final，同样的，赋值为final的参数就不能改变了。
8.final和private,overriding只有在方法时是父类的接口的时候才会发生。如果方法时private，那么此方法不属于类的接口，只是隐藏在类中的代码。如果你在子类中“override”这个方法（实际并没有），你只是新建了一个同名的方法。

9.final类，即无法继承。

10.首先，载入class文件，其次由父类开始一级一级往下初始化static。接着创造对象，所有基本数据都被初始化，所有对象句柄初始化为null，基类的构造器启动，实例变量按照语句顺序执行，最后就是剩余的部分执行。