Java中常见的设计模式---简单工厂模式、工厂方法模式和单例模式

在讲设计模式之前，我们首先来说一下面向对象思想的设计原则，在实际的开发中，我们要想更深入的了解面向对象思想，就必须熟悉前人总结过的面向对象的思想的设计原则：

1.单一职责原则：“高内聚，低耦合”，也就是说，每个类应该只有一个职责，对外只能提供一种功能，而引起类变化的原因应该只有一个。在设计模式中，所有的设计模式都遵循这一原则。

2.开闭原则：核心思想：一个对象对扩展开放，对修改关闭，也就是说对类的改动是通过增加代码进行的，而不是修改现有代码。

3.里氏替换原则：在任何父类出现的地方都可以用它的子类来替代。其实就是说：同一个继承体系中的对象应该有共同的行为特征。

4.依赖注入原则：要依赖于抽象，不要依赖于具体实现。其实就是说：在应用程序中，所有的类如果使用或依赖于其他的类，则应该依赖这些其他类的抽象类，而不是这些其他类的具体类。为了实现这一原则，就要求我们在编程的时候针对抽象类或者接口编程，而不是针对具体实现编程。

5.接口分离原则：不应该强迫程序依赖它们不需要使用的方法。其实就是说：一个接口不需要提供太多的行为，一个接口应该只提供一种对外的功能，不应该把所有的操作都封装到一个接口中。

6.迪米特原则：一个对象应当对其他对象尽可能少的了解，其实就是说：降低各个对象之间的耦合，提高系统的可维护性。在模块之间应该只通过接口编程，而不理会模块的内部工作原理，它可以使各个模块耦合度降到最低，促进软件的复用。

简单工厂模式

简单工厂模式也叫静态工厂方法模式 
设计一个工厂类:

工厂类提供一些静态方法,间接的去创建具体的对象

下来我们通过一个具体的例子来学习一下。

//提供了一个动物抽象类
public abstract  class Animal {
	
	//抽象功能
	public abstract void eat() ;
}

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼...");
	}

}

public class Dog extends Animal{

	@Override
	public void eat() {
		System.out.println("狗吃骨头...");
	}
	
}

//动物工厂类
public class AnimalFactory {

	//无参构造私有:外界不能创建该类对象
	private AnimalFactory() {
		
	}
	
	//提供一些静态功能,间接的创建具体对象
	/*public static Cat createCat() {
		return new Cat() ;
	}
	
	//狗类
	public static Dog createDog() {
		return new Dog() ;
	}*/
	
	//想办法用多态的形式解决:代码扩展性
	public static Animal createAnimal(String type) {
		if("cat".equals(type)) {
			return new Cat() ;
		}else if("dog".equals(type)) {
			return new Dog() ;
		}
		return null;
	}
	
}

public class AnimalDemo {

	public static void main(String[] args) {
		
		//养猫
		Cat c = new Cat() ;
		c.eat();
		//养狗
		Dog d = new Dog() ;
		d.eat(); 
		
		System.out.println("---------------------");
		
		//优化改进之后,调用工厂类里面的方法
		/*Cat cc = AnimalFactory.createCat() ;
		cc.eat();
		Dog dd = AnimalFactory.createDog() ;
		dd.eat();*/
		
		//改进:使用抽象类多态的形式改进工厂类
		Animal a = AnimalFactory.createAnimal("cat") ;
		a.eat();
		a = AnimalFactory.createAnimal("dog") ;
		a.eat();
		
		a = AnimalFactory.createAnimal("pig") ;
		//java.lang.NullPointerException
		//对象进行非空判断
		if(a!=null) {
			a.eat();
		}else {
			System.out.println("抱歉,当前工厂类不提供该动物类的创建");
		}
	}
}

从代码中也可以发现，简单工厂模式的优缺点。

优点：

        客户端不需要在负责对象的创建，从而明确了各个类的职责

缺点：

        这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护（如代码中pig对象的增加，则必须增加pig类并修改AnimalFactory工厂类）

工厂方法模式

工厂方法模式
提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体的类都有对应的工厂类(实现工厂接口)

具体对象的创建工作由继承抽象工厂的具体类实现

//抽象类
public abstract class Animal {

	public abstract void eat() ;
}

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼...");
		
	}
	
}

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃骨头...");
	}

}

public interface Factory {
	
	//该工厂接口的方法的返回值是抽象工厂类
	public abstract Animal creatAnimal() ;
}

//猫的工厂类--->创建一只猫
public class CatFactory implements Factory {

	@Override
	public Animal creatAnimal() {
		return  new Cat() ;
	}

}

