java 单例 工厂模式_Java ------ 工厂模式、单例模式

工厂模式

简单工厂模式：

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)语句，也就是上面看到的代码