java设计模式（部分）_public class concretebuilder {-优快云博客

本文链接：https://blog.youkuaiyun.com/zc157158/article/details/88564149

java的设计模式大体上分为三大类：

创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式（11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

设计模式遵循的原则有6个：

1、开闭原则（Open Close Principle）

对扩展开放，对修改关闭。

2、里氏代换原则（Liskov Substitution Principle）

只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

使用多个隔离的借口来降低耦合度。

5、迪米特法则（最少知道原则）（Demeter Principle）

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。继承实际上破坏了类的封装性，超类的方法可能会被子类修改。

1. 工厂模式（Factory Pattern）

第一种：简单工厂模式（静态工厂模式），并不算是一种设计模式

常用的工厂模式是静态工厂，利用static方法，作为一种类似于常见的工具类Utils等辅助效果，一般情况下工厂类不需要实例化。

interface Food{}

class A implements Food{}
class B implements Food{}
class C implements Food{}

public class FootStaticFactory {
    //提供静态方法，需要什么食物就返回什么食物
    public static food get(String name){
	    if ( name.equals("A")) {
	        return new A();
	    }else if ( name.equals("B")){
	        return new B();
	    }else if ( name.equals("C")){
	        return new C();
	    }
    }
}

class Client{
    //客户端代码只需要将相应的参数传入即可得到对象
    Food food = FootStaticFactory.get("a");
}

第二种：工厂方法模式

这个是用来解决简单工厂存在的问题比如: 增加一个产品简单工厂需要对工厂类代码进行修改, 增加一个判断条件, 这样就增加了代码的复杂程度, 工厂方法为了解决这个问题, 通过多态的方式来实现不同的工厂类来生产不同的产品. 即会有一个工厂接口, 通过实现工厂接口的方式实现新的工厂类, 来代替修改工厂类代码, 这样会使得代码耦合度降低

interface Food{}

class A implements Food{}
class B implements Food{}
class C implements Food{}

public interface FoodFactory {
    
    /**
     * 生产可制造的食物
     * @return
     */
    public abstract Food createFood(String name);

}

public class FoodFactory1 implements FoodFactory{
	 @Override
    public Food createFood(String name) {
        if ( name.equals("A")) {
	        return new A();
	    }else if ( name.equals("B")){
	        return new B();
	    }
    }
}

public class FoodFactory2 implements FoodFactory{
	 @Override
    public Food createFood(String name) {
        if ( name.equals("A")) {
	        return new A();
	    }else if ( name.equals("C"))
	        return new C();
	    }
    }
}

class Client{
    //客户端代码只需要找到生产相应食物的工厂，再将相应的参数传入即可得到对象
    Food food = new FoodFactory1().get("b");
    Food food = new FoodFactory2().get("c");
}

第三种:抽象工厂模式

抽象工厂为产品分类, 将纵向的产品实现类, 横向化, 就是组成更大的产品工厂，用来生产复杂的产品

interface Food{}
interface Drink{}
interface Clothes{}

class A implements Food{}
class B implements Food{}
class C implements Food{}

class D implements Drink{}
class E implements Drink{}
class F implements Drink{}

class X implements Clothes{}
class Y implements Clothes{}
class Z implements Clothes{}

public interface MainFactory(){
	 /**
     * 生产可制造的食物
     * @return
     */
    public abstract Food createFood(String name);
	 /**
     * 生产可制造的饮品
     * @return
     */
    public abstract Drink createDrink(String name);
     /**
     * 生产可制造的衣服
     * @return
     */
    public abstract Clothes createClothes(String name);
}

//只生产食物的工厂
public class FootFactory implements MainFactory(){

	 @Override
    public Food createFood(String name) {
    	if ( name.equals("A")) {
	        return new A();
	    }else if ( name.equals("B")){
	        return new B();
	    }else if ( name.equals("C")){
	        return new C();
	    }
    }
     @Override
    public Drink createDrink(String name) {
    	return null;
    }
     @Override
    public Clothes createClothes(String name) {
    	return null;
    }
}

//只生产衣服的工厂
public class ClothesFactory implements MainFactory(){

	 @Override
    public Food createFood(String name) {
    	return null;
    }
     @Override
    public Drink createDrink(String name) {
    	return null;
    }
     @Override
    public Clothes createClothes(String name) {
    	if ( name.equals("X")) {
	        return new X();
	    }else if ( name.equals("Y")){
	        return new Y();
	    }else if ( name.equals("Z")){
	        return new Z();
	    }
    }
}

class Client{
    //客户端代码只需要找到对应生产该类产品的工厂，将相应的参数传入即可得到对象
    Food food = new FootFactory().createFood("b");
    Clothes clothes= new ClothesFactory().createClothes("x");
}

