设计模式

设计原则：
1：单一职责原则：就一个类而言，应该仅有一个引起他变化的原因。如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会消弱获知抑制这个类完成其他职责的能力。这种耦合会导致弱设计，当变化发生，设计会遭受到意想不到的破坏。
2：开闭原则：是说软件实体应该可以扩展，但是不可修改。对扩展开放，对修改关闭。对程序的改动是通过增加新代码进行的，而不是更改现有的代码。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。为了是程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类。
3：依赖倒转原则：A:高层模块不应该依赖底层，两个都应该依赖对象 B：抽象不应该依赖细节。细节应该依赖抽象。针对接口编程：依赖于抽象而不依赖于具体。
4：里式替代原则：子类必须能够替换它们的父类型。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。
设计模式：
1：工厂模式：
工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽起来，达到提高灵活性。
工厂模式分为三种：
1）简单工厂模式 （静态方法模式）
2）工厂方法模式 与简单工厂模式统称普通工厂模式，将简单工厂模式看为工厂方法模式的特列。
3）抽象工厂模式
普通工厂模式和抽象工厂模式区别：
工厂方法模式：
1）一个抽象产品类，可以派生出多个具体的产品了
2）一个抽象工厂类，可以派生多个具体工厂类
3）每个具体工厂类只能创建一个具体产品类实例。
抽象工厂模式：
1）多个抽象产品类，每个抽象产品了可以派生多个具体产品类。
2）一个抽象工厂类可以创建多个具体工厂类。
3）每个具体工厂类可以创建多个具体产品类实例。
即：工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个；工厂方法模式的具体工厂类只能创建一个具体产品类，而抽象工厂模式可以创建多个。
1.1简单工厂模式：
在简单工厂模式中，一个工厂类处于对产品类实例化调用的中心位置，它决定那一个产品类被调用。
组成：
1）工厂类角色：本模式中心，含一定的商业逻辑和判断逻辑。由一个具体类实现。
2）抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类实现
3）具体产品角色：工厂类创建的对象就是此角色的实例。由一个具体类实现。

抽象产品类：
abstract class BMW {
public void proBMW() {
}
}
具体产品类：
/**
* 宝马车具体实现类
* @author pc7
*
*/
public class BMW523 extends BMW {
public void proBMW() {
System.out.println(“BMW523”);
}
}
/**
* 宝马车具体实现类
* @author pc7
*
*/
public class BMW320 extends BMW {
public void proBMW() {
System.out.println(“BMW320”);
}
}

/**
* 核心工厂类
* @author pc7
*
*/
public class BMWFactory {
//采用静态方法（静态工厂模式）
public static BMW createBMW320(){
return new BMW320();
}
public static BMW createBMW523(){
return new BMW523();
}
}
客户端
public class Client {
public static void main(String[] args) {
BMWFactory facotry=new BMWFactory();
BMW bmw320=facotry.createBMW320();
bmw320.proBMW();
}
}

1.2工厂方法模式：
工厂方法模式是简单工厂模式的进一步抽象和推广，工厂方法模式里不再只有一个工厂类决定哪一个产品类应当被实例化，这个决定被交给抽象工厂的子类去做。
组成：
1）抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口获知必须继承的父类。由抽象类和接口来实现。
2）具体工厂角色：它含有和业务逻辑相关的代码。由应用程序调用以创建对应的具体产品的对象。
3）抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类实现
4）具体产品角色：具体工厂角色创建的对象就是此角色的实例。由一个具体类实现。

代码：
抽象产品类：
abstract class BMW {
public void proBMW() {
}
}
具体产品类：
/**
* 宝马车具体实现类
* @author pc7
*
*/
public class BMW523 extends BMW {
public void proBMW() {
System.out.println(“BMW523”);
}
}
/**
* 宝马车具体实现类
* @author pc7
*
*/
public class BMW320 extends BMW {
public void proBMW() {
System.out.println(“BMW320”);
}
}
/**
* 抽象工厂类
* @author pc7
*
*/
public interface BMWFactoryAb {
public BMW createBmw();
}
/**
* 具体工厂类
* @author pc7
*
*/
public class BMWFactoryAb320 implements BMWFactoryAb {
@Override
public BMW createBmw() {
return new BMW320();
}
}
/**
* 具体工厂类
* @author pc7
*
*/
public class BMWFactoryAb523 implements BMWFactoryAb {
@Override
public BMW createBmw() {
return new BMW523();
}
}
客户端
public class Client1 {
public static void main(String[] args) {
BMWFactoryAb factory=new BMWFactoryAb320();
BMW bmw=factory.createBmw();
bmw.proBMW();
}
}
1.3抽象工厂模式：
抽象工厂模式和工厂方法模式的区别在于需要创建对象的负责程度上。而且抽象工厂模式在三个里面最为抽象，最具有一般性。抽象工厂模式的用意是：给客户提供一个接口，可以创建多个产品族中的产品对象。而且使用抽象工厂模式还要满足以下条件：
1）：系统有多个产品族，而系统一次只能消费其中一族产品。
2）：同属于同一个产品族的产品一起使用。
组成：
1）抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口获知必须继承的父类。由抽象类和接口来实现。
2）具体工厂角色：它含有和业务逻辑相关的代码。由应用程序调用以创建对应的具体产品的对象。
3）抽象产品角色：它一般是具体产品继承的父类或者实现的接口。由接口或者抽象类实现
4）具体产品角色：具体工厂角色创建的对象就是此角色的实例。由一个具体类实现。

