标签：java
Java复用类一般有两种方法。
一，组合：在新的类中产生现有类的对象。由于新的类是由现有类的对象所组成，所以这种方法成为组合。
import java.util.*;
class WaterSource{
private String s;
WaterSource(){
System.out.println("WaterSource()");
s="constructed";
}
public String toString(){
return s;
}
}
public class SprinkerSystem{
private String value1,value2,value3,value4;
private WaterSource source=new WaterSource();
private int i;
private float f;
public String toString(){
return "value1= "+value1+" "+
"value2= "+value2+" "+
"value3= "+value3+" "+
"value4= "+value4+"\n"+
"i= "+i+" "+"f= "+f+" "+
"source= "+source;
}
public static void main(String[] args){
SprinkerSystem sprinker=new SprinkerSystem();
System.out.println(sprinker);
}
}
初始化：
1，定义对象的地方。
2，在类的构造器中。
3，在正要使用这些对象之前。
4，使用实例初始化。
二，继承：按照现有类的类型来创建新类。无需改变现有类的形式，采用现有类的形式并在其中添加新代码。
当创建一个类时，总是在继承，因此除非已明确指出要从其他类中继承，否则就是隐式的从Java的标准根类Object进行继承。
import java.util.*;
class Cleanser{
private String s="Cleaner";
public void append(String a){
s+=a;
}
public void dilute(){
append(" dilute()");
}
public void apply(){
append(" apply()");
}
public void scrub(){
append(" scrub()");
}
public String toString(){
return s;
}
public static void main(String[] args){
Cleanser x=new Cleanser();
x.dilute();
x.apply();
x.scrub();
System.out.println(x);
}
}
public class Detergent extends Cleanser{
public void scrub(){
append(" Detergent.scrub()");
super.scrub();
}
public void foam(){
append(" foam()");
}
public static void main(String[] args){
Detergent x=new Detergent();
x.dilute();
x.apply();
x.scrub();
x.foam();
System.out.println(x);
System.out.println("Test base class:");
Cleanser.main(args);
}
}
初始化基类：构建过程从基类向外扩散的。
销毁对象：Java垃圾回收器必要时释放其内存。
名称屏蔽：@Override注解可以防止你在不想重载时而意外的进行了重载。
向上转型：导出类是基类的一个超集，它可能比基类含有更多的方法，在向上转型的过程中，类接口唯一可能发生的事情是丢失方法，而不是获取它们。
组合与继承之间的选择：
组合技术通常用于想在新类中使用现有类的功能而不是其接口的情形。即，在新类中嵌入某个对象，让其实现所需要的功能，但是新类的用户只能看见为新类所定义的接口，而不是嵌入对象的接口。“is-a”的关系是用继承来表达的，”has-a”的关系则是用组合来表达的；到底是该用组合还是继承，一个清晰的方法是判断到底需不需要从新类型向基类进行向上转型。如果必须向上转型，则继承是必要的；但如果不是必须的，那么就需要好好考虑是否真的需要继承了。
标签：java
原文地址：http://blog.csdn.net/cstopcoder/article/details/40929879