2. 单例模式（Singleton Pattern）

饿汉式：在程序启动或单件模式类被加载的时候，单件模式实例就已经被创建。

public Simple(){
     private static Single s=new Single();        
     private Single(){
        
     }  
     public static Simple getSimple(){
         return s;
     } 
}

懒汉式：当程序第一次访问单件模式实例时才进行创建。懒汉模式在使用时，容易引起不同步问题，所以应该创建同步"锁"，demo如下

class Single1 {
    private static Single1 s = null;

    public Single1() {

    }
       //同步函数的demo
    public static synchronized Single1 getInstance() {
        if (s == null)
            s = new Single1();

        return s;
    }
    //同步代码快的demo加锁，安全高效
    public static Single1 getInStanceBlock(){
        if(s==null)
            synchronized (Single1.class) {
                if(s==null)
                    s = new Single1();
            }
        return s; 
    }
}

3. 建造者模式（Builder Pattern）

定义：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示，这样的设计模式被称为建造者模式。

建造者模式的角色定义，在建造者模式中存在以下4个角色：
1 builder:为创建一个产品对象的各个部件指定抽象接口。
2 ConcreteBuilder:实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。
3 Director:构造一个使用Builder接口的对象。
4 Product:表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

比如我们要建造一个房子，房子就是一个Product类，我们最终就是为了构建它

public class Product {
    private String basic;//地基
    private String wall;//墙
    private String roofed;//楼顶

    public String getBasic() {
        return basic;
    }
    public void setBasic(String basic) {
        this.basic = basic;
    }
    public String getWall() {
        return wall;
    }
    public void setWall(String wall) {
        this.wall = wall;
    }
    public String getRoofed() {
        return roofed;
    }
    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }
    
}

首先我们要写一个build建造者接口

public interface Builder {
    //打基础
    public void  buildBasic();
    
    //砌墙
    public void  buildWalls();
    
    //封顶
    public void  roofed();
    
    //造房子
    public Product buildProduct();
}

ConcreteBuilder类来实现上面这个接口

public class ConcreteBuilder implements Builder{
    
    private Product product;
    
    public ConcreteBuilder(){
        product=new Product();
    }
    
    @Override
    public void buildBasic() {
        product.setBasic("打好基础");
    }

    @Override
    public void buildWalls() {
        product.setWall("砌墙");
    }

    @Override
    public void roofed() {
        product.setRoofed("封顶大吉");
    }

    @Override
    public Product buildProduct() {
        return product;
    }

}

Director:构造一个使用Builder接口的对象

public class Director {

    public Product constructProduct(ConcreteBuilder concreteBuilder){
        concreteBuilder.buildBasic();
        concreteBuilder.buildWalls();
        concreteBuilder.roofed();
        return concreteBuilder.buildProduct();
    }
}

测试

public class Test{
	public static void main(String[] args) {
		Director director = new Director();
		Product product = director.constructProduct( new ConcreteBuilder());
		System.out.println(product.getBasic());
		System.out.println(product.getWall());
		System.out.println(product.getRoofed());
	}
}

转载自：https://www.cnblogs.com/liaoweipeng/p/5790603.html

4：适配器模式（Adapter Pattern）

定义：适配器就是一种适配中间件，它存在于不匹配的二者之间，用于连接二者，将不匹配变得匹配，简单点理解就是平常所见的转接头，转换器之类的存在。
适配器模式有三种：类适配器、对象适配器、接口适配器。前二者在实现上有些许区别，作用一样，第三个接口适配器差别较大。

第一种：类适配器模式：

原理：通过继承来实现适配器功能。
应用场景：
当我们要访问的接口A中没有我们想要的方法，却在另一个接口B中发现了合适的方法，我们又不能改变访问接口A，在这种情况下，我们可以定义一个适配器p来进行中转，这个适配器p要实现我们访问的接口A，这样我们就能继续访问当前接口A中的方法（虽然它目前不是我们的菜），然后再继承接口B的实现类BB，这样我们可以在适配器P中访问接口B的方法了，这时我们在适配器P中的接口A方法中直接引用BB中的合适方法，这样就完成了一个简单的类适配器。

详见下方实例：我们以ps2与usb的转接为例
我手中有个ps2插头的设备，但是主机上只有usb插头的插口，怎么办呢？弄个转换器，将ps2插头转换成为USB插头就可以使用了
ps2接口：Ps2

public interface Ps2 {
	void isPs2();
}

USB接口：Usb

public interface Usb {
	void isUsb();
}

USB接口实现类：Usber

public class Usber implements Usb {
     @Override
    public void isUsb() {
        System.out.println("USB口");
    }
}

适配器：Adapter

public class Adapter extends Usber implements Ps2 {
    @Override
    public void isPs2() {
        isUsb();
    }
}

