Java学习之“浮”谈设计模式

开头首先推荐一下，也是我的老师老杨在授课时给我们强烈推荐的一本书，《Java与模式》，作者叫闫宏，此书中洋洋洒洒几十万字讨论了Java著名的“剑23”——23种设计模式，书很长，1000多页，大家有兴趣可以慢慢看看。今天结合学习到的案例，来谈谈一谈设计模式中最简单的单例模式和简单工厂模式的皮毛，这也是为什么我把标题定位“浮谈”一下设计模式。在这本1000多页皇皇巨著面前，我连浅谈的资格恐怕都不够，所以我的浮谈仅供拍砖。

什么是模式：
人们多年生产经营活动中会遇到各种问题，然后会想办法解决各种问题。当反复的遇到同样的问题，逐渐的使用一种或几种方式去解决这种问题，这种遇到问题解决问题的方式就是：模式。它是由之前的经验总结而来的。

Java与模式：
当我们开发Java程序时，也会去遇到各种问，也会去解决各种问题。当一种问题经常的出现，反复的使用一种方式去解决，就形成了一种模式。它使用Java语言的特征：构造方法、继承、多态、接口、抽象类等构建出种种解决问题的模式。

Java中的模式分为三类：
1.创建型模式：类如何创建对象。
2.行为型模式：类的对象之间如何配合，分工，做事情。
3.结构型模式：类之间怎样搭建结构。

简单工厂模式：需要一个工厂，工厂生产产品。 用户如果需要使用产品， 不用自己造，通过工厂获取。
工厂类 某些特定对象 程序中如果需要某个对象不用自己创建，通过工厂对象获得。
好处：前段使用者不需要自己创建对象，由工厂去统一创建，前端只需要调用工厂的方法获取对象就可以。
弊端：当增加新的动物时，要修改工厂类。

public class Demo {
	public static void main(String[] args) {
		//这种方式，需要什么对象，就自己实例化这个类的对象。
		/*Dog dog = new Dog();
		Cat cat = new Cat();
		
		dog.eat();
		cat.eat(); */
		
		//使用简单工厂--方式一，获取
		Dog dog = AnimalFactory.getDog();
		Cat cat = AnimalFactory.getCat();
		//简单工厂--方式二,获取
		Object obj = AnimalFactory.getAnimal("狗");//返回Dog
		Object obj2 = AnimalFactory.getAnimal("猫");//返回Cat
		//向下转型
		if(obj instanceof Dog){
			Dog dog2 = (Dog)obj;
			dog2.eat();
		}
		if(obj2 instanceof Cat){
			Cat cat2 = (Cat)obj2;
			cat2.eat();
		}	
	}
}

简单工厂模式：

动物工厂类：
方式一：为每一种对象分别提供方法
提供获取狗对象的方法
提供获取猫对象的方法
方式二：可以提供一个方法，提供一个标记，通过标记标示需要哪个对象，然后我返回哪个对象；

public class AnimalFactory {
	//********方式一*************//
	public static Dog getDog(){
		return new Dog();
	}
	public static Cat getCat(){
		return new Cat();
	}
	//********方式二*************//
	public static Object getAnimal(String type){
		if(type.equals("狗")){
			return new Dog();
		}
		if(type.equals("猫")){
			return new Cat();
		}
		return null;
	}
}

public class Dog {
	public void eat(){
		System.out.println("狗吃肉");
	}
}

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

工厂方法模式：

模式是基于简单工厂模式的，即实现了前端不需要实例化对象，由工厂提供，也实现了当新增一个新动物时，无需修改工厂类。
如果需要增加新的动物，增加一个新的动物类，实现IAnimal接口，然后再增加一个工厂类，实现IAnimalFactory接口此在主类中就可以使用了。任何工厂类的代码不用修改。

弊端：使用的类太多。

public class Demo {
	public static void main(String[] args) {
		IAnimalFactory fac1 = new DogFactory();//狗工厂
		IAnimalFactory fac2 = new CatFactory();//猫工厂
		
		IAnimal a = fac1.getAnimal();//Dog对象
		IAnimal b = fac2.getAnimal();//Cat对象
		
		a.eat();//
		b.eat();	
	}
}
public interface IAnimal {
	void eat();
}	
public interface IAnimalFactory {
	IAnimal getAnimal();
}

public class CatFactory implements IAnimalFactory {
	@Override
	public IAnimal getAnimal() {
		return new Cat();
	}
}

public class DogFactory implements IAnimalFactory {

	@Override
	public IAnimal getAnimal() {
		return new Dog();
	}
}
public class Dog implements IAnimal{
	public void eat(){
		System.out.println("狗吃肉");
	}
}
public class Cat implements IAnimal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
}

什么是单例模式？
单：一个 例：对象 单例：一个对象
单例模式：在整个应用程序运行期间，有些类，全局只需要一个对象。这个时候这个类
需要进行一些设计，否则，其它类可能会去实例化它。

单例模式之饿汉式：
思路：
1.首先不能让其他类任意的实例化；
2.由类本身去实例化；
3.提供一个对外的公有方法，返回这个对象的引用；

将Student类作为单例模式的对象。

public class Demo {
	public static void main(String[] args) {
		Student stu = Student.getInstance();
		stu.show();
		Student stu2 =Student.getInstance();
		stu2.show();
		Student stu3 =Student.getInstance();
		stu3.show();
		
		System.out.println(stu == stu2);
		System.out.println(stu2 == stu3);	
	}
}

1.类内部持有一个静态的本类对象的引用，作为成员属性；并初始化
2.提供公有的对外的方法返回此引用；

public class Student {
	private Student(){	
	}
	private static Student stu = new Student();//0x2233
	public static Student getInstance(){
		return stu;//每次调用都会返回：0x2233
	}
	public void show(){
		System.out.println("is show()");
	}
}

单例模式之懒汉式：

public class Demo {
	public static void main(String[] args) {
		Student stu1 = Student.getInstance();
		stu1.show();
		Student stu2 = Student.getInstance();
		stu2.show();
		System.out.println(stu1 == stu2);
		
	}
}

懒汉式：
1.私有成员变量声明时不初始化；
2.在公有方法内部判断成员是否为null, 是：再初始化；
3.在公有方法内部返回成员变量；

public class Student {
	private Student(){
		Runtime r;
	}
	private static Student stu = null;//初始化为null，这里与饿汉式不同
	
	public static Student getInstance(){
		if(stu == null){
			stu = new Student();
		}
		return stu;
	}
	public void show(){
		System.out.println("懒汉式-->show()");
	}
}

总结：

对于设计模式的学习，一开始我是拒绝的！

“一开始我是不懂”为什么要把很简单的东西搞得那么复杂。后来随着代码量的增加才开始明白我所看到的“复杂”恰恰就是设计模式的精髓所在，我所理解的“简单”就是一把钥匙开一把锁的模式，目的仅仅是着眼于解决现在的问题，而设计模式的“复杂”就在于它是构造一个“万能钥匙”，目的是提出一种对所有锁的开锁方案。
在真正理解设计模式之前我一直在编写“简单”的代码。这个“简单”不是功能的简单，二是设计的简单。简单的设计意味着缺少灵活性，代码很强硬的，只在这个项目里有用，拿到其它的项目中就是垃圾。要使代码可被反复使用，就需要使用“设计模式”对代码进行设计，这样才能达到“以柔克刚”之效。代码深处等着我们的是道家的阴阳哲学，繁即简，少亦多。