Java的一点内容（2）

• 1 面向对象的三个原则 封装性 封装的基本单元是类(class)，类是一个抽象的逻辑结构，而类的对象是一个真实的物理实体；类的目的是封装复杂性，在类内部存在隐藏实现复杂性机制；
  封装(encapsulation) 的两个好处：
  模块化：可以独立于其他对象的源代码进行编写和维护，可以很容易的将对象在系统中传递；
  隐藏信息：其他对象可以通过本对象的一个公共接口进行通信而不影响其他对象；
    继承性 继承是一个对象获得另一个对象的属性的过程，继承机制是一个对象成为一个更具通用类的一个特定实例成为可能，避免了代码的重复编写；
    多态性 (重载overload，方法名相同、参数的个数不同、参数的类型不同、返回的类型不同和覆盖override) ；多态性就是“一种接口，多种方法”，可以为一组相关的动作设计一个通用的接口，其实类的函数的重载就是一种多态的体现；
  4 引入抽象编程的思想； 类的封装就是一种抽象思想

• Java中除了static方法和final方法（private方法本质上属于final方法，因为不能被子类访问）之外，其它所有的方法都是动态绑定，这意味着通常情况下，我们不必判定是否应该进行动态绑定—它会自动发生。

• • final方法会使编译器生成更有效的代码，这也是为什么说声明为final方法能在一定程度上提高性能（效果不明显）。
  • 如果某个方法是静态的，它的行为就不具有多态性：

    class StaticSuper {
        public static String staticGet() {
            return "Base staticGet()";
        }
    
        public String dynamicGet() {
            return "Base dynamicGet()";
        }
    }
    
    class StaticSub extends StaticSuper {
        public static String staticGet() {
            return "Derived staticGet()";
        }
    
        public String dynamicGet() {
            return "Derived dynamicGet()";
        }
    }
    
    public class StaticPolymorphism {
    
        public static void main(String[] args) {
            StaticSuper sup = new StaticSub();
            System.out.println(sup.staticGet());
            System.out.println(sup.dynamicGet());
        }
    
    }
    

    输出：

    Base staticGet()
    Derived dynamicGet()

• 构造函数并不具有多态性，它们实际上是static方法，只不过该static声明是隐式的。因此，构造函数不能够被override。
• 在父类构造函数内部调用具有多态行为的函数将导致无法预测的结果，因为此时子类对象还没初始化，此时调用子类方法不会得到我们想要的结果。

  class Glyph {
      void draw() {
          System.out.println("Glyph.draw()");
      }
      Glyph() {
          System.out.println("Glyph() before draw()");
          draw();
          System.out.println("Glyph() after draw()");
      }
  }
  
  class RoundGlyph extends Glyph {
      private int radius = 1;
  
      RoundGlyph(int r) {
          radius = r;
          System.out.println("RoundGlyph.RoundGlyph(). radius = " + radius);
      }
  
      void draw() {
          System.out.println("RoundGlyph.draw(). radius = " + radius);
      }
  }
  
  public class PolyConstructors {
  
      public static void main(String[] args) {
          new RoundGlyph(5);
  
      }
  
  }
  

  输出：

  Glyph() before draw()
  RoundGlyph.draw(). radius = 0
  Glyph() after draw()
  RoundGlyph.RoundGlyph(). radius = 5

为什么会这样输出？这就要明确掌握Java中构造函数的调用顺序：

（1）在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制0；
（2）调用基类构造函数。从根开始递归下去，因为多态性此时调用子类覆盖后的draw()方法（要在调用RoundGlyph构造函数之前调用），由于步骤1的缘故，我们此时会发现radius的值为0；
（3）按声明顺序调用成员的初始化方法；
（4）最后调用子类的构造函数。

• 只有非private方法才可以被覆盖，但是还需要密切注意覆盖private方法的现象，这时虽然编译器不会报错，但是也不会按照我们所期望的来执行，即覆盖private方法对子类来说是一个新的方法而非重载方法。因此，在子类中，新方法名最好不要与基类的private方法采取同一名字（虽然没关系，但容易误解，以为能够覆盖基类的private方法）。
• Java类中属性域的访问操作都由编译器解析，因此不是多态的。父类和子类的同名属性都会分配不同的存储空间，如下：

  // Direct field access is determined at compile time.
  class Super {
      public int field = 0;
      public int getField() {
          return field;
      }
  }
  
  class Sub extends Super {
      public int field = 1;
      public int getField() {
          return field;
      }
      public int getSuperField() {
          return super.field;
      }
  }
  
  public class FieldAccess {
  
      public static void main(String[] args) {
          Super sup = new Sub();
          System.out.println("sup.filed = " + sup.field +
                  ", sup.getField() = " + sup.getField());
          Sub sub = new Sub();
          System.out.println("sub.filed = " + sub.field +
                  ", sub.getField() = " + sub.getField() +
                  ", sub.getSuperField() = " + sub.getSuperField());
      }
  
  }
  

  输出：

  sup.filed = 0, sup.getField() = 1
  sub.filed = 1, sub.getField() = 1, sub.getSuperField() = 0

  Sub子类实际上包含了两个称为field的域，然而在引用Sub中的field时所产生的默认域并非Super版本的field域，因此为了得到Super.field，必须显式地指明super.field。