【Java】 Java常用的幾個設計模式實例

一.單例模式

public class SingletonDemo {
    public static void main(String[] args) {
        //
    }
}

class User1{//餓漢式
    User1(){
        
    }
    private static User1 zs = new User1();
    private static User1 getZs(){
        return zs;
    }
}
class User2{//懶漢式
    private User2(){
        
    }
    private static User2 ls = null;
    private synchronized static User2 getLs(){//為了線程安全，加上synchronized修飾
        if(ls == null){
            ls = new User2();
        }
        return ls;
    }
}

class User3 {// 雙重加鎖機制
    private User3() {

    }

    private static User3 ww = null;

    private static User3 getWw() {
        if (ww == null) {
            synchronized (User3.class) {//只有ww為null的時候,創建過程中加上同步鎖
                if (ww == null) {
                    ww = new User3();
                }
            }
        }
        return ww;
    }
}

二.簡單工廠模式 

public class SimpleFactoryDemo {
    public static void main(String[] args) {
         Factory.create("productA");
         Factory.create("ProductB");
    }
}

interface Product {
    //聲明類所需繼承的共同接口，也可以是抽象類
}
class ProductA implements Product {
    public ProductA() {
        System.out.println("ProductA");
    }
}

class ProductB implements Product {
    public ProductB() {
        System.out.println("ProductB");
    }
}

class Factory {
    //可以在工廠類中添加任何你所需要的邏輯
    public static Product create(String str)
    {
        //生成ProductA
        if(str.equalsIgnoreCase("ProductA"))
        {
            return new ProductA();
        }
        else
            //生成ProductB
            if(str.equalsIgnoreCase("ProductB"))
            {
                return new ProductB();
            }
        return null;
    }

}

三.工廠方法模式

public class FactoryMethodDemo {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        factory.createProduct();
        factory = new FactoryB();
        factory.createProduct();
    }
}
interface Product{}
interface Factory {
    //聲明產生產品類的方法
    public Product createProduct();
}
class ProductA implements Product {
    public ProductA() {
        System.out.println("ProductA");
    }
}
class ProductB implements Product {
    public ProductB() {
        System.out.println("ProductB");
    }
}

class FactoryA implements Factory {
    //實現工廠類的方法生成產品類A
    public Product createProduct()
    {
        return new ProductA();
    }

}

class FactoryB implements Factory {
    //實現工廠類的方法生成產品類B
    public Product createProduct()
    {
        return new ProductB();
    }
}

四.抽象工廠模式

public class AbstractFactory {
    public static void main(String[] args) {
        Factory factory = new FactoryA();
        factory.createGift();
        factory.createProduct();
    }
}

interface Product{}
interface Gift {}//也可以是抽象類
class ProductA implements Product {
    public ProductA() {
        System.out.println("ProductA");
    }
}
class ProductB implements Product {
    public ProductB() {
        System.out.println("ProductB");
    }
}
class GiftA implements Gift {
    public GiftA(){
        System.out.println("GiftA");
    }
}
class GiftB implements Gift {
    public GiftB(){
        System.out.println("GiftB");
    }
}

interface Factory {
    public Product createProduct();
    public Gift createGift();

}
class FactoryA implements Factory {
    @Override
    public Product createProduct(){
        return new ProductA();
    }
    @Override
    public Gift createGift(){
        return new GiftA();
    }
}

class FactoryB implements Factory {
    @Override
    public Product createProduct(){
        return new ProductB();
    }
    @Override
    public Gift createGift(){
        return new GiftB();
    }

}

五.適配器模式

public class AdapterDemo {
    public static void main(String[] args) {
        SmallPort smallPort = new SmallPort() {//手機自帶小的接口
            public void useSmallPort() {
                System.out.println("使用的是手機小的接口");
            }
        };
        //需要一個大的接口才可以連上電腦,小口轉換為大口
        BigPort bigPort=new SmallToBig(smallPort);
        bigPort.useBigPort();
    }
}

interface BigPort {
    
    public void useBigPort();//使用的大口
}

interface SmallPort {
    public void useSmallPort();//使用小口
}

class SmallToBig implements BigPort{

