java编程思想学习笔记4

复用类
  复用类的两种方法：
  第一：在新的类里直接创建旧的类的对象。这是“合成”
  第二：创建一个新的类，与原来那个类同属一种类型的类。它全盘接受旧类的形式，在没有对它做修改的情况下往里面添加了新的代码。这是“继承” 
   合成和继承在做法上有许多相似之处。
  基类的初始化
      要创建一个派生类的对象已经不是一个类的事情了，它会牵涉到两个类---基类和派生类。当我们要创建一个派生类的对象的时候，我们不仅要初始化派生类，基类子对象的正确初始化也是非常重要的，而且也只有一个办法能保证这一点：调用基类的构造函数来进行初始化，Java会让派生类的构造函数自动地调用基类的构造函数。下面这段程序就演示了它在三级继承体系下是如何运作的：
---------------------------------------------------------------------
public class Art
{
  Art(){
      System.out.println("Art constructor");
  }
};
class  Drawing extends Art
{
Drawing(){
   System.out.println("Drawing constructor");
}
}
public class  Cartoon extends Drawing
{
public Cartoon(){
    System.out.println("Cartoon constructor");
}
public static void main(String[] args){
    Cartoon x  = new Cartoon();
}
};
运行cartoon后台打印出的数据是：
Art constructor
Drawing constructor
Cartoon constructor

-----------------------------------------------------------------
Protected
   在理想得情况下private关键词已经够用了，但是在实际的项目中，我们有时会碰到要让一些东西对外部世界隐藏，但是却要对它的继承类开发，protected关键词就是这种实用主义的体现。
最好的做法是，将数据成员设成private的；你应该永远保留修改底层实现的权利，然后用protected权利的方法来控制继承类的访问权限；


Final关键词
    Final的三种用途：数据，方法，类
Final的数据: 在java中定义final常量时，其类型必须是primitive型的。
      Final 是在创建对象的时候进行初始化的；
      Static final 是在装载类的时候初始化的；
      Public class FinalTest(){
         Private static Random rand = new Random();
         Private final int VAL_ONE = rand.nextInt(20);
         Public static final int VAL_TWO = rand.nextInt(20);
        
         Public static void main(String[] args){
           FinalTest t1 = new FinalTest();
           FinalTest t2 = new FinalTest();
           System.out.println(“t1.VAL_ONE=”+ t1.VAL_ONE);
System.out.println(“t2.VAL_ONE=”+ t2.VAL_ONE);

           System.out.println(“t1.VAL_ TWO =”+ t1.VAL_ TWO);
System.out.println(“t2.VAL_ TWO =”+ t2.VAL_ TWO);

}
}
//结果：
t1.VAL_ONE 和t2.VAL_ONE的值不同
t1.VAL_ TWO和t2.VAL_ TWO的值相同

类的装载：总的莱说“类的代码会在它们第一次使用的时候装载”.(类的装载通常都发生在第一次创建那个类的对象的时候)

多态
   除了static和final方法（private方法隐含有final的意思），java的所有的方法都采用后绑定。也就是说，通常情况下你不必考虑是不是应该采用后绑定—它是自动的。
   Class Shape{
Void draw(){};
Void erase(){};
}
Class Circle extends Shape{
   Void draw(){
       System.out.println(“Circle.draw()”);
}
Void erase(){
    System.out.println(“Circle.erase()”);
}
Public static void main(){
    Shape shape = new Circle();//1
    Shape.draw();//2
}
}
注释1： 上传，这里先创建了一个circle对象，马上就把它的reference赋给了shape。看上去这是一个错误（一种类型怎么能赋值给另一种呢）；但是由于circle是由shape派生来的，circle就是一种shape，因此这样做正确。
注释2：可能你认为，这次应该调用shape的draw（） 了吧，但是由于实现了后绑定（多态型），实际上它会调用circle.draw();
     结论：只有非private的方法才能被覆写。但是你得留意那些看上去就想是在覆写private方法的程序。它们不会产生编译错误。但是很可能会不按你的计划运行，说的再彻底一些，别用基类的private方法的名字去命名派生类的方法。

抽象类和抽象方法
　　　当你想要通过一个公共的接口来操纵一组类的时候，就可使用抽象类了。
　　　继承的前提是你能看到基类，并且还能访问它的public和protected成员
　　　清理：派生类编写dispose()(清理方法)的时候，第一件事就是调用基类的dispose().因为不这样做，基类就得不到清理。清理的顺序和初始化的顺序相反。

　　　一个好的构造函数应该，“用最少的工作量把对象的状态设置好，而且要尽可能的避免去调用。”。构造函数唯一能安全调用的方法，就是基类的final方法（这一条也适用private方法，因为它自动就是final的）它们不会被覆写，因此也不会产生意外的行为。