设计模式java代码实现

创建型模式(5)

单例模式

package site.yuanrui.establish;
/**  
 * @Title: Single.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/*节省内存空间
避免频繁创建销毁对象，提高性能
避免对共享资源的多重占用
可以全局访问*/
public class SinglePattern {
   
   
    public static void main(String[] args) {
   
   
        System.out.println("Singleto:"+(Singleton.getInstance()!=null));
        System.out.println("Singleto2:"+(Singleton2.getInstance()!=null));
    }

}
class Singleton{
   
   
    private static Singleton singleton = new Singleton();
    private Singleton(){
   
   }
    public static Singleton getInstance() {
   
   
        return singleton;
    }
}
class Singleton2{
   
   
    private static Singleton2 singleton2;
    private Singleton2(){
   
   }
    public static synchronized Singleton2 getInstance(){
   
   
        if (singleton2 ==null) {
   
   
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

工厂模式

package site.yuanrui.establish;
/**  
 * @Title: FactoryPattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
public class FactoryPattern {
   
   
    public static void main(String[] args) {
   
   
        IFactory factory = new Factory();
        IProduct product = factory.createProduct();
        product.productMethod();
    }

}
interface IProduct{
   
   
    public void productMethod();
}
class Product implements IProduct{
   
   
    @Override
    public void productMethod() {
   
   
        System.out.println("Product");
        
    }
}
interface IFactory{
   
   
    public IProduct createProduct();
}
class Factory implements IFactory{
   
   

    @Override
    public IProduct createProduct() {
   
   
            return new Product();
    }
}

抽象工厂模式

package site.yuanrui.establish;
/**  
 * @Title: AbstractFactoryPattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
//可以在类内部对产品族进行约束                          
public class AbstractFactoryPattern {
   
   
    public static void main(String[] args) {
   
   
        IFactory1 factory = new Facctory();
        factory.createProduct1().show();
        factory.createProduct2().show();
    }

}
interface IProduct1{
   
   
    public void show();
}
interface IProduct2{
   
   
    public void show();
}
class Product1 implements IProduct1{
   
   

    @Override
    public void show() {
   
   
        System.out.println("这是I型产品");
    }
}
class Product2 implements IProduct2{
   
   

    @Override
    public void show() {
   
   
        System.out.println("这是II型产品");
    }
}
interface IFactory1{
   
   
    public IProduct1 createProduct1();
    public IProduct2 createProduct2();
}
class Facctory implements IFactory1{
   
   

    @Override
    public IProduct1 createProduct1() {
   
   
        return new Product1();
    }

    @Override
    public IProduct2 createProduct2() {
   
   
        return new Product2();
    }
    
}

建造者模式

package site.yuanrui.establish.builderPattern;


/**  
 * @Title: BuilderPattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/**
一般用来创建更为复杂的对象，因为对象的创建过程更为复炸，因此将对象的创建过程独立出来组成一个新的类-导演类
 */
public class BuilderPattern {
   
   
    public static void main(String[] args) {
   
   
        Director director = new Director();
        Product product1 = director.getAProduct();
        Product product2 = director.getBPorduct();
        product1.showProduct();
        product2.showProduct();
    }
}
class Product{
   
   
    private String name;
    private String type;
    public void showProduct(){
   
   
        System.out.println("名称："+this.name);
        System.out.println("型号："+this.type);
    }
    public void setName(String name){
   
   
        this.name = name;
    }
    public void setType(String type){
   
   
        this.type = type;
    }
}
abstract class Builder{
   
   
    public abstract void setPart(String arg1,String arg2);
    public abstract Product getProduct();
}
class ConcreteBuilder extends Builder{
   
   
    private Product product = new Product();
    public Product getProduct(){
   
   
        return product;
    }
    @Override
    public void setPart(String arg1, String arg2) {
   
   
        product.setName(arg1);
        product.setType(arg2);;
    }
}
class Director{
   
   
    private Builder builder = new ConcreteBuilder();
    public Product getAProduct(){
   
   
        builder.setPart("宝马汽车", "X7");
        return builder.getProduct();
    }
    public Product getBPorduct(){
   
   
        builder.setPart("奥迪汽车", "Q5");
        return builder.getProduct();
    }
}

原型模式

package site.yuanrui.establish;
/**  
 * @Title: PrototypePattern.java  
 * @Package site.yuanrui  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月23日  
 * @version V1.0  
*/
/*主要用于队形的复制
简化对象的创建
需要重复地创建相似对象的可以考虑使用原型模式*/
public class PrototypePattern {
   
   
    public static void main(String[] args) {
   
   
        ConcretePrototype cp = new ConcretePrototype();
        for (int i = 0; i < 10; i++) {
   
   
            ConcretePrototype clonecp = (ConcretePrototype) cp.clone();
            clonecp.show();System.out.println(i);
        }
    }

}
class Prototype implements Cloneable{
   
   //只有实现了该接口的类上才能使用clone方法
    public Prototype clone(){
   
   
        Prototype prototype = null;
        try {
   
   
            prototype = (Prototype) super.clone();
        }
        catch (CloneNotSupportedException e) {
   
   
            e.printStackTrace();
         }
        return prototype;
    }
}
class ConcretePrototype extends Prototype{
   
   
    public void show() {
   
   
        System.out.print("原型模式实现类");
        
    }
}

结构型模式(7)

适配器模式

package site.yuanrui.structure;

import com.sun.org.apache.xerces.internal.impl.dv.ValidatedInfo;

/**  
 * @Title: AdapterPattern.java  
 * @Package site.yuanrui.structure  
 * @Description: 
 * @author YUANRUI  
 * @date 2019年3月24日  
 * @version V1.0  
*/
/*
 * 适用性：
 * 想使用一个已经存在的类，而它的接口不符合你的需求
 * 你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类协同工作
 * 想使用一些已经存在的子类，不可能对每个进行子类化以匹配他们的接口。对象适配器可以适配它的父类接口
 * */
public class AdapterPattern {
   
   
    public static void main(String[] args) {
   
   
        Target target = new Adapter(new Adaptee());
        target.adapteeMethod();
        target.adapterMethod();
    }
}
//定义Client使用的与特定领域相关的接口
interface Target{
   
   
    void adapteeMethod();
    void adapterMethod();
}
//定义一个已经存在的接口，这个接口需要适配
class Adaptee{
   
   
    public void adapteeMethod(){
   
   
        System.out.println("Adaptee method!");
    }
}
//对Adaptee的接口与Target接口进行适配
class Adapter implements Target{
   
   
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
   
   
        this.adaptee = adaptee;
    }
    @Override
    public void adapteeMethod() {
   
   
        adaptee.adapteeMethod();
    }
    @Override
    public void adapterMethod() {
   
   
        System.out.println("Adapter method!");
    }
}

桥接模式

package site