复用类有两种实现方式。

在新的类中产生现有类的对象，由于新的类是由现有类的对象所组成，所以这种方法称之为组合。
采用继承实现。

一组合语法

下面创建两个类WaterSource和SprinklerSystem。其中SprinklerSystem中包含WaterSource的对象引用。

class WaterSource {
    //如果定义时没有初始化，则基本类型会被自动初始化为0，对象引用初始化为Null
    private String s;
    WaterSource(){
        System.out.println("WaterSource()");
        s = "Constructed";
    }    
}

public class SprinklerSystem {
    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) {
        SprinklerSystem sprinklers = new SprinklerSystem();
        System.out.println(sprinklers);
    }
}

运行结果如下：

WaterSource()
value1 = null value2 = null value3 = null value4 = null
i = 0  f = 0.0 source = WaterSource@15db9742

注意：如果把一个对象以String类型输出，则默认调用的是该对象的toString()方法。

类中成员变量如果是基本基本类型则默认被初始化为零，如果是对象引用则会被初始化为null。

我们也可以自己去初始化他们：

在定义成员变量的时候初始化，比如private String s1 = "happy"；这意味着他们能够在构造函数被调用之前初始化。
在类的构造函数中初始化；
在使用这些成员变量之前初始化，这种方式称之为惰性初始化；
使用实例初始化{s1 = "happy";}。

回到顶部

二继承语法

Java创建一个类时，默认都是继承于Object，除非自己指定从哪个类继承。

class Cleanser{
    private String s = "Cleanser";
    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("Testing base class:");
         
        Cleanser.main(args);
    }
 
}

运行结果如下：

Cleanser  dilute()  apply() Detergent.scrub()  scrub() foam()
Testing base class:
Cleanser  dilute()  apply()  scrub()

看以看到继承使用的是关键字extends，如果在子类中想调用父类方法，可以使用super.*。

1、初始化父类

在创建一个子类对象时，父类构造器总会在子类构造器之前被调用。

class Art{
    Art(){
        System.out.println("Art constructor");
    }
}
 
class Drawing extends Art{
    Drawing(){
        System.out.println("Drawing constructor");
    }
}
 
public class Cartoon extends Drawing{
    Cartoon(){
        System.out.println("Cartoon constructor");
    }
     
    public static void main(String[] args) {
        Cartoon x = new Cartoon();
    }
}

运行输出如下：

Art constructor
Drawing constructor
Cartoon constructor

所以很容易发现，子类对象的构建过程是从父类"向外"扩散的，所以父类在子类构造器可以访问它之前，就已经完成了初始化。

上面的父类构造函数是没有参数的，如果父类只有一个带有参数的构造器，就必须在子类构造器中用关键字super显式的编写调用父类构造器的语句，否则编译器将无法找到符合'类名()'形式的构造器。

2、重载

亲爱的读者和支持者们，自动博客加入了打赏功能，陆陆续续收到了各位老铁的打赏。在此，我想由衷地感谢每一位对我们博客的支持和打赏。你们的慷慨与支持，是我们前行的动力与源泉。

日期	姓名	金额
2023-09-06	*源	19
2023-09-11	*朝科	88
2023-09-21	*号	5
2023-09-16	*真	60
2023-10-26	*通	9.9
2023-11-04	*慎	0.66
2023-11-24	*恩	0.01
2023-12-30	I*B	1
2024-01-28	*兴	20
2024-02-01	QYing	20
2024-02-11	*督	6
2024-02-18	一*x	1
2024-02-20	c*l	18.88
2024-01-01	*I	5
2024-04-08	*程	150
2024-04-18	*超	20
2024-04-26	.*V	30
2024-05-08	D*W	5
2024-05-29	*辉	20
2024-05-30	*雄	10
2024-06-08	*:	10
2024-06-23	小狮子	666
2024-06-28	*s	6.66
2024-06-29	*炼	1
2024-06-30	*!	1
2024-07-08	*方	20
2024-07-18	A*1	6.66
2024-07-31	*北	12
2024-08-13	*基	1
2024-08-23	n*s	2
2024-09-02	*源	50
2024-09-04	*J	2
2024-09-06	*强	8.8
2024-09-09	*波	1
2024-09-10	*口	1
2024-09-10	*波	1
2024-09-12	*波	10
2024-09-18	*明	1.68
2024-09-26	B*h	10
2024-09-30	岁	10
2024-10-02	M*i	1
2024-10-14	*朋	10
2024-10-22	*海	10
2024-10-23	*南	10
2024-10-26	*节	6.66
2024-10-27	*o	5
2024-10-28	W*F	6.66
2024-10-29	R*n	6.66
2024-11-02	*球	6
2024-11-021	*鑫	6.66
2024-11-25	*沙	5
2024-11-29	C*n	2.88