    private SmallPort smallPort;//小口
    
    public SmallToBig(SmallPort smallPort){//獲得小口
        this.smallPort=smallPort;
    }
    @Override
    public void useBigPort() {
        this.smallPort.useSmallPort();    //使用小口
    }
            
}

六.策略模式

public class StrategyDemo {
    public static void main(String[] args) {
        Car smallCar = new SmallCar("路虎","黑色");
        Car bussCar = new BussCar("公交車","白色");
        Person p1 = new Person("小明", 20);
        p1.driver(smallCar);
        p1.driver(bussCar);
    }
}

interface CarFunction {
    void run();        //每輛車有不同的行駛方法
}

class Car implements CarFunction {
    protected String name;            //車名字
    protected String color;            //車顏色
    
    public Car(String name, String color) {
        this.name = name;
        this.color = color;
    }

    @Override
    public void run() {
        System.out.println(color +" " + name  +"在行駛。。。");
    }
    
}
class SmallCar extends Car {

    public SmallCar(String name, String color) {
        super(name, color);
    }
    @Override
    public void run() {
        System.out.println(color +" " + name  +"在高速的行駛。。。");
    }
    
}
class BussCar extends Car{

    public BussCar(String name, String color) {
        super(name, color);
    }
    @Override
    public void run() {
        System.out.println(color +" " + name  +"在緩慢的行駛。。。");
    }
}
class Person {
    private String name;    
    private Integer age;    
    
    public void driver(Car car){
        System.out.print(name +"  "+ age+" 歲 "+" 開着");
        car.run();
    }

    public Person(String name,Integer age) {
        this.name=name;
        this.age=age;
    }

}

七.代理模式(靜態代理)

public class StaticProxyDemo {
    public static void main(String[] args) {
        ProxySubject subject = new ProxySubject(new RealSubject());
        subject.visit();
    }
}
interface Subject {
    void visit();
}
class RealSubject implements Subject {

    private String name = "byhieg";
    @Override
    public void visit() {
        System.out.println(name);
    }
}
class ProxySubject implements Subject{
    private Subject subject;
    public ProxySubject(Subject subject) {
        this.subject = subject;
    }

    @Override
    public void visit() {
        subject.visit();
    }
}

八.代理模式(動態代理)

public class DynamicProxyDemo {
    public static void main(String[] args) {
        //創建一個實例對象，這個對象是被代理的對象
        Person zhangsan = new Student("張三");
        //創建一個與代理對象相關聯的InvocationHandler
        InvocationHandler stuHandler = new StuInvocationHandler<Person>(zhangsan);
        //創建一個代理對象stuProxy來代理zhangsan，代理對象的每個執行方法都會替換執行Invocation中的invoke方法
        Person stuProxy = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class<?>[]{Person.class}, stuHandler);
       //代理執行上交班費的方法
        stuProxy.giveMoney();
    }
}
interface Person {
    //上交班費
    void giveMoney();
}
class Student implements Person {
    private String name;
    public Student(String name) {
        this.name = name;
    }
    
    @Override
    public void giveMoney() {
        try {
          //假設數錢花了一秒時間
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       System.out.println(name + "上交班費50元");
    }
}
class MonitorUtil {
    
    private static ThreadLocal<Long> tl = new ThreadLocal<>();
    
    public static void start() {
        tl.set(System.currentTimeMillis());
    }
    
    //結束時打印耗時
    public static void finish(String methodName) {
        long finishTime = System.currentTimeMillis();
        System.out.println(methodName + "方法耗時" + (finishTime - tl.get()) + "ms");
    }
}
class StuInvocationHandler<T> implements InvocationHandler {
       //invocationHandler持有的被代理對象
        T target;
        
        public StuInvocationHandler(T target) {
           this.target = target;
        }
        
        /**
         * proxy:代表動態代理對象
         * method：代表正在執行的方法
         * args：代表調用目標方法時傳入的實參
         */
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("代理執行" +method.getName() + "方法");
            //代理過程中插入監測方法,計算該方法耗時
            MonitorUtil.start();
            Object result = method.invoke(target, args);
            MonitorUtil.finish(method.getName());
            return result;
        }
  }