java 建造者+继承

Java中的建造者模式是一种创建型设计模式，用于创建复杂的对象。它通过将对象的构建过程拆分为多个步骤，并将这些步骤封装在单独的建造者类中，使得用户可以根据需要选择执行哪些步骤，从而创建出不同的对象。

而继承则是Java中面向对象编程的一种基本特性，它允许一个类继承另一个类的属性和方法，并在此基础上进行扩展。通过继承，子类可以重用父类的代码，从而更快地开发出新的功能。

在实际应用中，建造者模式和继承可以结合使用。比如，我们可以定义一个抽象的Builder类，并让具体的建造者类继承这个Builder类。这样，在使用建造者模式的时候，我们就可以根据需要选择使用哪个具体的建造者类，并在此基础上进行对象的构建。同时，由于建造者类继承自抽象的Builder类，所以它们之间也可以进行代码的重用。

相关问题

java 建造者+继承实现 demo

好的，下面是一个更完整的 Java 建造者+继承实现的 demo：

我们以一个简单的电脑制造系统为例，其中有两种不同类型的电脑：台式机和笔记本。台式机和笔记本都需要进行多个步骤的构建，比如选择 CPU、安装内存、安装硬盘等等。我们可以使用建造者模式来实现这些步骤的构建，然后让台式机和笔记本分别继承自一个抽象的电脑类，从而实现代码的重用。

首先，我们定义一个抽象的电脑类，其中包含了电脑的基本属性和方法：

public abstract class Computer {
    protected String cpu;
    protected String memory;
    protected String hardDisk;

    public String getCpu() {
        return cpu;
    }

    public String getMemory() {
        return memory;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public abstract void setCpu(String cpu);
    public abstract void setMemory(String memory);
    public abstract void setHardDisk(String hardDisk);
}

然后，我们定义一个抽象的建造者类，其中包含了电脑构建的各个步骤：

public abstract class ComputerBuilder {
    protected Computer computer;

    public Computer getComputer() {
        return computer;
    }

    public void createNewComputer() {
        computer = new Computer();
    }

    public abstract void buildCpu();
    public abstract void buildMemory();
    public abstract void buildHardDisk();
}

接下来，我们定义具体的台式机和笔记本类，它们继承自抽象的电脑类，并实现了其中的抽象方法：

public class Desktop extends Computer {
    @Override
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    @Override
    public void setMemory(String memory) {
        this.memory = memory;
    }

    @Override
    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }
}

public class Laptop extends Computer {
    @Override
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    @Override
    public void setMemory(String memory) {
        this.memory = memory;
    }

    @Override
    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }
}

最后，我们定义具体的台式机建造者和笔记本建造者类，它们继承自抽象的建造者类，并实现了其中的抽象方法：

public class DesktopBuilder extends ComputerBuilder {
    @Override
    public void buildCpu() {
        computer.setCpu("Desktop CPU");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("Desktop Memory");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("Desktop Hard Disk");
    }
}

public class LaptopBuilder extends ComputerBuilder {
    @Override
    public void buildCpu() {
        computer.setCpu("Laptop CPU");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("Laptop Memory");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("Laptop Hard Disk");
    }
}

使用时，我们可以先创建一个具体的建造者对象，然后根据需要选择对应的建造者方法，最后获取构建好的电脑对象：

public class Demo {
    public static void main(String[] args) {
        ComputerBuilder builder = new DesktopBuilder();
        builder.createNewComputer();
        builder.buildCpu();
        builder.buildMemory();
        builder.buildHardDisk();
        Computer desktop = builder.getComputer();

        builder = new LaptopBuilder();
        builder.createNewComputer();
        builder.buildCpu();
        builder.buildMemory();
        builder.buildHardDisk();
        Computer laptop = builder.getComputer();
    }
}

这样，我们就可以通过建造者模式和继承，快速创建出不同类型的电脑，并且可以在代码中重用已有的代码。

java 建造者+继承 demo

下面是一个简单的Java示例，演示如何将建造者模式和继承结合使用。

我们以一个简单的汽车制造系统为例，其中有两种不同类型的汽车：轿车和卡车。轿车和卡车都需要进行多个步骤的构建，比如生产发动机、组装底盘、安装车门等等。我们可以使用建造者模式来实现这些步骤的构建，然后让轿车和卡车分别继承自一个抽象的汽车类，从而实现代码的重用。

首先，我们定义一个抽象的汽车类，其中包含了汽车的基本属性和方法：

public abstract class Car {
    protected String engine;
    protected String chassis;
    protected String doors;

    public String getEngine() {
        return engine;
    }

    public String getChassis() {
        return chassis;
    }

    public String getDoors() {
        return doors;
    }

    public abstract void setEngine(String engine);
    public abstract void setChassis(String chassis);
    public abstract void setDoors(String doors);
}

然后，我们定义一个抽象的建造者类，其中包含了汽车构建的各个步骤：

public abstract class CarBuilder {
    protected Car car;

    public Car getCar() {
        return car;
    }

    public void createNewCar() {
        car = new Car();
    }

    public abstract void buildEngine();
    public abstract void buildChassis();
    public abstract void buildDoors();
}

接下来，我们定义具体的轿车和卡车类，它们继承自抽象的汽车类，并实现了其中的抽象方法：

public class Sedan extends Car {
    @Override
    public void setEngine(String engine) {
        this.engine = engine;
    }

    @Override
    public void setChassis(String chassis) {
        this.chassis = chassis;
    }

    @Override
    public void setDoors(String doors) {
        this.doors = doors;
    }
}

public class Truck extends Car {
    @Override
    public void setEngine(String engine) {
        this.engine = engine;
    }

    @Override
    public void setChassis(String chassis) {
        this.chassis = chassis;
    }

    @Override
    public void setDoors(String doors) {
        this.doors = doors;
    }
}

最后，我们定义具体的轿车建造者和卡车建造者类，它们继承自抽象的建造者类，并实现了其中的抽象方法：

public class SedanBuilder extends CarBuilder {
    @Override
    public void buildEngine() {
        car.setEngine("Sedan Engine");
    }

    @Override
    public void buildChassis() {
        car.setChassis("Sedan Chassis");
    }

    @Override
    public void buildDoors() {
        car.setDoors("Sedan Doors");
    }
}

public class TruckBuilder extends CarBuilder {
    @Override
    public void buildEngine() {
        car.setEngine("Truck Engine");
    }

    @Override
    public void buildChassis() {
        car.setChassis("Truck Chassis");
    }

    @Override
    public void buildDoors() {
        car.setDoors("Truck Doors");
    }
}

使用时，我们可以先创建一个具体的建造者对象，然后根据需要选择对应的建造者方法，最后获取构建好的汽车对象：

public class Demo {
    public static void main(String[] args) {
        CarBuilder builder = new SedanBuilder();
        builder.createNewCar();
        builder.buildEngine();
        builder.buildChassis();
        builder.buildDoors();
        Car sedan = builder.getCar();

        builder = new TruckBuilder();
        builder.createNewCar();
        builder.buildEngine();
        builder.buildChassis();
        builder.buildDoors();
        Car truck = builder.getCar();
    }
}

这样，我们就可以通过建造者模式和继承，快速创建出不同类型的汽车，并且可以在代码中重用已有的代码。