工厂模式~

没有使用简单工厂模式时：

package nofactory;

public interface Car {

    void run();
}

package nofactory;

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪汽车");

    }

}
 

package nofactory;

public class Byd implements Car {

    @Override
    public void run() {
        System.out.println("比亚迪汽车");

    }

}

package nofactory;

/**
 * 没有使用简单工厂的时候：
 * 创建Car接口（run方法）
 * 创建Car的实现类：Audi，Byd，重写run方法
 * 客户端调用：利用多态，创建Byd对象、Audi对象并调用run方法
 * 需要和Car接口，Audi类，Byd类打交道，有很大的耦合性
 */
public class Client01 {

    public static void main(String[] args) {
        Car c1 = new Byd();
        Car c2 = new Audi();
        c1.run();
        c2.run();
    }
}
 

使用简单工厂：

package simplefactory;

public interface Car {

    void run();
}
 

package simplefactory;

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪汽车");

    }

}

package simplefactory;

public class Byd implements Car {

    @Override
    public void run() {
        System.out.println("比亚迪汽车");

    }

}

package simplefactory;

public class CarFactory {

    /*
    //静态方法，方便调用.传入参数：根据不同的汽车类型创建实例
    public static Car createCar(String type) {
        Car c = null;
        if("奥迪".equals(type)) {
            c = new Audi();
        }else if("比亚迪".equals(type)) {
            c = new Byd();
        }//如果以后还有其他类型的汽车，这里就需要再修改代码，添加新的汽车类型，不符合开闭原则
        return c;
    }
    */
    
    //可以直接创建不同类型的汽车
    public static Car createAudi() {
        return new Audi();
    }
    
    public static Car createByd() {
        return new Byd();
    }
    
    
}

package simplefactory;

/**
 * 简单工厂模式
 * 创建Car接口（run方法）
 * 创建Car的实现类：Audi，Byd，重写run方法
 * 创建CarFactory类，创建静态方法方便调用，传入参数是汽车类型，根据不同类型，创建具体的对象
 * 客户端：直接与CarFactory打交道，传入具体的汽车类型，返回给客户端具体的对象，这样客户端就不需要直接和具体的汽车类打交道，避免了类与类之间的耦合
 */
public class Client02 {

    public static void main(String[] args) {
        /*
        //传入参数，CarFactory根据参数值创建不同的汽车对象
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");
        c1.run();
        c2.run();*/
        
        
        //直接调用工厂中不同类型的对象创建方法获取对象
        Car c1 = CarFactory.createAudi();
        c1.run();
        Car c2 = CarFactory.createByd();
        c2.run();
    }
}
 

使用工厂方法模式：

package factorymethod;

public interface Car {

    void run();
}
 

package factorymethod;

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪汽车");

    }

}
 

package factorymethod;

public class Byd implements Car {

    @Override
    public void run() {
        System.out.println("比亚迪汽车");

    }

}

package factorymethod;

public interface CarFactory {

    Car createCar();
}

package factorymethod;

public class AudiFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Audi();
    }

}
 

package factorymethod;

public class BydFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Byd();
    }

}
 

package factorymethod;

/**
 * 工厂方法模式：
 * 创建Car接口（run方法）
 * 创建Car的实现类：Audi，Byd，重写run方法
 * 创建CarFactory接口：createCar（）方法
 * 创建AudiFactory类实现CarFactory接口，实现createCar（）方法，在该方法中创建Audi对象
 * 创建BydFactory类实现CarFactory接口，实现createCar（）方法，在该方法中创建Byd对象
 * 在客户端创建具体的汽车类型Factory对象（AudiFactory，BydFactory）并调用createCar（）获得汽车对象，执行run方法
 * 使用该模式方便扩展，扩展时不需要修改原来的代码，只需要增加实现类完成新的业务功能
 */
public class Client03 {

    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();
        c1.run();
        c2.run();
    }
}