Thinking In Java 4th Chap7 复用类

复用代码的两种方法：组合和继承

组合方法：（新类中产生现有类的对象）

　　没什么好说的，就是调用别类的对象而已

　　值得一提的是一个特殊方法：toString（）当需要一个String却只有对象时能够自动调用此方法（每个类只需写一个toString方法）

　　　　例如：class Myclass{

　　　　　　　　/*..............*/

　　　　　　　　private String s;

　　　　　　　　public String toString(){

　　　　　　　　　　return s;} }

　　对象引用的初始化方法：1.定义对象之时即初始化　　2.在类的构造器中初始化　　3.在使用对象之前才初始化　　4.实例初始化

　　

 class Soap {
     public Soap() {
         System.out.println("Soap");
     }

     @Override
     public String toString() {
         return "Constructed";
     }
 }

 public class TestInit {
     private String s1 = "Happy"; // 定义初始化
     private Soap s2;
     private String s3, s4;

     // 实例初始化
     {
         s2 = new Soap();
     }

     public TestInit() {
         s3 = "Good"; // 构造器初始化
     }

     @Override
     public String toString() {
         s4 = "Girl"; // 惰性初始化
         return "TestInit{" + "s1='" + s1 + ", s2=" + s2 +
                 ", s3='" + s3 + ", s4='" + s4 + '}';
     }

     public static void main(String[] args) {
         TestInit ti = new TestInit();
         System.out.println(ti);
     }
 }
 /*
     Output:
     Soap
     TestInit{s1='Happy, s2=Constructed, s3='Good, s4='Girl}
  */

继承方法：（按照现有类的类型创建新类）

　　除非指明要继承的类，否则隐式地从根类Object进行继承

　　例如：public class Detergent extends Cleaner{/*...................*/}类Detergent继承自类Cleaner，获得Cleaner的全部域和方法

　　通常为了继承，将所有基类的数据成员定义为private，将所有方法定义为public（或protected）

　　想要调用基类的方法，使用super关键字：super.funcFromBase();

　　调用继承类对象的同时不仅调用了自己的构造器，也调用了基类的构造器（而且是在调用自己的构造器之前）

　　　　如果基类的构造器带有参数，调用基类的构造器需要使用super：

　　　　例如：class Base{

　　　　　　　　Base(int i){/*...............*/} }

　　　　　　　class Myclass extends Base{

　　　　　　　　Myclass(int i){

　　　　　　　　super(i);

　　　　　　　　/*...................*/} }

介乎组合和继承之间还存在一种方法：代理（在自己的类中建立别类的对象，在自己的方法中调用对象的方法）

　　例如：//在类的域中

　　　　　Baseclass bc = new Baseclass();

　　　　　void Myfunc(){

　　　　　　bc.Myfunc();}

　　　　　/*.............*/

　　使用代理的好处是我们可以控制使用“基类”的部分成员而不用全盘“拿来主义”

其中一种清理方式是try-finally语句组合（即使需要手动清理，也不要使用finalize（））

　　try{

　　//需要被特殊处理的代码}

　　finally{

　　//不管怎样，只要try语句块内代码执行完成就会调用的代码}

不同于c++：继承类重新定义基类的某个多次重载的方法，不会屏蔽该方法在基类中的任何一个版本

@override注解：想要覆写某个方法却不小心重载了该方法时，编译器会生成一条错误信息

覆写：方法名和参数列表都完全一致　　重载：方法名一致但是参数列表不同

如果是“是一个”的关系，应当使用继承（实际上慎用继承是明智的选择，如果不是必须向上转型，那么继承则不是必要的）；

如果是“有一个”的关系，应当使用组合（组合在一般情况下在新类中应使调用对象域为private）

向上转型：

　　其中一例是在继承类中的对象作为参数可以使用基类中的方法（虽然基类中的方法的参数并非继承类中的对象类型，却可以使用）

　　例如：class Base{

　　　　　　play(Base bs){/*.................*/} }

　　　　　public class Son extends Base{

　　　　　　Son sn=new Son();

　　　　　　Base.play(sn);}这里将子类引用转换为基类引用

final关键字：(类比c++中的const关键字）

　　编译期常量，这类常量必须是基本数据类型而且以final修饰

　　对象引用可以是常量，也就是说永远只指向同一对象（但是指向的对象的值是可以改变的，Java并不提供任何使对象恒定不变的途径）

　　同时以static和final修饰的只占有一份不变空间的常量，其名称全部大写并以_分隔单词

　　使用final参数意味着无法在方法中改变参数引用所指向的对象，也无法改变基本数据的值：

　　　　void func（final Myclass mc）{

　　　　　　//! mc=new Myclass(); mc因为是final修饰的，所以无权再指向新的对象

　　　　　　/*...............*/}

　　final方法：将方法锁定，防止继承类修改其含义

　　　　类中所有的private方法都隐式的认为是final，如果在继承类中写一个同名的方法（并无向上引用的接口），仅仅是同名而已（与基类方法并无关联）

　　　　只有方法是基类的接口的一部分（即能够将一个对象向上引用为基类的基本类型并调用相同方法），才能体现“覆盖”效应（无private或final的保护）

　　final类：如果将类整体定义为final（例如：final class Myclass{/*..........*/}）,则断绝了继承该类的途径，而且类中所有的方法都隐式指定为final

所有static对象和代码段按定义类时的书写顺序而依次初始化

类是在其任何static成员被访问时加载的（构造器是隐式的static成员）

调用一个继承类的初始化顺序：基类->(可能存在的其他基类）->继承类