设计原则
设计模式分类
设计模式
工厂模式
简单工厂模式（也叫静态工厂模式）
简介
定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延伸到子类。
uml图
角色
- 抽象产品（接口或抽象类）
- 具体产品（继承或者实现都行）
- 工厂类（通过循环条件来new 哪个具体产品）
例子(以+-*/为例)
- 抽象产品
public abstract class Operation {
public abstract float getResult(float firstNumber, float secondNumber);
}- 具体产品
public class SubOperation extends Operation {
@Override
public float getResult(float firstNumber, float secondNumber) {
return firstNumber-secondNumber;
}
}public class MulOperation extends Operation {
@Override
public float getResult(float firstNumber, float secondNumber) {
return firstNumber*secondNumber;
}
}public class DivOperation extends Operation {
@Override
public float getResult(float firstNumber, float secondNumber) {
return firstNumber/secondNumber;
}
}- 工厂类
public class OperationFactory {
public static Operation getOperation(String quotaFlag){
Operation o = null;
// 通过条件判断类来决定哪个产品
switch (quotaFlag){
case "+" : o = new AddOperation();
case "-" : o = new SubOperation();
case "*" : o = new MulOperation();
case "/" : o = new DivOperation();
default:break;
}
return o;
}
}- 应用程序
public class Computer {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入第一个数字：");
float firstNum = in.nextFloat();
System.out.println("请输入第二个数字：");
float secondNum = in.nextFloat();
System.out.println("请输入运算符号：");
String countQuato = in.next();
System.out.println(count(firstNum,secondNum,countQuato));
}
private static float count(float firstNum,float secondNum , String countQuota){
//通过工厂类获取对象
Operation operation = OperationFactory.getOperation(countQuota);
return operation.getResult(firstNum,secondNum);
}
}缺点
产品部分来说，它是符合开闭原则的；但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑，这显然是违背开闭原则。
工厂方法模式
简介
简单工厂模式虽然解决了解耦问题。但如果要增加某个产品的时候，工厂类就必须对里面的条件进行修改。违反了对扩展开发，对修改关闭的原则。因此必须把工厂再抽象化出来。当有产生新产品的时候，就新建一个新的工厂来实现它。
角色
- 抽象产品
- 很多个具体产品
- 抽象工厂
- 很多个工厂
- 控制生产
例子（同样以加减乘除为例）
产品不变.和上面的相同。
1. 抽象工厂
public interface IFractory {
public Operation generateOper();
}- 具体工厂
public class AddOperationFactory implements IFractory{
@Override
public Operation generateOper() {
return new AddOperation();
}
}public class SubOperationFactory implements IFractory {
@Override
public Operation generateOper() {
return new SubOperation();
}
}….
3. 应用程序
IFractory fractory = new AddOperationFactory();
Operation operation = fractory.generateOper();
operation.getResult(firstNum,secondNum);抽象工厂模式
简介
抽象工厂是工厂方法的延伸。工厂方法里面一个工厂只能生产一种产品。而抽象工厂则是一个工厂可以生产很多产品。
角色
角色和工厂方法模式一样。
例子
- 抽象产品1
public interface IUser {
public void insert();
public void getById();
}- 具体产品1
public class SqlServerUser implements IUser {
@Override
public void insert() {
System.out.println("insert into sqlserver.");
}
@Override
public void getById() {
System.out.println("get user by id from sqlserver.");
}
}- 抽象产品2
public interface IDepartment {
public void insert();
public void getDepartmentById();
}- 具体产品2
public class SqlServerDepartment implements IDepartment {
@Override
public void insert() {
System.out.println("insert department into sqlserver.");
}
@Override
public void getDepartmentById() {
System.out.println("get department in sqlserver by id.");
}
}- 抽象工厂（下面有两种产品）
public interface IFacfory {
public IUser createUser();
public IDepartment createDepartment();
}- 具体工厂
/不同产品组使用一个工厂
public class SqlServerFactory implements IFacfory {
@Override
public IUser createUser() {
return new SqlServerUser();
}
@Override
public IDepartment createDepartment() {
return new SqlServerDepartment();
}
}- 应用程序
IFacfory facfory = new AccessFactory();
IUser user = facfory.createUser();
IDepartment department = facfory.createDepartment();
user.insert();
user.getById();
department.insert();
department.getDepartmentById();
总结工厂模式
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
单例模式
简介
保证一个类仅有一个实例，并提供一个访问他的全局访问点。
应用场景
在某些情况下，我们可能只需要某个类智能创建一个对象，即不让用该类实例化多于两个的实例。比如打印机。所有的打印的机子都通过一台打印机。这样避免了，同一个文件有两台打印机打印的情况。
角色
- 单例类
UML图解
未完待续。。。
例子
关于单例模式有很多种，下面来一一列举。
- 懒汉式单例模式(线程不安全)
public class Singleton{
private Singleton(){}
private static Singleton = null;
public static Singleton getSingleton (){
if( Singleton == null ){
Singleton = new Singleton ();
}
return Singleton
}懒汉式顾名思义，就是用到的时候再去创建该实例。但遇到高并发情况下，有可能产生线程不安全的情况。
- 懒汉式单例模式(线程安全)
public class Singleton{
private Singleton(){}
private static Singleton = null;
public static synchronized Singleton getSingleton (){
if( Singleton == null ){
Singleton = new Singleton ();
}
return Singleton
}
}这种比1中加了锁，能够很好处理线程，但加锁影响了性能。
- 饿汉式单例模式（线程安全，但消耗内存）
public class Singleton{
private Singleton(){}
private static Singleton = new Singleton;
public static Singleton getSingleton (){
return Singleton
}
}虽然能避免了线程安全和加锁。但初始化就加载，比较消耗内存。但现在一般不考虑硬件问题。
- 双重检查加锁 综合。既可以不用类加载初始化，又能保持线程安全
public class Singleton {
private volatile static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance(){
//先检查实例是否存在，如果不存在才进入下面的同步块
if(instance == null){
//同步块，线程安全的创建实例
synchronized (Singleton.class) {
//再次检查实例是否存在，如果不存在才真正的创建实例
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}用双重if判断，复杂，容易出错。也有加锁，还是影响性能。
- 静态内部类方法
public class Singleton {
private Singleton(){}
/**
* 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
* 没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载。
*/
private static class SingletonHolder{
/**
* 静态初始化器，由JVM来保证线程安全
*/
private static Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return SingletonHolder.instance;
}
}这种最好的，既可以不用类加载初始化，又能保持线程安全。额外知识：
大家都知道，在多线程开发中，为了解决并发问题，主要是通过使用synchronized来加互斥锁进行同步控制。但是在某些情况中，JVM已经隐含地为您执行了同步，这些情况下就不用自己再来进行同步控制了。这些情况包括：
1.由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时
2.访问final字段时
3.在创建线程之前创建对象时
4.线程可以看见它将要处理的对象时
这种内部类与其外部类之间并没有从属关系，加载外部类的时候，并不会同时加载其静态内部类，只有在发生调用的时候才会进行加载，加载的时候就会创建单例实例并返回，有效实现了懒加载（延迟加载），至于同步问题，我们采用和饿汉式同样的静态初始化器的方式，借助JVM来实现线程安全。
- 单例和枚举
http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html最优解
适配器模式
观察者模式
代理模式
简介
当用户希望和某个对象打交道，但程序可能不希望用户直接和某个对象打交道或者不能。这时候可以使用一个代理对象。该对象里面再调用实际对象的方法。比如老板和秘书，都有打电话的功能。用户是通过秘书来联系，然后秘书再联系老板。
uml图
角色
- 抽象主题
- 实际对象（老板）
- 代理对象（秘书）
例子
- 抽象主题
public interface phone{
void heardPhone();
}- 实际对象
public boss implements phone(){
public void heardPhone(){
System.out.println("有人打电话");
}
}- 代理对象
public secretary implements phone(){
private boss;
public void heardPhone(){
boss = new boss();
boss.heardPhone();
}
}解决了什么问题
可以让用户和实际对象实现了解耦。并且，当用户请求对个某个对像时，做一些动作。比如日志操作，校验等等。
Java 动态代理
以上都是静态代理。在Java中还有动态代理以及Cglib代理。
https://www.cnblogs.com/cenyu/p/6289209.html
Java动态代理
Cglib代理代理
桥接模式
简介
将抽象部分与它的实现部分分离，是他们可以独立地变化。
应用场景
当有两个抽象类。一个抽象类的子类的去调用两一个抽象类子类实现的方法。
UML图
角色
- 抽象类
- 继承该抽象类
- 另一个抽象类（或接口）
- 具体实现方法类
例子(以晚餐为例)
- 数据库连接接口
package Bridge;
/**
* Created by looper on 2017/8/16.
*/
public interface Driver {
public void connect();
- 数据库实现类
package Bridge;
/**
* Created by looper on 2017/8/16.
*/
public class MysqlDriver implements Driver {
@Override
public void connect() {
System.out.println("连接Mysql数据库");
}
- 抽象类
package Bridge;
/**
* Created by looper on 2017/8/16.
*/
public abstract class Bridge {
private Driver driver;
public void connect(){
driver.connect();
}
public void setDriver(Driver driverTemp){
this.driver = driverTemp;
}
public Driver getDriver(){
return this.driver;
}
- 继承抽象类
package Bridge;
/**
* Created by looper on 2017/8/16.
*/
public class MyBridge extends Bridge {
- 实现
Bridge mysqlBridge = new MyBridge();
Driver mysqlDriver = new MysqlDriver();
mysqlBridge.setDriver(mysqlDriver);
mysqlBridge.connect();缺点
模板方法模式
简介
定义一个操作中算法的框架（抽象类），而将一些步骤延迟到子类中。模板方法使子类可以不改变一个算法的结构即可重定义该算法的某些特点步骤。
应用场景
对于某一种功能实现是需要一系列方法步骤来实现的时候，可以参考该模板方法。比如数据库的查询。在查询之前，需要用到数据库的加载、连接等，这些方法是需要步骤来实现。
角色
- 抽象模板（Abstract Template）
- 具体模板（Concrete Template）
UML图解
未完待续。。。
例子
以吃饭过程为例。在吃饭过程中，有洗手、盛饭、上菜等操作。
- 抽象模板（晚餐）
public abstract class Dinner(){
//这个就是模板方法。通过这个方法定义了一系列操作。
// 但通常不允许子类去重写该方法。所以一般用final类修饰该方法。
public final void eat(){
wash();
upRice();
upFood();
}
public abstract void wash();
public abstract void upRice();
public abstract void upFood();
}- 具体模板
public MyDinner extends dinner（）{
@Override
public void wash(){
System.out.println("洗手...")
}
@Override
public void upRice(){
System.out.println("盛饭...")
}
@Override
public void upFood(){
System.out.println("上菜...")
}
}- 应用程序
public class TemplatePatternDemo {
public static void main(String[] args) {
Dinner dinner = new MyDinner();
dinner.eat;
}
}扩展
由于抽象类中也可以定义具体的方法，那么所有子类可以继承父类的共同方法，对于一些特殊的子类，可以选择重写父类的方法。就恰好也体现了继承的特性。
439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
