我从这里学的:http://www.runoob.com/design-pattern/design-pattern-intro.html菜鸟教程
https://www.cnblogs.com/fengmao/p/8609440.html这个博客不错
设计模式:
1工厂模式:定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,主要解决接口选择的问题,让其子类实现工厂接口,返回的也是一个抽象的产品,创建过程在其子类执行。
应用实例: 1、您需要一辆汽车,可以直接从工厂里面提货,而不用去管这辆汽车是怎么做出来的,以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。
优点: 1、一个调用者想创建一个对象,只要知道其名称就可以了。 2、扩展性高,如果想增加一个产品,只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现,调用者只关心产品的接口。
缺点:每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得系统中类的个数成倍增加,在一定程度上增加了系统的复杂度,同时也增加了系统具体类的依赖。
步骤:创建接口,创建实现接口的实体类,定义工厂类,用工厂类获取接口对象。
简单工厂:
1 2 3 4 5 6 7 8 | 你会建立一个专门生产Sample实例的工厂:
那么在你的程序中,如果要创建ISample的实列时候可以使用 ISample sampleA=Factory.creator(1); |
/*工厂类*/
//1:创建一个接口
public interface Shape{
//声明接口中的方法
void draw();//这个接口会画画
}
//2:创建实体类实现接口
public class Rectangle implements Shape{
@Override
public void drow(){
System.out.println("Rectangle implements Shape:会画");
}
}
public class Square implements Shape{
@Override
public void drow(){
System.out.println("Square implements Shape:会画油Square");
}
}
public class Circle implements Shape{
@Override
public void drow(){
System.out.println(" Circle implements Shape:会画 Circle");
}
}
//3:创建一个工厂,生成基于给定信息的实体类的对象
public class ShapeFactory {
//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
//4.使用该工厂,通过传递类型信息来获取实体类的对象
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
//获取 Circle 的对象,并调用它的 draw 方法
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取 Rectangle 的对象,并调用它的 draw 方法
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取 Square 的对象,并调用它的 draw 方法
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
}
}
2单例设计模式:
简介
单例模式是一种常用的软件设计模式,其定义是单例对象的类只能允许一个实例存在。
许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。比如在某个服务器程序中,该服务器的配置信息存放在一个文件中,这些配置数据由一个单例对象统一读取,然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。
基本的实现思路
单例模式要求类能够有返回对象一个引用(永远是同一个)和一个获得该实例的方法(必须是静态方法,通常使用getInstance这个名称)。
单例的实现主要是通过以下两个步骤:
- 将该类的构造方法定义为私有方法,这样其他处的代码就无法通过调用该类的构造方法来实例化该类的对象,只有通过该类提供的静态方法来得到该类的唯一实例;
- 在该类内提供一个静态方法,当我们调用这个方法时,如果类持有的引用不为空就返回这个引用,如果类保持的引用为空就创建该类的实例并将实例的引用赋予该类保持的引用
public class Singleton { public static void main(String[] args) { SingleObject object= SingleObject.getInstance(); object.showMessage(); } } class SingleObject{ private static SingleObject instance=new SingleObject(); private SingleObject(){} public static SingleObject getInstance(){ return instance; } public void showMessage(){ System.out.print("hello world"); } } //懒汉式:线程安全 class SingleLazy{ private static SingleLazy s=null; private SingleLazy(){} public static SingleLazy getInstance(){ if(s==null){ synchronized(SingleLazy.class) { if(s==null) s=new SingleLazy(); } } return s; } } //饿汉式 class SingleHungry{ private final static SingleHungry instance=new SingleHungry(); private SingleHungry(){}; public static SingleHungry getInstance(){ return instance; } }
分类:
- 创建型模式-->对象怎么来
- 1 工厂模式(Factory Pattern) :定义一个创建对象的接口,让其子类自己决定实例化哪一个工厂类,工厂模式使其创建过程延迟到子类进行。ps:通过同一个接口创建不同对象
- 2 抽象工厂模式(Abstract Factory Pattern):提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。
- 3单例模式(Singleton Pattern):保证一个类仅有一个实例,并提供一个访问它的全局访问点。划重点
- 4建造者模式(Builder Pattern)
- 5原型模式(Prototype Pattern)
- 结构型模式-->对象和谁有关
-
- 适配器模式(Adapter Pattern)
- 是作为两个不兼容的接口之间的桥梁 举个真实的例子,读卡器是作为内存卡和笔记本之间的适配器。JAVA 中的 jdbc。
- 将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
-
主要解决在软件系统中,常常要将一些"现存的对象"放到新的环境中,而新环境要求的接口是现对象不能满足的。
何时使用: 1、系统需要使用现有的类,而此类的接口不符合系统的需要。 2、想要建立一个可以重复使用的类,用于与一些彼此之间没有太大关联的一些类,包括一些可能在将来引进的类一起工作,这些源类不一定有一致的接口。 3、通过接口转换,将一个类插入另一个类系中。
- 桥接模式(Bridge Pattern)
- 过滤器模式(Filter、Criteria Pattern)
- 组合模式(Composite Pattern)
- 装饰器模式(Decorator Pattern)
- 外观模式(Facade Pattern)
- 享元模式(Flyweight Pattern)
- 代理模式(Proxy Pattern)
- 行为型模式-->对象与对象在干嘛
-
- 责任链模式(Chain of Responsibility Pattern)
- 命令模式(Command Pattern)
- 解释器模式(Interpreter Pattern)
- 迭代器模式(Iterator Pattern)
- 中介者模式(Mediator Pattern)
- 备忘录模式(Memento Pattern)
- 观察者模式(Observer Pattern)
- 状态模式(State Pattern)
- 空对象模式(Null Object Pattern)
- 策略模式(Strategy Pattern)
- 模板模式(Template Pattern)
- 访问者模式(Visitor Pattern)
六大原则:
开闭原则:实现热插拔,提高扩展性。
里氏代换原则:实现抽象的规范,实现子父类互相替换;
依赖倒转原则:针对接口编程,实现开闭原则的基础;
接口隔离原则:降低耦合度,接口单独设计,互相隔离;
迪米特法则,又称不知道原则:功能模块尽量独立;
合成复用原则:尽量使用聚合,组合,而不是继承;