【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();//静态内部类对象
    }
}