工厂模式
简单工厂模式：
1.创建Car接口
public interface Car {
public void drive();
}
2.创建两个实体类，分别实现Car接口
public class Benz implements Car {
@Override
public void drive() {
System.out.println("Driving Benz");
}
}
public class Bmw implements Car {
@Override
public void drive() {
System.out.println("Driving Bmw");
}
}
3.创建Driver工厂，根据传过来的值创建不同的对象
public class DriverFactory {
public Car drivercar(String key){
if("Benz".equals(key)){
return new Benz();
}else if("Bwm".equals(key)){
return new Bmw();
}
return null;
}
}
4.测试
public class TestFactory {
@Test
public void test() {
DriverFactory dirver = new DriverFactory();
Car car1= dirver.drivercar("Bwm");
car1.drive();
Car car2 = dirver.drivercar("Benz");
car2.drive();
}
}
工厂方法模式：
包括：
1.抽象产品：产品对象同一的基类，或者是同一的接口。
2.具体的产品：各个不同的实例对象类
3.抽象工厂：所有的子类工厂类的基类，或是同一的接口
4.具体的工厂子类：负责每个不同的产品对象的实际创建
工厂方法的优缺点
工厂方法模式的优点：
（1）在工厂方法模式中，工厂方法用来创建客户所需要的产品，同时还向客户隐藏了哪种具体产品类将被实例化这一细节，用户只需要关心所需产品对应的工厂，无需关心创建细节，甚至无需知道具体产品类的类名。
（2）基于工厂角色和产品角色的多态性设计是工厂方法模式的关键。它能够使工厂可以自主确定创建何种产品对象，而如何创建这个对象的细节则完全封装在具体工厂内部。工厂方法模式之所以又被称为多态工厂模式，正是因为所有的具体工厂类都具有同一抽象父类。
（3）使用工厂方法模式的另一个优点是在系统中加入新产品时，无需修改抽象工厂和抽象产品提供的接口，无需修改客户端，也无需修改其他的具体工厂和具体产品，而只要添加一个具体工厂和具体产品就可以了，这样，系统的可扩展性也就变得非常好，完全符合“开闭原则”。
工厂方法模式的缺点如下：
（1）在添加新产品时，需要编写新的具体产品类，而且还要提供与之对应的具体工厂类，系统中类的个数将成对增加，在一定程度上增加了系统的复杂度，有更多的类需要编译和运行，会给系统带来一些额外的开销。
（2）由于考虑到系统的可扩展性，需要引入抽象层，在客户端代码中均使用抽象层进行定义，增加了系统的抽象性和理解难度，且在实现时可能需要用到DOM、反射等技术，增加了系统的实现难度。
工厂方法模式的适用环境
在以下情况下可以使用工厂方法模式：
（1）一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
（2）一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。
（3）将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无需关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。
步骤：
1.抽象的产品类
public interface TV {
public void play();
}
2.具体的产品类
public class HaierTV implements TV {
@Override
public void play() {
System.out.println("海尔电视播放中.....");
}
}
public class XimiTV implements TV {
@Override
public void play() {
System.out.println("小米电视播放中.....");
}
}
3.抽象的工厂类
public interface TVFactory {
public TV productTV();
}
4.具体的工厂类
public class HaierTVFactory implements TVFactory {
@Override
public TV productTV() {
System.out.println("海尔电视工厂生产海尔电视.....");
return new HaierTV();
}
}
public class XimiTVFactory implements TVFactory {
@Override
public TV productTV() {
System.out.println("小米电视工厂生产海尔电视.....");
return new XimiTV();
}
}
5.测试
public class TestFactory {
@Test
public void test(){
TVFactory tvf1 = new HaierTVFactory();
TV tv1 = tvf1.productTV();
tv1.play();
TVFactory tvf2 = new XimiTVFactory();
TV tv2 = tvf2.productTV();
tv2.play();
}
}
抽象工厂模式：
当每个抽象产品都有多于一个的具体子类的时候（乘车工具有两种、早餐有两种），工厂角色怎么知道实例化哪一个子类呢？比如每个抽象产品角色都有两个具体产品（人有穷人和富人）。抽象工厂模式提供两个具体工厂角色（穷人工厂和富人工厂），分别对应于这两个具体产品角色（穷人骑自行车和橙汁；富人坐公交喝牛奶），每一个具体工厂角色只负责某一个产品角色的实例化。每一个具体工厂类只负责创建抽象产品的某一个具体子类的实例。
1.抽象产品接口：定义产品的接口，公共的暴露方法。便于实际的产品类实现。
2.具体的产品类：包含实际产品的类的逻辑处理：
3.抽象工厂接口：定义产生系列对象的接口
4.具体的工厂实现：实现抽象的接口工厂，返回具体的产品类的实现。
步骤：
1.抽象的产品接口
public interface Car {
public void gotowork();
}
public interface BreakFast {
public void eat();
}
2.具体的产品类
1）Car
public class Bike implements Car {
@Override
public void gotowork() {
System.out.println("骑自行车去工作....");
}
}
public class Bus implements Car {
@Override
public void gotowork() {
System.out.println("坐公交去工作....");
}
}
2）BreakFast类
public class Milk implements BreakFast {
@Override
public void eat() {
System.out.println("早餐喝牛奶.....");
}
}
public class Orange implements BreakFast {
@Override
public void eat() {
System.out.println("早餐喝橙汁.....");
}
}
3.抽象的工厂类
public interface AbstractFactory {
public Car getcar();
public BreakFast getbreakfast();
}
4.具体的工厂类
public class LowPersonFactory implements AbstractFactory {
@Override
public Car getcar() {
return new Bike();
}
@Override
public BreakFast getbreakfast() {
return new Orange();
}
}
public class HighPersonFactory implements AbstractFactory {
@Override
public Car getcar() {
return new Bus();
}
@Override
public BreakFast getbreakfast() {
return new Milk();
}
}
5.测试
public class TestFactory {
@Test
public void test3(){
AbstractFactory lowfactory = new LowPersonFactory();
Car car = lowfactory.getcar();
BreakFast breakFast = lowfactory.getbreakfast();
System.out.println("早饭：");
breakFast.eat();
System.out.println("上班交通工具是：");
car.gotowork();
AbstractFactory highfactory = new HighPersonFactory();
Car car2 = highfactory.getcar();
BreakFast getbreakfast2 = highfactory.getbreakfast();
System.out.println("早饭：");
getbreakfast2.eat();
System.out.println("上班交通工具是：");
car2.gotowork();
}
}
单例模式：
主要介绍：懒汉式单例、饿汉式单例
特点：
1.单例类只能有一个实例
2.单例类必须自己创建自己的唯一实例
3.单例类必须给所有其他的对象提供这一实例
1、饿汉式单例
public class Singleton{
private static Singleton instance = new Singleton();
private Singleton(){}
public static Singleton newInstance(){
return instance;
}
}
从代码中我们看到，类的构造函数定义为private的，保证其他类不能实例化此类，然后提供了一个静态实例并返回给调用者。
饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期都存在。
它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。
这种实现方式适合单例占用内存比较小，在初始化时就会被用到的情况。但是，如果单例占用的内存比较大，或单例只是在某个特定场景下才会用到，使用饿汉模式就不合适了，这时候就需要用到懒汉模式进行延迟加载。
2、懒汉式单例
public class Singleton{
private static Singleton instance = null;
private Singleton(){}
public static Singleton newInstance(){
if(null == instance){
instance = new Singleton();
}
return instance;
}
}
懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。
如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择。
但是这里的懒汉模式并没有考虑线程安全问题，在多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，因此需要加锁解决线程同步问题，实现如下。
public class Singleton{
private static Singleton instance = null;
private Singleton(){}
public static synchronized Singleton newInstance(){
if(null == instance){
instance = new Singleton();
}
return instance;
}
}
3、双重校验锁
加锁的懒汉模式看起来即解决了线程并发问题，又实现了延迟加载，然而它存在着性能问题，依然不够完美。synchronized修饰的同步方法比一般方法要慢很多，如果多次调用getInstance()，累积的性能损耗就比较大了。因此就有了双重校验锁，先看下它的实现代码
public class Singleton {
private static Singleton instance = null;
private Singleton(){}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
可以看到上面在同步代码块外多了一层instance为空的判断。由于单例对象只需要创建一次，如果后面再次调用getInstance()只需要直接返回单例对象。因此，大部分情况下，调用getInstance()都不会执行到同步代码块，从而提高了程序性能。不过还需要考虑一种情况，假如两个线程A、B，A执行了if (instance == null)语句，它会认为单例对象没有创建，此时线程切到B也执行了同样的语句，B也认为单例对象没有创建，然后两个线程依次执行同步代码块，并分别创建了一个单例对象。为了解决这个问题，还需要在同步代码块中增加if (instance == null)语句，也就是上面看到的代码