Java编程思想学习笔记——复用类

前言

复用代码是Java众多引人注目的功能之一。

达到复用代码的方法有：

1. 组合：新的类由现有类的对象所组成。（复用现有代码的功能，而非它的形式）
2. 继承：按照现有类的类型组建新类。（不改变现有类的形式，复用现有类的形式并在其中添加新代码）。面向对象程序设计的基石

正文

1.组合语法

将对象引用置于新类中即可（非基本类型：在新类中放置引用，基本类型：直接添加就可以了）

/**
 * 引擎
 */
class Engine{
    /**
     * 功率
     */
    double power;
    /**
     * 品牌
     */
    String type;
    /**
     * 无参构造方法
     */
    Engine(){

    }
    /**
     * 构造方法
     * @param power
     * @param type
     */
    Engine(double power,String type){
        this.power = power;
        this.type = type;
    }

    @Override
    public String toString() {
        return "Engine:power="+power+" type="+type;
    }
}
/**
 *火炮
 */
class Artillery{
    /**
     * 口径
     */
    double caliber;
    /**
     * 构造方法
     */
    Artillery(){

    }
    Artillery(double caliber){
        this.caliber = caliber;
    }

    @Override
    public String toString() {
       return "Artillery: caliber="+caliber;
    }
}
/**
 * 坦克
 */
public class Tank {
    private Engine engine;
    private Artillery artillery;
    public  Tank(Engine engine,Artillery artillery){
        this.artillery = artillery;
        this.engine = engine;
    }

    @Override
    public String toString() {
        return "Tank:"+this.engine+""+this.artillery;
    }

    public static void main(String[] args) {
        Engine engine = new Engine(10000.0,"ABC");
        Artillery artillery = new Artillery(1000);
        Tank tank = new Tank(engine,artillery);
        System.out.println(tank);
    }
}

每一个非基本类型的对象都有一个toString()方法。可以打印对象，重写toString()方法能自定义打印的内容。

对于类中的域，若是基本类型则能自动初始化为0。但是对象引用会被初始化为null。
编译器不会简单的为每一个引用创建默认对象(如果创建默认对象的话，在许多情况下增加不必要的负担)
初始化引用的方法：
1.在定义对象的地方。（在构造器被调用前被初始化）
2.在类的构造器中。
3.正要使用这些对象之前（惰性初始化，可减少额外负担）
4.使用实例初始化。

class Soap{
    private String s;
    /**
     * 构造器初始化
     */
    Soap(){
        System.out.println("Soap()");
        s = "Constructed";
    }

    @Override
    public String toString() {
        return s;
    }
}
public class Bath {
    /**
     * 在定义对象的地方（在构造器被调用前初始化）
     */
    private String s1 = "Happy",
    s2 = "Happy",
    s3,
    s4;
    private Soap castille;
    private int i;
    private float toy;
    public Bath(){
        System.out.println("Inside Bath()");
        s3 = "Joy";
        toy = 3.14f;
        castille = new Soap();
    }
    /**
     * 实例初始化
     */
    {
        i=47;
    }

    @Override
    public String toString() {
        /**
         * 惰性初始化
         */
        if(s4==null)
            s4="Joy";
        return "s1 = "+s1+
                "
s2 ="+s2+
                "
s3 ="+s3+
                "
s4 ="+s4+
                "
i ="+i+
                "
toy ="+toy
                +"
castille ="+castille;
    }

    public static void main(String[] args) {
        Bath b = new Bath();
        System.out.println(b);
    }
}

继承语法

继承是所有OOP（面向对象的编程语言）语言，包括Java语言不可缺少的组成部分。

当创建一个类时，总是在继承。（除非已明确指出从其他类中继承，否则就是隐式的继承自Java的标准根类Object）

关键字：extends(子类会自动得到父类中所有的域和方法)

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()");
    }

    @Override
    public String toString() {
        return s;
    }

    /**
     * 可以为每个类都创建一个main方法，使每个类的单元测试变得容易。
     * @param args
     */
    public static void main(String[] args) {
        Cleanser cleaner = new Cleanser();
        cleaner.dilute();
        cleaner.apply();
        cleaner.scrub();
        System.out.println(cleaner);
    }
}
public class Detergent extends Cleanser{
    /**
     * 重写Cleanser的scrub方法
     */
    public void scrub() {
        append("Detergent.scrub()");
        super.scrub();
    }
    /**
     * 在子类中添加新的方法
     */
    public void foam(){
        append("foam()");
    }

    public static void main(String[] args) {
        Detergent detergent = new Detergent();
        detergent.dilute();
        detergent.apply();
        detergent.scrub();
        detergent.foam();
        System.out.println(detergent);
        System.out.println("Test base classes:");
        //调用Cleanser的main方法
        Cleanser.main(args);
    }
}

初始化基类（父类）

class Art{
    Art(){
        System.out.println("Art Constructor");
    }
}
class Drawing extends Art{
    Drawing(){
        //Java会自动在子类的构造器中插入对父类构造器的调用（即super()方法的调用）
//        super();
        System.out.println("Drawing Constructor");
    }
}
public class Cartoon extends Drawing {
    public Cartoon(){
//        super();
        System.out.println("Cartoon Constructor");
    }

    public static void main(String[] args) {
        Cartoon cartoon = new Cartoon();
    }
}

结果：

Art Constructor
Drawing Constructor
Cartoon Constructor

带参数的构造器

若没有默认构造器，或想调用一个带参数的基类构造器，就必须使用关键字super显式地编写调用基类构造器的语句，并且配以适当的参数列表：

class Art{
    Art(int i){
        System.out.println("Art Constructor");
    }
}
class Drawing extends Art{
    Drawing(int i){
        //super(i)显式调用基类（父类）的构造器方法
        super(i);
        System.out.println("Drawing Constructor");

    }
}
public class Cartoon extends Drawing {
    public Cartoon(int i){
        //super(i)显式调用基类（父类）的构造器方法
        super(i);
        System.out.println("Cartoon Constructor");
    }

    public static void main(String[] args) {
        Cartoon cartoon = new Cartoon(1);
    }
}