【258天】我愛刷題系列（17）

叨叨兩句

1. 人生沒有白走的路，每一步都算數。
2. 內心想什麼，就能看到什麼，奇了！
3. 今天在鍛鍊這件事上，有一個100千米的里程碑！

牛客網——java專項練習001

1. 類中的數據域使用private修飾爲私有變量，因此任何方法均不能訪問它。（錯誤）

反射和本類方法都可調用。

1. 如下代碼執行的結果是什麼？

public class Demo {
    public static void main(String[] args) {
        Collection<?>[] collections = 
    {new HashSet<String>(), new ArrayList<String>(), new HashMap<String, String>().values()};
                    Super subToSuper = new Sub();
                    for(Collection<?> collection: collections) {
        System.out.println(subToSuper.getType(collection));
    }
    }
    abstract static class Super {
        public static String getType(Collection<?> collection) {
            return 「Super:collection」;
    }
    public static String getType(List<?> list) {
            return 「Super:list」;
    }
    public String getType(ArrayList<?> list) {
            return 「Super:arrayList」;
    }
    public static String getType(Set<?> set) {
            return 「Super:set」;
    }
    public String getType(HashSet<?> set) {
            return 「Super:hashSet」;
    }
    }
    static class Sub extends Super {
        public static String getType(Collection<?> collection) {
                return "Sub"; }
    }
}

解析

public class A {
    public static String staticStr = "A's static field"; 
    public String nonStaticStr = "A's nonstatic field"; 
    public static void staticMethod(){ 
        System.out.println("A's static method"); 
    } 
    public void nonStaticMethod(){ 
        System.out.println("A's nonstatic method"); 
    } 
} 
public class B extends A{
    public static String staticStr = "B's static field"; 
    public String nonStaticStr = "B's nonstatic field"; 
    public static void staticMethod(){ 
        System.out.println("B's static method"); 
    } 
}
public class C extends A{
   
}
public class Test { 
   
    public static void main(String[] args) { 
        C c = new C(); 
        System.out.println(c.nonStaticStr);  //A's nonstatic field
        System.out.println(c.staticStr);  //A's static field
        c.staticMethod(); //A's static method
        
        System.out.println("-------------------------------"); 
           
        A c1 = new C(); 
        System.out.println(c1.nonStaticStr);  //A's nonstatic field
        System.out.println(c1.staticStr);  //A's static field
        c1.staticMethod(); //A's static method
          
        // 以上這說明java中靜態屬性和靜態方法能夠被繼承
         
        System.out.println("-------------------------------"); 
        B b = new B(); 
        System.out.println(b.nonStaticStr); // B's nonstatic field
        System.out.println(b.staticStr);   //B's static field
        b.staticMethod();  //B's static method
         
        System.out.println("-------------------------------"); 
        A b1 = new B(); 
        System.out.println(b1.nonStaticStr);  //A's nonstatic field
        System.out.println(b1.staticStr);  //A's static field
        b1.staticMethod(); //A's static method
        //b1.nonStaticStr  輸出的是父類的非靜態屬性，說明非靜態屬性不能夠被重寫，不能實現多態
        //b1.staticStr     輸出的是父類的靜態屬性，說明靜態屬性不能夠被重寫，不能實現多態
        //b1.staticMethod()輸出的是父類A的靜態方法，不是子類B改寫後的，因此沒有實現多態
         
         
        //結論是：靜態屬性和靜態方法只是能夠繼承沒有表現出多態性。
        //由於靜態方法和靜態屬性沒有采用動態綁定。具體表現就是，
        //將子類實例向上轉型則會調用到基類中的靜態方法和屬性，
        //不轉型就調用子類自身的靜態方法和屬性。
        //編譯器不推薦經過實例去調用靜態方法和屬性，由於這種調用方式容易形成混淆。
         
        //實際上，在Java的規範中，Java對於類的方法和屬性採用了兩種徹底不一樣的處理機制：
        //對於方法，使用重載機制實現了多態性；對於屬性，使用的是同名屬性隱藏機制。
        //所謂的同名屬性隱藏機制是指：在具備父子關係的兩個類中，
        //子類中相同名字的屬性會使得從父類中繼承過來的同名屬性變得不可見，
        //無論類型是否一致，名稱一致的兩個屬性就是同名屬性。
        //在子類中，沒法簡單地經過屬性名稱來獲取父類中的屬性，
        //而是必須經過父類名稱加屬性名稱(super.變量名)的方法才能夠訪問父類中的該屬性。
        //通常而言，爲了代碼容易閱讀，極其不建議在父類和子類中使用同名屬性。
    } 
   
}

1. 如何建立靜態與非靜態內部類？

public class Enclosingone {
    //非靜態內部類
    public class InsideOne {}
    //靜態內部類
    public static class InsideTwo{}
}
 
class Mytest02{
    public static void main(String args []){
        Enclosingone.InsideOne obj1 = new Enclosingone().new InsideOne();//非靜態內部類對象
        Enclosingone.InsideTwo obj2 = new Enclosingone.InsideTwo();//靜態內部類對象
    }
}