一：抽象工厂模式
工厂模式指的是，围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。
1 /**
2 * 绘画接口
3 */
4 public interface Color{
5 //填充颜色
6 void fill();
7 }
8
9
10
11 /**
12 * 形状接口
13 */
14 public interface Shape{
15 //绘画形状
16 void draw();
17 } 18 19 20 21 public class GreenColor implements Color{//Color的实现类 22 public void fill(){ 23 System.out.println("绿色---"); 24 } 25 } 26 public class RedColor implements Color{//Color的实现类 27 public void fill(){ 28 System.out.println("红色---"); 29 } 30 } 31 32 33 34 35 public class TriangleShape implements Shape{//Shape的实现类 36 public void draw(){ 37 System.out.println("三角形---"); 38 } 39 } 40 public class CircleShape implements Shape{//Shape的实现类 41 public void draw(){ 42 System.out.println("圆形---"); 43 } 44 } 45 46 47 48 /** 49 * 抽象工厂，构造两个接口 50 */ 51 public abstract class AbstractFactory { 52 public abstract Color getColor(String color) ;//根据颜色字符串得到哪种对象 53 public abstract Shape getShape(String shape) ;//根据形状字符串得到哪种对象 54 } 55 56 57 58 public class ColorFactory extends AbstractFactory{//颜色工厂继承抽象工厂 59 public Color getColor(String color) {//根据颜色字符串得到哪种对象 60 if(null == color){return null;} 61 if ( "red".equalsIgnoreCase(color) ){ 62 return new RedColor();//实例化一个RedColor对象 63 }else if ( "green".equalsIgnoreCase(color)){ 64 return new GreenColor();//实例化一个GreenColor对象 65 } 66 return null; 67 } 68 public Shape getShape(String shape){ ;//根据形状字符串得到哪种对象 69 return null; 70 } 71 } 72 73 74 75 public class ShapeFactory extends AbstractFactory{//形状工厂继承抽象工厂 76 public Color getColor(String color) {//根据颜色字符串得到哪种对象 77 return null; 78 } 79 public Shape getShape(String shape){ ;//根据形状字符串得到哪种对象 80 if(null == shape){return null;} 81 if ( "triangle".equalsIgnoreCase(shape) ){ 82 return new CircleShape();//实例化一个CircleShape对象 83 }else if ( "circle".equalsIgnoreCase(shape)){ 84 return new TriangleShape ();//实例化一个TriangleShape 对象 85 } 86 return null; 87 } 88 } 89 90 91 92 public class FactoryBuilder{//父工厂,构建具体工厂对象 93 public static AbstractFactory getFactory(String factory){ 94 if ( "colorfactory".equalsIgnoreCase(factory) ){ 95 return new ColorFactory(); 96 }else if ( "shapefactory".equalsIgnoreCase(factory) ){ 97 return new ShapeFactory(); 98 } 99 return null; 100 } 101 } 102 103 104 105 /** 106 * 抽象工厂模式测试类 107 */ 108 public class AbstractFactoryPattern { 109 public static void main (String [] args){ 110 //获取颜色工厂 111 AbstractFactory af = FactoryBuilder.getFactory("colorfactory"); 112 //创建红色对象 113 Color red = af.getColor("red"); 114 //输出信息 115 red.fill(); 116 //创建红色对象 117 Color green = af.getColor("green"); 118 //输出信息 119 green.fill(); 120 121 System.out.println("分割线---------------------------"); 122 123 AbstractFactory abstractFactory = FactoryBuilder.getFactory("shapefactory"); 124 Shape circle = abstractFactory.getShape("CIRCLE"); 125 circle.draw(); 126 Shape triangle = abstractFactory.getShape("triangle"); 127 triangle.draw(); 128 } 129 }
二：代理设计模式
代理模式指给一个对象提供一个代理对象，并由代理对象控制对原对象的引用。代理可以分为静态代理和动态代理。
通过代理模式，可以利用代理对象为被代理对象添加额外的功能，以此来拓展被代理对象的功能。可以用于计算某个方法执行时间，在某个方法执行前后记录日志等操作。
三：单例设计模式
单例模式指的是，一个类只允许创建一个实例化对象，分为懒汉模式与恶汉模式。
饿汉式：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象。不存在线程安全的问题。
1 public class TestSingleton{
2 //构造方法私有化
3 private TestSingleton(){}
4 //类加载时，创建一个实例化对象
5 private static final TestSingleton testSingleton = new TestSingleton();
6 //提供一个对外的方法 ， 返回对象实例
7 public static TestSingleton getTestSingleton(){
8 return testSingleton;
9 } 10 }
懒汉式：需要加上同步锁，同步锁影响了程序执行效率。
扫描二维码关注公众号，回复：
6948437 查看本文章
1）、双重if判断
1 public class TestSingleton{
2
3 /**
4 * volatile的作用是作为指令关键字，确保本条指令不会因编译器的优化而省略，
5 * 且要求每次直接读值。
6 * volatile让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工作内存”。
7 * 声明对象变量
8 * volatile 禁止指令重排 主要由于new TestSingleton();可能出现问题
9 */
10 private static volatile TestSingleton testSingleton = null ;
11
12 //构造方法私有化
13 private TestSingleton(){}
14
15 /**
16 * 提供一个对外的方法 ， 返回对象实例
17 * 双重 if 校验锁 (synchronized) 保证线程安全。
18 */
19 public staticTestSingleton getTestSingleton(){
20 //if判断，该对象还未实例化
21 if ( testSingleton == null ){
22 //加锁
23 synchronized (TestSingleton.class){ 24 //if判断，该对象还未实例化 25 if ( testSingleton == null ){ 26 testSingleton = new TestSingleton(); 27 } 28 } 29 } 30 return testSingleton; //返回实例对象 31 }
2）、内部类
1 public class TestSingleton{
2
3 //构造器私有化
4 private TestSingleton(){}
5
6 //静态内部类，在其中 实例化 私有的 静态的 外部类对象
7 private static class InternalClass{
8 //实例化外部类对象
9 private static final TestSingleton TESTSINGLETON = new TestSingleton();
10 }
11
12 //提供对外的方法
13 public static TestSingleton getTestSingleton(){ 14 return InternalClass.TESTSINGLETON ; 15 } 16 }
四：建造者设计模式
建造者模式指的是，将各种产品集中起来管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性。
五：适配器设计模式
适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的的类的兼容性问题。主要分三类：类的适配器模式、对象的适配器模式、接口的适配器模式。
适配器：当A接口中的方法过多，然而实现他的B子类只需要实现其中一两条，于是新建一个C类实现这个接口，C类中实现的方法都为空方法，然后B子类继承该C类，重写需要用到的方法。
六：MVC设计模式
适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的的类的兼容性问题。主要分三类：类的适配器模式、对象的适配器模式、接口的适配器模式。