Java基础学习——代码复用

1.什么是复用

复用指的是代码的复用，即将编写的类通过组合或继承的方式重新利用

2.复用的方式

• 组合(has-a 关系)

• 继承(is-a 关系)

3.组合 

1.什么是组合？

在新类中引入现有的类，组合是代码复用使用频率最高的方式

比如，我们有轮子、玻璃、引擎、坐垫等等，我们就可以简单组装成一辆车。轮子、玻璃、引擎、坐垫我们可以作为现有类，将其通过组合方式构建出一个新的类——车

 2.简单代码展示

• 现有类：Engine

/**
 * @author panyq
 * @since: 2022/3/13 16:43
 * #Description Engine
 */
public class Engine {
    //region 构造器
​
    public Engine() {
        System.out.println("氢氧燃料电池");
    }
​
    //endregion
}

• 现有类：Wheel

/**
 * @author panyq
 * @since: 2022/3/13 16:33
 * #Description Wheel
 */
public class Wheel {
    //reign 变量
​
    /**
     * 开始使用时间
     */
    private static Long startTime = System.currentTimeMillis();
​
    //endregion
​
    //region 方法
​
    /**
     * 计算车轮使用的时间
     */
    public void runningTime(){
        System.out.println(System.currentTimeMillis() - startTime);
    }
​
    //endregion
}

现有类：Window

/**
 * @author panyq
 * @since: 2022/3/13 16:42
 * #Description Window
 */
public class Window {
    //region 构造器
​
    public Window(int windowFlag) {
        this.windowFlag = windowFlag;
    }
​
    //endregion
​
    //region 变量
​
    /**
     * 窗户标识
     */
    private int windowFlag;
​
    //endregion
​
    //region 方法
​
    /**
     * 输出窗户编号
     */
    public void windowFlag(){
        System.out.println("这是第" + windowFlag + "块窗户");
    }
​
    //endregion
}

新类：将原有的类：Engine，Wheel，Window在新类中引入

/**
 * @author panyq
 * @since: 2022/3/13 16:48
 * #Description Car
 */
public class Car {
    //region 构造器
​
    public Car() {
        wheel = new Wheel();
        engine = new Engine();
        for (int i = 0; i < 4; i++) {
            windows[i] = new Window(i+1);
        }
        System.out.println("这是第" + count++ + "辆车" );
    }
​
    //endregion
​
    //region 成员变量
​
    /**
     * 车辆数量统计
     */
    private static int count = 1;
    /**
     * 轮子
     */
    private Wheel wheel;
    /**
     * 引擎
     */
    private Engine engine;
    /**
     * 窗户
     */
    private Window[] windows = new Window[4];
​
​
    //endregion
​
    //region 方法
​
    /**
     * 查看窗户标识
     */
    public void installWindows(){
        for (int i = 0; i < 4; i++) {
            windows[i].windowFlag();
        }
​
    }
​
    /**
     * 查看轮子的使用时间
     */
    public void wheelRunningTime(){
        wheel.runningTime();
    }
​
    //endregion
​
    public static void main(String[] args) {
        Car car = new Car();
        car.installWindows();
        car.wheelRunningTime();
    }
}

最终输出结果：
氢氧燃料电池
这是第1辆车
这是第1块窗户
这是第2块窗户
这是第3块窗户
这是第4块窗户
1

组合的特点：根据程序的需要通过引入不同的对象组装成新的对象来满足需求

4.继承

1.什么是继承？

从已有类拓展成新类，一般在java中通过extends关键字(继承类或接口继承接口)或implement关键字(继承接口)声明

比如，我们普通的车都是四轮前驱，现在出了一种越野型奥迪车，它前后都有高级引擎，配备了高级减震器。这些特性都是普通车所没有的，同样是行驶，它们表现出的：奥迪车明显速度更快，加速更猛

 2.简单代码展示

现有类：BaseCar

/**
 * @author panyq
 * @since: 2022/3/13 18:19
 * #Description BaseCar
 */
public class BaseCar {
    //region 构造器
​
    public BaseCar() {
        System.out.println("这是普通车");
    }
​
    //endregion
}

新类：AudiCar通过extends关键字继承了BaseCar

/**
 * @author panyq
 * @since: 2022/3/13 18:18
 * #Description AudiCar
 */
public class AudiCar extends BaseCar {
    //region 构造器
​
    public AudiCar() {
        System.out.println("这是前后驱动配备高级缓震的奥迪车");
    }
​
    //endregion
    public static void main(String[] args) {
        AudiCar audiCar = new AudiCar();
    }
}

输出结果：

这是普通车

这是前后驱动配备高级缓震的奥迪车

继承的特点：具备现有类的所有信息(private域除外)，并且可以根据需要进行拓展