java 子類強轉父類 父類強轉子類

 

Java 繼承

繼承就是子類繼承父類的特征和行為，使得子類對象（實例）具有父類的實例域和方法，或子類從父類繼承方法，使得子類具有父類相同的行為。

 

Java 子類強轉父類

父類引用指向子類對象:

java中子類強轉父類,實際上依然是子類；

該引用只能調用父類中定義的方法和變量；

如果子類中重寫了父類中的一個方法，那么在調用這個方法的時候，將會調用子類中的這個方法；

// A是父類,B是子類
A a = new A();
a.setName("a1");
a.sayA(); // sayA

B b = new B();
b.setName("b1");
b.setSex(true);
b.sayA(); // sayA from B
b.sayB(); // sayB

// Java中的對象進行類型提升，依然保持其原有的類型。
A a2 = (A) b; // 子類強轉父類,其實仍然是子類
System.out.println(a2.toString()); // B [name=b1, age=0, sex=true]
// 該引用只能調用父類中定義的方法和變量； 
// a2.sayB(); // The method sayB() is undefined for the type A 報錯
// 如果子類中重寫了父類中的一個方法，那么在調用這個方法的時候，將會調用子類中的這個方法；
a2.sayA(); // sayA from B a2其實是B,調用的是B方法

 

Java 父類強轉子類

只有父類對象本身就是用子類new出來的時候, 才可以在將來被強制轉換為子類對象.

// B b2 = (B) a; // atest.A cannot be cast to atest.B a是A,轉不成B
// 只有父類對象本身就是用子類new出來的時候, 才可以在將來被強制轉換為子類對象.
B b2 = (B) a2; // a2其實是B,可以轉成B
System.out.println(b2.toString()); // B [name=b1, sex=true]
b2.sayA(); // sayA from B
b2.sayB(); // sayB

 

 

擴展:

對於list也是這樣

List<A> aList = new ArrayList<A>();
aList.add(a);
aList.add(b);
for (A item : aList) {
    System.out.println(item.getClass() + ":" + item.toString());
    // class atest.A:A [name=a1]
    // class atest.B:B [name=b1, sex=true]
}

 

附錄:

　　public class A {

        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public void sayA() {
            System.out.println("sayA");
        }

        @Override
        public String toString() {
            return "A [name=" + name + "]";
        }
    }
    
    public class B extends A {

        private boolean sex;

        public boolean isSex() {
            return sex;
        }

        public void setSex(boolean sex) {
            this.sex = sex;
        }

        @Override
        public void sayA() {
            System.out.println("sayA from B");
            // super.sayA();
        }

        public void sayB() {
            System.out.println("sayB");
        }

        @Override
        public String toString() {
            return "B [name=" + this.getName() + ", sex=" + sex + "]";
        }
    }


    public static void main(String[] args) {

        // A是父類,B是子類
        A a = new A();
        a.setName("a1");
        a.sayA(); // sayA

        B b = new B();
        b.setName("b1");
        b.setSex(true);
        b.sayA(); // sayA from B
        b.sayB(); // sayB

        // Java中的對象進行類型提升，依然保持其原有的類型。
        A a2 = (A) b; // 子類強轉父類,其實仍然是子類
        System.out.println(a2.toString()); // B [name=b1, sex=true]
        // 該引用只能調用父類中定義的方法和變量； 
        // a2.sayB(); // The method sayB() is undefined for the type A 報錯
        // 如果子類中重寫了父類中的一個方法，那么在調用這個方法的時候，將會調用子類中的這個方法；
        a2.sayA(); // sayA from B a2其實是B,調用的是B方法
        // B b2 = (B) a; // atest.A cannot be cast to atest.B a是A,轉不成B
        // 只有父類對象本身就是用子類new出來的時候, 才可以在將來被強制轉換為子類對象.
        B b2 = (B) a2; // a2其實是B,可以轉成B
        System.out.println(b2.toString()); // B [name=b1, sex=true]
        b2.sayA(); // sayA from B
        b2.sayB(); // sayB

        List<A> aList = new ArrayList<A>();
        aList.add(a);
        aList.add(b);
        for (A item : aList) {
            System.out.println(item.getClass() + ":" + item.toString());
            // class atest.A:A [name=a1]
            // class atest.B:B [name=b1, sex=true]
        }

    }