工厂模式

1.1简单工厂

简单工厂模式的工厂类一般是使用静态方法，通过接收的参数的不同来返回不同的对象实例。

不修改代码的话，是无法扩展的

package com.company;
public class ComputerFactory {
    public static double result(double num1,String fu,double num2){
         double re=0;
         switch (fu){
             case "+":
                 re=num1+num2;
                 break;
             case "-":
                 re=num1-num2;
                 break;
             case "*":
                 re=num1*num2;
                 break;
             case "/":
                 re=num1/num2;
                 break;
                 default:
                     break;
         }
        return re;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("输入第一个数");
         double num1=scanner.nextDouble();
        System.out.println("输入字符");
        String fu=scanner.next();
        System.out.println("输入第二个数");
        double num2=scanner.nextDouble();
        double result = ComputerFactory.result(num1, fu, num2);
        System.out.println(result);
    }
}

输出：

输入第一个数
1
输入字符
*
输入第二个数
3
3.0

1.2.工厂方法

工厂方法是针对每一种产品提供一个工厂类。通过不同的工厂实例来创建不同的产品实例。

在同一等级结构中，支持增加任意产品。

工厂方法模式：工厂父类（接口）负责定义产品对象的公共接口，而子类工厂则负责创建具体的产品对象。

目的：是为了把产品的实例化操作延迟到子类工厂中完成，通过工厂子类来决定究竟应该实例化哪一个产品具体对象。

工厂方法模式包含四个部分：

1.抽象产品：产品对象同一的基类，或者是同一的接口。

2.具体的产品：各个不同的实例对象类

3.抽象工厂：所有的子类工厂类的基类，或是同一的接口

4. 具体的工厂子类：负责每个不同的产品对象的实际创建

public interface Tools {
    void gettowork();
}

public interface ToolFactory {
    Tools getTool();
}

public class Bus  implements Tools{
    @Override
    public void gettowork() {
        System.out.println("坐公交去上班");
    }
}

public class bike  implements Tools{
    @Override
    public void gettowork() {
        System.out.println("骑自行车去上班");
    }
}

public class BusFactory  implements  ToolFactory{
    @Override
    public Tools getTool() {
        return new Bus();
    }
}

public class BikeFactory  implements ToolFactory {
    @Override
    public Tools getTool() {
        return new bike();
    }
}

public class Text {
    public static void main(String[] args) {
        ToolFactory toolFactory=new BikeFactory();
        Tools bike = toolFactory.getTool();
        bike.gettowork();
        ToolFactory toolFactory1=new BusFactory();
        Tools bus = toolFactory1.getTool();
        bus.gettowork();
    }
}

输出：骑自行车去上班
         坐公交去上班

1.3.抽象工厂

抽象工厂是应对产品族概念的。比如说，每个汽车公司可能要同时生产轿车，货车，客车，那么每一个工厂都要有创建轿车，货车和客车的方法。

应对产品族概念而生，增加新的产品线很容易，但是无法增加新的产品。

抽象工厂模式：提供一个创建一系列的相关的或者依赖的对象的接口，无需指定它们的具体实现类，具体的实践分别在子类工厂中产生。隔离了具体类的生产实现，使得替换具体的工厂实现类很容易。包含有以下模块：

1.抽象产品接口：定义产品的接口，公共的暴露方法。便于实际的产品类实现。

2.具体的产品类:包含实际产品的类的逻辑处理：

3.抽象工厂接口：定义产生系列对象的接口

4.具体的工厂实现：实现抽象的接口工厂，返回具体的产品类的实现。

public interface Tools {
    void gotowork();
}
public interface BreakFast {
    void eat();
}
public interface AbstractFactroy {
    Tools getTools();
    BreakFast getBreakFast();
}
public class Milk  implements BreakFast {
    @Override
    public void eat() {
        System.out.println("早餐和牛奶");
    }
}
public class Baozi implements BreakFast {
    @Override
    public void eat() {
        System.out.println("早餐吃包子");
    }
}
public class Bus implements Tools {
    @Override
    public void gotowork() {
        System.out.println("坐公交上班");
    }
}
public class Bike implements Tools {
    @Override
    public void gotowork() {
        System.out.println("骑自行车上班");
    }
}

public class FirstClassFactroy  implements AbstractFactroy {
    @Override
    public Tools getTools() {
        return new Bike();
    }
    @Override
    public BreakFast getBreakFast() {
        return new Milk();
    }
}

public class SconedClassFactory  implements AbstractFactroy {
    @Override
    public Tools getTools() {
        return new Bus();
    }
    @Override
    public BreakFast getBreakFast() {
        return new Baozi();
    }
}

public class Text {
    public static void main(String[] args) {
            AbstractFactroy abstractFactroy=new FirstClassFactroy();
        Tools bike = abstractFactroy.getTools();
        bike.gotowork();
        BreakFast milk = abstractFactroy.getBreakFast();
        milk.eat();

        AbstractFactroy abstractFactroy1=new SconedClassFactory();
        Tools bus = abstractFactroy1.getTools();
        BreakFast baozi = abstractFactroy1.getBreakFast();
        bus.gotowork();
        baozi.eat();
    }
}

输出：骑自行车上班
早餐和牛奶
坐公交上班

早餐吃包子

2.单例模式

一个类中只有一个实例

第一种形式:懒汉式

public class SingletonClass {
	private SingletonClass() {
	}
	private static SingletonClass instance = null;
// synchronized  同步方法  保证该方法在某一个时间片只能被一个线程调用
	public static synchronized SingletonClass getInstance() {
		if (instance == null) {
			instance = new SingletonClass();
		}
		return instance;
	}
}

第二种形式:饿汉式

public class Singleton {
	private static final Singleton instance = new Singleton();
	private Singleton() {
	}
	// 这里提供了一个供外部访问本class的静态方法，可以直接访问
	public static Singleton getInstance() {
		return instance;
	}
}

3.代理模式

3.1静态代理

静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类.

3.2动态代理

动态代理有以下特点:
1.代理对象,不需要实现接口
2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)
3.动态代理也叫做:JDK代理,接口代理

JDK中生成代理对象的API
代理类所在包:java.lang.reflect.Proxy
JDK实现代理只需要使用newProxyInstance方法,但是该方法需要接收三个参数,完整的写法是:

static Object newProxyInstance(ClassLoader loader, Class<?>[]interfaces,InvocationHandler h )

注意该方法是在Proxy类中是静态方法,且接收的三个参数依次为:

       ClassLoader loader,:指定当前目标对象使用类加载器,获取加载器的方法是固定的

     Class<?>[]interfaces,:目标对象实现的接口的类型,使用泛型方式确认类型

   InvocationHandler h:事件处理,执行目标对象的方法时,会触发事件处理器的方法,会把当前执行目标对象的方法作为参数传入