23中设计模式之工厂模式
工厂模式
- 实现了创建者和调用者的分离
- 详细分裂:
简单工厂模式
工厂方法模式
抽象工厂模式
面向对象设计的基本原则
- OCP(开闭原则):一个软件实体应当对外开放，对修改关闭
- DIP(依赖倒转原则）：要针对接口编程，不要针对实现编程
- LoD(迪米特原则):只与你直接朋友通信，而避免与陌生人通信.
简单工厂模式
定义一个接口Car
public interface Car {
void run();
}实现类Audi
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪再跑！");
}
}实现类Byd
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪再跑！");
}
}测试类Client01,没有工厂模式的时候：
public class Client01 { //调用者
public static void main(String[] args) {
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}添加一个工厂类CarFactory
/**
* 根据要的类型进行创建
*/
public static Car createCar(String type) {
if (type.equals("奥迪")) {
return new Audi();
} else if (type.equals("比亚迪")) {
return new Byd();
}
return null;
}工厂类也可以这样
public class CarFactory2 {
public static Audi getAudi() {
return new Audi();
}
public static Byd getByd() {
return new Byd();
}
}
测试类
public class testCa {
@Test
public void testCar() {
Car car = new Audi();
Car car1 = new Byd();
car.run();
car1.run();
}
@Test
public void testCar1() {
Car car = CarFactory.createCar("奥迪");
Car car1 = CarFactory.createCar("比亚迪");
car.run();
car1.run();
}
@Test
public void testCar2() {
Car car = CarFactory2.getAudi();
Car car1 = CarFactory2.getByd();
car.run();
car1.run();
}
}
工厂模式
- 实现了创建者和调用者的分离
- 详细分裂:
简单工厂模式
工厂方法模式
抽象工厂模式
面向对象设计的基本原则
- OCP(开闭原则):一个软件实体应当对外开放，对修改关闭
- DIP(依赖倒转原则）：要针对接口编程，不要针对实现编程
- LoD(迪米特原则):只与你直接朋友通信，而避免与陌生人通信.
简单工厂模式
定义一个接口Car
public interface Car {
void run();
}实现类Audi
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪再跑！");
}
}实现类Byd
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪再跑！");
}
}测试类Client01,没有工厂模式的时候：
public class Client01 { //调用者
public static void main(String[] args) {
Car c1 = new Audi();
Car c2 = new Byd();
c1.run();
c2.run();
}
}添加一个工厂类CarFactory
/**
* 根据要的类型进行创建
*/
public static Car createCar(String type) {
if (type.equals("奥迪")) {
return new Audi();
} else if (type.equals("比亚迪")) {
return new Byd();
}
return null;
}工厂类也可以这样
public class CarFactory2 {
public static Audi getAudi() {
return new Audi();
}
public static Byd getByd() {
return new Byd();
}
}
测试类
public class testCa {
@Test
public void testCar() {
Car car = new Audi();
Car car1 = new Byd();
car.run();
car1.run();
}
@Test
public void testCar1() {
Car car = CarFactory.createCar("奥迪");
Car car1 = CarFactory.createCar("比亚迪");
car.run();
car1.run();
}
@Test
public void testCar2() {
Car car = CarFactory2.getAudi();
Car car1 = CarFactory2.getByd();
car.run();
car1.run();
}
}
工厂方法模式
- 汽车接口
public interface Car {
void run();
}- 汽车工厂接口
public interface CarFactory {
Car createCar();
}
- 比亚迪车的实现
public class Byd implements Car {
@Override
public void run() {
System.out.println("比亚迪在跑！");
}
}
- 奥迪车的实现
public class Audi implements Car {
@Override
public void run() {
System.out.println("奥迪在跑！");
}
}
- 奥迪工厂实现
public class AudioFactory implements CarFactory {
@Override
public Car createCar() {
return new Audi();
}
}
- 比亚迪工厂实现
public class BydFactory implements CarFactory {
@Override
public Car createCar() {
return new Byd();
}
}
- 测试类
Car car1=new AudioFactory().createCar();
Car car2=new BydFactory().createCar();
car1.run();
car2.run();注意：按照六大原则，简单工厂不符合开闭原则,因此, 根据设计理论建议：工厂方法模式，但是实际上，我们一般都是使用简单工厂模式！
抽象工厂模式
多个接口，构成了产品族的时候使用抽象工厂模式！
- 创建引擎
public interface Engine {
void run();
void start();
}
class HeightEngine implements Engine {
@Override
public void run() {
System.out.println("转的快！");
}
@Override
public void start() {
System.out.println("启动快!可以自动启停！");
}
}
class LowEngine implements Engine {
@Override
public void run() {
System.out.println("转的慢！");
}
@Override
public void start() {
System.out.println("启动慢!");
}
}- 创建座位
public interface Seat {
void message();
}
class HeightSeat implements Seat {
@Override
public void message() {
System.out.println("可以自动按摩！");
}
}
class LowSeat implements Seat {
@Override
public void message() {
System.out.println("不能按摩！");
}
}- 创建轮胎
public interface Tyre {
void revolve();
}
class HeightTyre implements Tyre {
@Override
public void revolve() {
System.out.println("旋转不磨损！");
}
}
class LowTyre implements Tyre {
@Override
public void revolve() {
System.out.println("旋转磨损快！");
}
}
- 汽车接口
public interface CarFactory {
Engine createEngine();
Seat createSeat();
Tyre createTyre();
}
- 创建高档汽车
public class HeightCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new HeightEngine();
}
@Override
public Seat createSeat() {
return new HeightSeat();
}
@Override
public Tyre createTyre() {
return new HeightTyre();
}
}- 创建低等汽车
public class LowCarFactory implements CarFactory {
@Override
public Engine createEngine() {
return new LowEngine();
}
@Override
public Seat createSeat() {
return new LowSeat();
}
@Override
public Tyre createTyre() {
return new LowTyre();
}
}
- 测试
Engine engine = new HeightCarFactory().createEngine();
engine.run();
engine.start();总结：
1. 简单工厂：有两种表达方式，第一种就好比万能建车厂，客户要什么类型，如果有，就直接new car；第二种方式就好比建车厂现在只有这两种车(Byd,Audi)，客户只能买这两种车
2.工厂方法模式:就是Audi有专门的Audi建造厂，Byd有专门的Byd建造厂,而每一个建造厂都有一个共同的建造厂，实现创建车
3.抽象工厂模式：多个接口，构造成的产品族，比如车有座椅，轮子，镜子，发动机