内容是看了设计模式之禅,然后自己写个文档总结到一起,便于查看。
单例模式:(程序运行过程中只能有一个类的对象)
单例模式主要是对构造方法进行私有化 private,防止外部通过 new方法 创建实体类。针对该类中的方法尽量使用static修饰,便于访问。
public class Singleton { private static final Singleton singleton = new Singleton(); private Singleton(){ } //通过该方法获得实例对象 public static Singleton getSigleton(){ return singleton; } public static void talk(){ System.out.println("我被执行了"); } } public class Client { public static void main(String[] args) { Singleton singleton1 = Singleton.getSigleton(); Singleton singleton2 = Singleton.getSigleton(); System.out.println(singleton1 == singleton2); System.out.println(singleton1.equals(singleton2)); } } 执行结果: true true
工厂模式:定义:一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使类的实例化延迟到其子类。
工厂模式主要是包含:工厂类(可以是抽象类,可以是接口,主要是用来定义有哪些方法),具体工厂类,产品类(可以是抽象类,可以是接口,主要是用来定义产品有哪些方法),产品实现类。只需要知道工厂类,实体类类名,就能获取到实体类对象,然后通过实体类对象调用实体中写的方法。
/** * 抽象产品类 */ public abstract class Human { //不同种族的肤色不同 public abstract void getColor(); //不同种族语言不同 public abstract void getTalk(); } public class BlackHuman extends Human { @Override public void getColor() { System.out.println("黑色人种的皮肤是黑色的"); } @Override public void getTalk() { System.out.println("黑色人种通用语言英语"); } } public class YellowHuman extends Human { @Override public void getColor() { System.out.println("黄色人种的皮肤是黄色的"); } @Override public void getTalk() { System.out.println("黄色人种通用语言是普通话"); } } /** * 抽象人类创建工厂 * */ public abstract class AbstractFactory { //获取人类对象 public abstract <T extends Human> T createHuman(Class c); } /** * 具体工厂类 */ public class HumanFactory extends AbstractFactory { @Override public <T extends Human> T createHuman(Class c) { //定义一个生产的人种 Human human = null; try { human = (T)(Class.forName(c.getName())).newInstance(); } catch (Exception e) { e.printStackTrace(); } return (T)human; } } public class Client { public static void main(String[] args) { //创建一个人类工厂 AbstractFactory factory = new HumanFactory(); BlackHuman blackHuman = factory.createHuman(BlackHuman.class); blackHuman.getColor(); blackHuman.getTalk(); YellowHuman yellowHuman = factory.createHuman(YellowHuman.class); yellowHuman.getColor(); yellowHuman.getTalk(); } }
抽象工厂模式:定义:一个用于创建一组相关或者相互依赖的对象提供一个接口,无需指定他们的具体实现类。
在工厂模式的升级版
主要是 有N产品族在抽象工厂中就有N个创建方法。有M个产品等级就应该有M个实现工厂类,在每个实现工厂中,实现不同产品族的生产任务。
//抽象的产品类 public abstract class AbstractProductA { //每个产品都有公共的方法 public void getProductName(){ System.out.println("我是一个产品"); } //每个产品相同方法,不同实现 public abstract void doSomething(); } //抽象的产品类 public abstract class AbstractProductB { //每个产品都有公共的方法 public void getProductName(){ System.out.println("我是一个产品B"); } //每个产品相同方法,不同实现 public abstract void doSomething(); } public class ProductA1 extends AbstractProductA{ @Override public void doSomething() { System.out.println("产品A1的实现方法"); } } public class ProductA2 extends AbstractProductA { @Override public void doSomething() { System.out.println("产品A2的实现方法"); } } public class ProductB1 extends AbstractProductB { @Override public void doSomething() { System.out.println("产品B1的实现方法"); } } public class ProductB2 extends AbstractProductB { @Override public void doSomething() { System.out.println("产品B2的实现方法"); } } /** * 有多少个产品族,在抽象工厂中就有多少个创建方法 */ public abstract class AbstractFactory { //创建A产品家族 public abstract AbstractProductA createProductA(); //创建B产品家族 public abstract AbstractProductB createProductB(); } //有多少产品等级就有多少实现工厂类 //产品等级1的实现类 public class Factory1 extends AbstractFactory { @Override public AbstractProductA createProductA() { return new ProductA1(); } @Override public AbstractProductB createProductB() { return new ProductB1(); } } //产品等级2的实现类 public class Factory2 extends AbstractFactory { @Override public AbstractProductA createProductA() { return new ProductA2(); } @Override public AbstractProductB createProductB() { return new ProductB2(); } } public class Client { public static void main(String[] args) { //创建出两个工厂 AbstractFactory factory1 = new Factory1(); AbstractFactory factory2 = new Factory2(); //产品A对象 AbstractProductA a1 = factory1.createProductA(); AbstractProductA a2 = factory2.createProductA(); //产品B对象 AbstractProductB b1 = factory1.createProductB(); AbstractProductB b2 = factory2.createProductB(); a1.doSomething(); a2.doSomething(); b1.doSomething(); b2.doSomething(); } } 运行结果: 产品A1的实现方法 产品A2的实现方法 产品B1的实现方法 产品B2的实现方法
模板模式:
主要是抽象模板类定义方法,模板实现类集成模板方法。但是通用的方法写到抽象模板类方法中。(如算法 它的参数可以不同,但是执行的步骤相同。就可以提取出来,放到抽象模板类方法中。)
代码待完成
建造者模式:类似于定义了一个算法,然后算法的步骤在于具体实现类,实现步骤不同会生成不同的对象。
和工厂模式相似,建造者模式重在零件组装,工厂模式重在零件的创建。一个是组装方法步骤,一个是类的创建,不关注组装。
代理模式: