复用代码的两种方法：组合和继承
组合方法：（新类中产生现有类的对象）
没什么好说的，就是调用别类的对象而已
值得一提的是一个特殊方法：toString（）当需要一个String却只有对象时能够自动调用此方法（每个类只需写一个toString方法）
例如：class Myclass{
/*..............*/
private String s;
public String toString(){
return s;} }
对象引用的初始化方法：1.定义对象之时即初始化 2.在类的构造器中初始化 3.在使用对象之前才初始化 4.实例初始化
1 class Soap {
2 public Soap() {
3 System.out.println("Soap");
4 }
5
6 @Override
7 public String toString() {
8 return "Constructed";
9 }
10 }
11
12 public class TestInit {
13 private String s1 = "Happy"; // 定义初始化
14 private Soap s2;
15 private String s3, s4;
16
17 // 实例初始化
18 {
19 s2 = new Soap();
20 }
21
22 public TestInit() {
23 s3 = "Good"; // 构造器初始化
24 }
25
26 @Override
27 public String toString() {
28 s4 = "Girl"; // 惰性初始化
29 return "TestInit{" + "s1='" + s1 + ", s2=" + s2 +
30 ", s3='" + s3 + ", s4='" + s4 + '}';
31 }
32
33 public static void main(String[] args) {
34 TestInit ti = new TestInit();
35 System.out.println(ti);
36 }
37 }
38 /*
39 Output:
40 Soap
41 TestInit{s1='Happy, s2=Constructed, s3='Good, s4='Girl}
42 */
继承方法：（按照现有类的类型创建新类）
除非指明要继承的类，否则隐式地从根类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成员）
调用一个继承类的初始化顺序：基类->(可能存在的其他基类）->继承类