public class DogFactory implements Factory {

	@Override
	public Animal creatAnimal() {
		return new Dog();
	}

}

public class AnimalDemo {
	
	public static void main(String[] args) {
		
		//创建Factory对象
		//接口多态的形式
		Factory f = new CatFactory() ;
		Animal a = f.creatAnimal() ;
		a.eat();
		System.out.println("-------------------");
		f = new DogFactory() ;
		a = f.creatAnimal() ;
		a.eat();
		
	}
}

优点:
客户端不需要在负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，

如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性。

弊端:
书写代码量大了!

单例模式

单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!
单例模式分类:

1)饿汉式 2)懒汉式(类似于多线程环境..)

两种分类在设计上几乎一样:
1)定义个类,将该类的无参构造方法私有化
2)在该类的成员位置创建该类对象 并且一定要私有化,防止外界更改这个对象
3)在该类中提供静态成员方法(返回值就是创建的那个对象),能被当前类直接调用,static修饰

饿汉式:

在加载那个类的时候,对象的创建工作就已经完成了!

//学生类
public class Student {

	//无参构造私有化,目的为了防止用户创建对象的时候,会产生多个对象!
	//为了不让直接通过构造方法创建该类对象
	private Student() {}
	
	//成员位置创建该类的实例
	//静态方法只能访问静态变量
	//加入私有修饰
	private static Student s = new Student() ; //静态的类变量
	
	//提供一个公共的成员方法
	public static Student getStudent() {
		return s ;
	}
}

public class StudentDemo {
	
	public static void main(String[] args) {
		
		//创建学生对象
		//在内存中有多个对象了
		/*Student s1  = new Student() ;
		Student s2  = new Student() ;
		System.out.println(s1==s2);*/	//false
		
		//修改当前那个类的成员
		//Student.s=null ;
		//直接更改了对象的值，所以学生类中应用private修饰
		
		Student s1 = Student.getStudent() ;
		Student s2 = Student.getStudent();
		System.out.println(s1==s2);//true

		System.out.println(s1);//org.westos_03.Student@70dea4e
		System.out.println(s2);//org.westos_03.Student@70dea4e
	}
}

懒汉式:
符合单例模式核心思想
1)自定义一个类,将无参构造私有化
2)在成员位置声明变量
3)提供公共静态功能,在里面判断的创建该类对象,返回该类对象

如果是开发中,那么就使用饿汉式(饿汉式它不会出现问题的单例模式)
如果是面试中,那么使用懒汉式(因为他是可能出现问题的一种单例模式)

面试题:
你使用过单例模式吗?简单介绍一种单例模式,请用代码设计
面试官想问的是:使用设计单例的懒汉式,能否想到使用同步机制解决线程的安全问题..

懒汉式(延迟加载 -->懒加载)
可能会出现问题
---> 多线程的问题
--->校验多线程安全问题的标准
1)是否是多线程环境
2)是否有共享数据

3)是否有多条语句对共享数据进行操作  (使用同步机制进行操作)

public class Teacher {
	
	//无参构造私有化
	private Teacher() {
		
	}
	
	//在成员位置声明变量
	//私有化,并且用static修饰来实现数据共享
	private static Teacher t = null ;
	
	//提供公共的静态功能
	/*public static Teacher getTeacher() {
		//如何创建该类对象,需要用的时候在创建
		//t1,t2,t3
		//在这里需要判断
		synchronized (t) {
			if(t==null) {
				t = new Teacher() ;
			}
			return t ;
		}
		
	}*/
	
	//静态的同步方法  (锁对象: 类名.class)
	public synchronized static Teacher getTeacher() {
		if(t==null) {
			t = new Teacher() ;
		}
		return t ;
	}
}

public class TeacherDemo {
	
	public static void main(String[] args) {
		
		//调用getTeacher()功能
		Teacher t1 = Teacher.getTeacher() ;
		Teacher t2 = Teacher.getTeacher() ;
		System.out.println(t1==t2);
		System.out.println(t1);//org.westos_04.Teacher@70dea4e
		System.out.println(t1);
		}
}

Runtime类
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
public static Runtime getRuntime()返回与当前 Java 应用程序相关的运行时对象

public Process exec(String command) throws IOException在单独的进程中执行指定的字符串命令。

public class RunTimeDemo {

	public static void main(String[] args) throws IOException {
		
		//创建Runtime类的实例
		Runtime r = Runtime.getRuntime() ;
		
		//开启某一个进程
		//r.exec("calc") ;//开启计算器进程
		//r.exec("notepad") ;//开启notepad进程
		r.exec("mspaint") ;//开启画图进程
	}
}