java设计模式

1、单例模式

单例模式是指某个类只有一个实例存在。
饿汉式

public class Singleton {
    private static Singleton singleton=new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return singleton;
    }
}

懒汉式

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

volatile作用：禁止处理器重排序。
java内存模型（jmm）并不限制处理器重排序，singleton=new Singleton()并不是原子语句，在执行时需要经历三大步骤：
(1) 为对象分配内存
(2) 初始化实例对象
(3) 将对象的内存地址赋值给singleton
如果一个线程的执行顺序是(1)(3)(2)，当这个线程执行到(3)时，singleton就不为null了，这时另一个线程判断不为null就直接返回了，而此时并没有初始化，就会产生错误。

2、工厂模式、抽象工厂模式

工厂模式：自己不创建对象，将对象的创建权交给工厂。可以简单理解为平时我们用到一个对象，就会去new一个对象，而工厂模式相当于加了一个中间层，我们不再直接new对象，而是通过工厂去new对象，然后返回给我们。

import sun.security.provider.SHA;

/**
 * Created by Administrator on 2020/4/13.
 */
public class TestFactory {
    public static void main(String[] args) {
        ShapeFactory shapeFactory=new ShapeFactory();
        Shape rectangle=shapeFactory.getShape("RECTANGLE");
        rectangle.draw();
        Shape square=shapeFactory.getShape("SQUARE");
        square.draw();
    }
}

interface  Shape{
    public void draw();
}

class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Rectangle draw method");
    }
}

class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Square draw method");
    }
}

class ShapeFactory{
    public Shape getShape(String shapeType){
        if(shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        }else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }else{
            return null;
        }
    }
}

抽象工厂模式
所谓抽象工厂模式，就是相当于有一个超级工厂来创建工厂，然后再由工厂创建对象。

import java.util.Comparator;

/**
 * Created by Administrator on 2020/4/13.
 */
public class testAbstractFactory {
    public static void main(String[] args) {
        AbstractFactory computerFactory=FactoryProducer.getFactory("COMPUTER");
        AbstractFactory phoneFactory=FactoryProducer.getFactory("PHONE");
        Computer lianXiang=computerFactory.getComputer("LIANXIANG");
        lianXiang.print();
        Computer dell=computerFactory.getComputer("DELL");
        dell.print();
        Phone huawei=phoneFactory.getPhone("HUAWEI");
        huawei.print();
        Phone xiaomi=phoneFactory.getPhone("XIAOMI");
        xiaomi.print();
    }
}

interface Computer{
    public void print();
}

class LianXiang implements Computer{
    public void print(){
        System.out.println("LianXiang print method");
    }
}

class Dell implements Computer{
    public void print(){
        System.out.println("Dell print method");
    }
}

interface Phone{
    public void print();
}

class Huawei implements Phone{
    public void print(){
        System.out.println("Huawei print method");
    }
}

class Xiaomi implements Phone{
    public void print(){
        System.out.println("Xiaomi print method");
    }
}

abstract class AbstractFactory{
    abstract Computer getComputer(String computerType);
    abstract Phone getPhone(String phoneType);
}

class FactoryProducer{
    public static AbstractFactory getFactory(String type){
        if(type.equalsIgnoreCase("COMPUTER")){
            return new ComputerFactory();
        }else if(type.equalsIgnoreCase("PHONE")){
            return new PhoneFactory();
        }else{
            return null;
        }
    }
}

class ComputerFactory extends AbstractFactory{
    public Computer getComputer(String computerType){
        if(computerType.equalsIgnoreCase("LIANXIANG")){
            return new LianXiang();
        }else if(computerType.equalsIgnoreCase("DELL")){
            return new Dell();
        }else{
            return null;
        }
    }

    public Phone getPhone(String phoneType){
        return null;
    }
}

class PhoneFactory extends AbstractFactory{

    @Override
    Computer getComputer(String computerType) {
        return null;
    }

    @Override
    Phone getPhone(String phoneType) {
        if(phoneType.equalsIgnoreCase("HUAWEI")){
            return new Huawei();
        }else if(phoneType.equalsIgnoreCase("XIAOMI")){
            return new Xiaomi();
        }else{
            return null;
        }
    }
}

3、代理模式

代理模式：即提供了对目标对象的另外访问方式，即通过代理对象访问目标对象。代理对象是对目标对象的扩展，并会调用目标对象。

• 静态代理
  目标对象和代理对象需要实现相同的接口，通过调用相同的方法来调用目标对象的方法。
  优点：可以在不改变目标类的前提下，对目标类进行功能扩展。
  缺点：代理类和目标类要实现同样的接口，对于不同的目标类我们需要创建不同的代理类，另外当接口中增加方法时，目标类和代理类都需要维护，比较麻烦。

/**
 * Created by Administrator on 2020/4/13.
 */
public class testStaticProxy {
    public static void main(String[] args) {
        ConsolePrinter consolePrinter=new ConsolePrinter();
        StaticProxy staticProxy=new StaticProxy(consolePrinter);
        staticProxy.print();
    }
}

interface Printer{
    void print();
}

class ConsolePrinter implements Printer{

    @Override
    public void print() {
        System.out.println("ConsolePrinter print method");
    }
}

class StaticProxy implements Printer{
    private Printer target;
    StaticProxy(Printer target){
        this.target=target;
    }

    @Override
    public void print() {
        System.out.println("StaticProxy print method start");
        target.print();
        System.out.println("StaticProxy print method end");
    }
}

• 动态代理
  也称为JDK代理或者接口代理，代理类不需要实现接口，通过JDK的API，在内存中动态的生成代理对象。但是目标类一定要实现接口，否则无法实现JDK代理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * Created by Administrator on 2020/4/13.
 */
public class testJdkProxy {
    public static void main(String[] args) {
        Printer consolePrinter=new ConsolePrinter();
        ProxyFactory proxyFactory1=new ProxyFactory(consolePrinter);
        Printer proxy1=(Printer) proxyFactory1.getProxyFactory();
        proxy1.print();
    }

}

class ProxyFactory{
    private Object target;
    ProxyFactory(Object target){
        this.target=target;
    }

    public Object getProxyFactory(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("start");
                        Object ret=method.invoke(target,args);
                        System.out.println("end");
                        return ret;
                    }
                });
    }
}

• cglib代理
  JDK代理虽然不需要代理类实现目标类相同的接口，但是目标类必须要实现接口，有的类可能没有实现任何接口，是一个非常简单的类，这时候可以采用cglib代理。cglib代理也称为子类代理，它是在内存中构建一个子类对象从而实现对目标对象的代理。

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * Created by Administrator on 2020/4/13.
 */
public class testCglibProxy {
    public static void main(String[] args) {
        User user=new User();
        CglibProxyFactory cglibProxyFactory=new CglibProxyFactory(user);
        User userProxy=(User) cglibProxyFactory.getProxyInstance();
        userProxy.sayHello();
    }
}

class User{
    void sayHello(){
        System.out.println("User sayHello");
    }
}

class CglibProxyFactory implements MethodInterceptor{
    private Object target;
    CglibProxyFactory(Object target){
        this.target=target;
    }

    public Object getProxyInstance(){
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("start");
        Object ret=method.invoke(target,objects);
        System.out.println("end");
        return ret;
    }
}

4、装饰者模式

装饰者模式用于给对象动态的添加一些职责，而无需改变原来的类。装饰者与被装饰者拥有共同的超类，继承的目的是继承类型，而不是行为。

/**
 * Created by Administrator on 2020/4/13.
 */
public class testDecorator {
    public static void main(String[] args) {
        Drink coffee=new Coffee();
        System.out.println(coffee.getIngredients());
        coffee=new WithMilk(coffee);
        System.out.println(coffee.getIngredients());
        coffee=new WithSugar(coffee);
        System.out.println(coffee.getIngredients());
    }
}

interface Drink{
    double getCost();
    String getIngredients();
}

class Coffee implements Drink{

    public double getCost() {
        return 1;
    }

    public String getIngredients() {
        return "coffee";
    }
}

abstract class DrinkDecorator implements Drink{
    private Drink drink;
    DrinkDecorator(Drink drink){
        this.drink=drink;
    }

    public double getCost() {
        return drink.getCost();
    }

    public String getIngredients() {
        return drink.getIngredients();
    }
}

class WithMilk extends DrinkDecorator {

    WithMilk(Drink drink) {
        super(drink);
    }

    @Override
    public double getCost() {
        double additionalCost=0.5;
        return super.getCost()+additionalCost;
    }

    @Override
    public String getIngredients() {
        String ingredients="milk";
        return super.getIngredients()+","+ingredients;
    }
}

class WithSugar extends DrinkDecorator{

    WithSugar(Drink drink) {
        super(drink);
    }

    @Override
    public double getCost() {
        double additionalCost=0.3;
        return super.getCost()+additionalCost;
    }

    @Override
    public String getIngredients() {
        String ingredients="sugar";
        return super.getIngredients()+","+ingredients;
    }
}