测试：

public class Clienter {
    public static void main(String[] args) {
        Ps2 p = new Adapter();
        p.isPs2();
    }
}
//输出结果：USB口

第二种：对象适配器模式

原理：通过组合来实现适配器功能。
应用场景：
当我们要访问的接口A中没有我们想要的方法，却在另一个接口B中发现了合适的方法，我们又不能改变访问接口A，在这种情况下，我们可以定义一个适配器p来进行中转，这个适配器p要实现我们访问的接口A，这样我们就能继续访问当前接口A中的方法（虽然它目前不是我们的菜），然后在适配器P中定义私有变量C（对象）（B接口指向变量名），再定义一个带参数的构造器用来为对象C赋值，再在A接口的方法实现中使用对象C调用其来源于B接口的方法。

其他代码和上面一样不变，适配器稍作更改

public class Adapter implements Ps2 {     
    private Usb usb;
    public Adapter(Usb usb){
        this.usb = usb;
    }
    @Override
    public void isPs2() {
        usb.isUsb();
    }
}

测试

public class Clienter {
    public static void main(String[] args) {
        Ps2 p = new Adapter(new Usber());
        p.isPs2();
    }
}

第三种：接口适配器模式

原理：通过抽象类来实现适配，这种适配稍别于上面所述的适配。

使用场景：
当存在这样一个接口，其中定义了N多的方法，而我们现在却只想使用其中的一个到几个方法，如果我们直接实现接口，那么我们要对所有的方法进行实现，哪怕我们仅仅是对不需要的方法进行置空（只写一对大括号，不做具体方法实现）也会导致这个类变得臃肿，调用也不方便，这时我们可以使用一个抽象类作为中间件，即适配器，用这个抽象类实现接口，而在抽象类中所有的方法都进行置空，那么我们在创建抽象类的继承类，而且重写我们需要使用的那几个方法即可。

目标接口：A

public interface A {
    void a();
    void b();
    void c();
    void d();
    void e();
    void f();
}

适配器：Adapter

public abstract class Adapter implements A {
    public void a(){}
    public void b(){}
    public void c(){}
    public void d(){}
    public void e(){}
    public void f(){}
}

实现类：AImpl

public class AImpl extends Adapter {
    public void a(){
        System.out.println("实现A方法被调用");
    }
    public void d(){
        System.out.println("实现d方法被调用");
    }
}

测试

public class Clienter {
    public static void main(String[] args) {
        A a = new AImpl();
        a.a();
        a.d();
    }
}

转载自：http://www.cnblogs.com/V1haoge/p/6479118.html

5.装饰者模式(Decorator Pattern)

定义：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。
使用场景：

角色：

抽象构件角色（Component）：装饰者和被装饰者共同的父类，是一个接口或者抽象类，用来定义基本行为
具体构件角色（Concrete Component）：定义具体对象，即被装饰者
抽象装饰角色（Decorator）：继承自Component，从外类来扩展ConcreteComponent。对于ConcreteComponent来说，不需要知道Decorator的存在，Decorator是一个接口或抽象类
具体装饰角色（Concrete Decorator）：用于扩展ConcreteComponent

假设一个应用场景，原本狗会呼吸，吃饭，睡觉，现在我们交给它添加功能，会叫，会玩耍

抽象构件角色（对应动物类）

public interface Component {
	void function();
}

具体构件角色（对应狗）

public class ConcreteComponent implements Component {
 
	@Override
	public void function() {
		System.out.println("基本功能：呼吸+吃饭+睡觉");
	}

装饰角色

public class Decorator implements Component {
	private Component component; //持有一个Component类型的对象引用
	
	public Decorator(Component component) {
		this.component = component;
	}
 
	@Override
	public void function() {
		component.function(); //客户端的调用委派给具体的子类
	}
}

具体装饰角色（对应叫和玩耍这两个功能）

public class ConcreteDecorator extends Decorator {
 
	public ConcreteDecorator(Component component) {
		super(component);
	}
 
	@Override
	public void function() {
		super.function();
		System.out.println("附加功能：");
		this.bellow();
		this.play();
		
	}
	
	private void bellow() {
		System.out.println("叫");
	}
	
	private void play() {
		System.out.println("玩耍");
	}
}

测试：

public class ClientTest {
	public static void main(String[] args) {
		Component component = new ConcreteComponent(); 
		System.out.println("------装饰前：-------");
		component.function();
		Component newComponent = new ConcreteDecorator(component);
		System.out.println("------装饰后：-------");
		newComponent.function();
	}
}

输出：
------装饰前：-------
基本功能：呼吸+觅食+睡觉
------装饰后：-------
基本功能：呼吸+觅食+睡觉
附加功能：吃肉+吼叫