1.优点
好的封装性,创建实例对象时尽量少的修改代码
2.简单工厂
一个接口
public interface CarInterface {
/**
* 车子类型
*/
void carType();
/**
* 车子价格
*/
void carPrice();
}
两个实现类
public class Bus implements CarInterface {
@Override
public void carType() {
System.out.println("公共汽车");
}
@Override
public void carPrice() {
System.out.println("50W");
}
}
public class Taxi implements CarInterface {
@Override
public void carType() {
System.out.println("出租车");
}
@Override
public void carPrice() {
System.out.println("20W");
}
}
一个汽车工厂类
public class CarFactory {
public static final String TAXI = "taxi";
public static final String BUS = "bus";
public static CarInterface createCar(String type) {
CarInterface carIntance = null;
switch (type) {
case TAXI:
carIntance = new Taxi();
break;
case BUS:
carIntance = new Bus();
break;
default:
carIntance = new Bus();
break;
}
return carIntance;
}
}
这样,一个简单汽车工厂就完成了,运行
public static void main(String[] args){
CarInterface taxi = CarFactory.createCar(TAXI);
taxi.carType();
taxi.carPrice();
CarInterface bus = CarFactory.createCar(BUS);
bus.carType();
bus.carPrice();
}
3.工厂方法
简单工厂中,新增一个汽车实体类,都需要在CarFactory
的createCar
方法中加一个case
,工厂方法中弃用了CarFactory
类,给每个汽车实体类都创建一个生产类,这样新增一个汽车实体类后,只需要添加一个新的生产类即可,相对于简单工厂好处是不需要改动原有代码
新增接口
public interface CreateCarInterface {
CarInterface createCar();
}
新增两个生产类
public class CreateTaxiFactory implements CreateCarInterface {
@Override
public CarInterface createCar() {
return new Taxi();
}
}
public class CreateBusFactory implements CreateCarInterface {
@Override
public CarInterface createCar() {
return new Bus();
}
}
运行
public static void main(String[] args) {
CreateTaxiFactory taxiFactory = new CreateTaxiFactory();
CarInterface taxi = taxiFactory.createCar();
taxi.carType();
taxi.carPrice();
CreateBusFactory busFactory = new CreateBusFactory();
CarInterface bus = busFactory.createCar();
bus.carType();
bus.carPrice();
}