1.简单工厂模式(买电脑问题)
简单工厂模式:专门定义一个类用来创建其它类的实例,
被创建的实例通常都具有共同的父类。
概要:
一个抽象产品类;
具体产品类;
一个工厂;
一个客户端;
代码如下:
public interface Computer {//抽象的电脑接口
void printComputer();
}
public class MacbookProComputer implements Computer {
@Override
public void printComputer() {
System.out.println("MacbookProComputer");
}
}
public class SurfaceBookComputer implements Computer {
@Override
public void printComputer() {
System.out.println("SurfaceBookComputer");
}
}
public class AlienComputer implements Computer {
@Override
public void printComputer() {
System.out.println("AlienComputer");
}
}
public class ComputerFactory {
public static Computer getInstance(String type) {//一个返回电脑型号的方法
Computer computer = null;
switch (type) {
case "MAC":
computer = new MacbookProComputer();
break;
case "SUR":
computer = new SurfaceBookComputer();
break;
case "ALI":
computer = new AlienComputer();
break;
default:
System.out.println("请输入正确的电脑型号");
break;
}
return computer;
}
}
import java.util.Scanner;
public class Client {
public void buyComputer(Computer computer) {//一个含有电脑型号的形参且无返回值的方法
computer.printComputer();
}
public static void main(String[] args) {
Client client = new Client();
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你想要的电脑型号");
String type = scanner.nextLine();
client.buyComputer(ComputerFactory.getInstance(type));
}
}
此类模式的优点有:简单易于实现;把类的实例化交给工厂,易于解耦。
此类模式的缺点有:添加具体产品需要修改工厂违反OCP开放封闭原则。
2.工厂方法模式(买电脑问题)
工厂方法模式:定义一个用来创建对象的接口,让子类决定实例化哪一个类,
让子类决定实例化延迟到子类。
概要:
一个抽象产品类;
多个具体产品类;
一个抽象工厂;
多个具体工厂,每一个具体产品对应一个具体工厂;
一个客户端;
代码如下:
public interface Computer {//抽象的电脑接口
void printComputer();
}
public class MacbookProComputer implements Computer {
@Override
public void printComputer() {
System.out.println("MacbookProComputer");
}
}
public class SurfaceBookComputer implements Computer {
@Override
public void printComputer() {
System.out.println("SurfaceBookComputer");
}
}
public interface ComputerFactory {//抽象的工厂接口
Computer createComputer();
}
public class MsFactor implements ComputerFactory {
@Override
public Computer createComputer() {
return new SurfaceBookComputer();
}
}
public class AppleFactory implements ComputerFactory {
@Override
public Computer createComputer() {
return new MacbookProComputer();
}
}
public class Client {
public void buyComputer(Computer computer) {//一个含有电脑型号的形参且无返回值的方法
computer.printComputer();
}
public static void main(String[] args) {
Client client = new Client();
ComputerFactory factory = new AppleFactory();
ComputerFactory factory1 = new MsFactor();
client.buyComputer(factory.createComputer());
client.buyComputer(factory1.createComputer());
}
}
此类模式的优点有:降低了代码耦合度,对象的生成交给子类去完成;
实现了开放封闭原则,每次添加子产品不需要修改原有代码。
此类模式的缺点有:增加了代码量,每个具体产品都需要一个具体工厂;
当增加抽象产品,也就是添加一个其他产品族,需要修改工厂违背OCP。
3.抽象工厂模式(买电脑问题)
抽象工厂模式:提供一个创建一系列相关互相依赖对象的接口,
而无需指定它们具体的类。
概要:
多个抽象产品类;
具体产品类;
抽象工厂类,声明(一组)返回抽象产品的方法;
具体工厂类,生产(一组)具体产品;
一个客户端;
代码如下:
public interface Computer {//抽象的电脑接口
void printComputer();
}
public class MacbookProComputer implements Computer {
@Override
public void printComputer() {
System.out.println("MacbookProComputer");
}
}
public class SurfaceBookComputer implements Computer {
@Override
public void printComputer() {
System.out.println("SurfaceBookComputer");
}
}
public interface OpeartSystem {//抽象的操作系统接口
void printSystem();
}
public class MacOsSystem implements OpeartSystem {
@Override
public void printSystem() {
System.out.println("MacOsSystem");
}
}
public class Windows10System implements OpeartSystem {
@Override
public void printSystem() {
System.out.println("Windows10System");
}
}
public interface ComputerFactory {//抽象的工厂接口,包含了两个抽象方法
Computer createComputer();
OpeartSystem createSystem();
}
public class AppleFactory implements ComputerFactory {
@Override
public Computer createComputer() {
return new MacbookProComputer();
}
@Override
public OpeartSystem createSystem() {
return new MacOsSystem();
}
}
public class MsFactor implements ComputerFactory {
@Override
public OpeartSystem createSystem() {
return new Windows10System();
}
@Override
public Computer createComputer() {
return new SurfaceBookComputer();
}
}
public class Client {
public void buyComputer(Computer computer) {//一个含有电脑型号的形参且无返回值的方法
computer.printComputer();
}
public void use(OpeartSystem system) {//一个含有操作系统类型的形参且无返回值的方法
system.printSystem();
}
public static void main(String[] args) {
Client client = new Client();
ComputerFactory factory = new AppleFactory();
ComputerFactory factory1 = new MsFactor();
client.buyComputer(factory.createComputer());
client.use(factory.createSystem());
client.buyComputer(factory1.createComputer());
client.use(factory1.createSystem());
}
}
此类模式的优点有:代码解耦;实现多个产品族;很好的满足OCP开放封闭原则;
抽象工厂模式中我们可以定义实现不止一个接口,
一个工厂也可以生成不止一个产品类,对于复杂对象的生产相当灵活易扩展。
此类模式的缺点有:扩展产品族相当麻烦而且扩展产品族会违反OCP,
因为要修改所有的工厂;
由于抽象工厂模式是工厂方法模式的扩展,总体来说很笨重。
最后再总结一下抽象类和接口的区别:
1.结构组成:抽象类可以包含普通方法、抽象方法(必有)、构造器以及代码块;
而接口只能包含抽象方法和全局静态常量。
2.权限:抽象类可以使用各种权限;而接口只能用public权限。
3.子类使用:抽象类使用extends关键字继承抽象类;
而接口使用implements关键字实现接口。
4.关系:一个抽象类可以实现若干个接口;
而接口不能继承抽象类(因为接口不含有普通方法),
但是接口可以使用extends关键字继承多个父接口。
5.子类限制:一个子类只能继承一个抽象类;而一个子类可以实现多个接口。