Java ------ 工厂模式、单例模式

时间  2019-11-15
标签 java 工厂 模式 栏目 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.测试ide

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.单例类必须给全部其余的对象提供这一实例

 

 

一、饿汉式单例

public class Singleton{  
        private static Singleton instance = new Singleton();  
        private Singleton(){}  
        public static Singleton newInstance(){  
            return instance;  
        }  
}

从代码中咱们看到，类的构造函数定义为private的，保证其余类不能实例化此类，而后提供了一个静态实例并返回给调用者。

饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行建立，实例在整个程序周期都存在。

它的好处是只在类加载的时候建立一次实例，不会存在多个线程建立多个实例的状况，避免了多线程同步的问题。它的缺点也很明显，即便这个单例没有用到也会被建立，并且在类加载以后就被建立，内存就被浪费了。

这种实现方式适合单例占用内存比较小，在初始化时就会被用到的状况。可是，若是单例占用的内存比较大，或单例只是在某个特定场景下才会用到，使用饿汉模式就不合适了，这时候就须要用到懒汉模式进行延迟加载。

 

二、懒汉式单例

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;  
    }  
}

 

三、双重校验锁

加锁的懒汉模式看起来即解决了线程并发问题，又实现了延迟加载，然而它存在着性能问题，依然不够完美。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)语句，也就是上面看到的代码

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程