代码：
代码：
抽象产品类1：
abstract class BMW {
public void proBMW() {
}
}
具体产品类：
/**
* 宝马车具体实现类
* @author pc7
*
*/
public class BMW523 extends BMW {
public void proBMW() {
System.out.println(“BMW523”);
}
}
/**
* 宝马车具体实现类
* @author pc7
*
*/
public class BMW320 extends BMW {
public void proBMW() {
System.out.println(“BMW320”);
}
}
抽象产品类2：
abstract class Aircondition {
public void proAir() {
}
}
产品2实现类：
public class AirconditionBmw320 extends Aircondition{
public void proAir() {
System.out.println(“AirconditionBmw320”);
}
}
public class AirconditionBmw523 extends Aircondition {
public void proAir() {
System.out.println(“AirconditionBmw523”);
}
}

/**
* 抽象工厂类
* @author pc7
*
*/
public interface BMWFactoryAb {
public BMW createBmw();
public Aircondition createircondition();
}
/**
* 具体工厂类
* @author pc7
*
*/
public class BMWFactoryAb320 implements BMWFactoryAb {
@Override
public BMW createBmw() {
return new BMW320();
}
@Override
public Aircondition createircondition() {
// TODO Auto-generated method stub
return new AirconditionBmw320();
}

}
/**
* 具体工厂类
* @author pc7
*
*/
public class BMWFactoryAb523 implements BMWFactoryAb {
@Override
public BMW createBmw() {
return new BMW523();
}
@Override
public Aircondition createircondition() {
// TODO Auto-generated method stub
return new AirconditionBmw523();
}
}
客户端
public class Client1 {
public static void main(String[] args) {
BMWFactoryAb factory=new BMWFactoryAb320();
BMW bmw=factory.createBmw();
Aircondition air= factory.createircondition();
bmw.proBMW();
air.proAir();
}
}
1.4代理模式：
代理模式提供了对目标对象另外的访问方式，即通过代理对象访问目标对象。
优点：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能。（不要随意去改别人已经写好的代码，如若修改，可以通过代理类来扩展该方法。）
1.4.1 静态代理模式：
静态代理在使用时，需要定义接口或者父类，被代理对象和代理对象一起实现相同的接口或者继承相同的父类。
比如访问数据库操作类

代码：
目标对象
public interface IUserDao {
void save();
}
实际对象
public class UserDao implements IUserDao {
@Override
public void save() {
System.out.println(“wwwwww”);
}
}
代理对象
public class UserDaoProxy implements IUserDao {
private IUserDao target;
public UserDaoProxy(IUserDao target){
this.target=target;
}
@Override
public void save() {
// TODO Auto-generated method stub
target.save();
}
}
客户端
public static void main(String[] args) {
// 目标对象
UserDao userDao =new UserDao();
//代理对象
UserDaoProxy proxy =new UserDaoProxy(userDao);
proxy.save();

}

静态代理模式优缺点：
1：可以在不修改目标对象的功能前提下，对目标功能扩展
2：缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类，类太多。同时，一旦接口增加方法，目标对象与代理对象都要维护。（可以使用动态代理）
1.4.2 动态代理模式：
动态代理有以下特点：
1：代理对象，不需要实现接口
2：代理对象的生成，是利用jdk的API，动态在内存中构建代理对象（需要我们指定创建代理对象/目标对象实现的接口类型）
3：动态代理也叫：jdk代理，接口代理

jdk中生成代理对象的API
代理类所在包：java.lang.reflect.Proxy
JDk实现代理只需要newProxyInstance方法，但是该方法需要接受三个参数

Static Object newProxyInstance(ClassLoader loader,Class