Java设计模式之简单工厂模式

设计一个简单工厂模式：

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

        优点：
                不需要在创建具体类的对象，而是把创建的工作交给了工厂类来创建；
        弊端：

                如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护；

        举例：简单工厂模式；
                提供一个动物抽象类：

package org.westos_01;

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

                狗实现类：

package org.westos_01;

public class Dog extends Animal{

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

                猫实现类：

package org.westos_01;

public class Cat extends Animal {

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

}

                动物工厂类：

package org.westos_01;

//动物工厂类
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;
	}
	
}

                测试类：

package org.westos_01;

//测试类

/**
 *    简单工厂模式
 */
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() ;//ctrl+1 /ctrl+2+L
		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("抱歉,当前工厂类不提供该动物类的创建");
		}
	}
}

工厂方法模式：

        提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口)，每一个具体的类都有对应的工厂类(实现工厂接口)；

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

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

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

        弊端：书写代码量太大；

        举例：工厂方法模式；
                定义一个动物抽象类：

package org.westos_02;

//抽象类
public abstract class Animal {

	public abstract void eat() ;
}

                猫类：

package org.westos_02;

public class Cat extends Animal {

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

                猫的工厂类：

package org.westos_02;

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

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

}

                狗类：

package org.westos_02;

public class Dog extends Animal {

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

}

                狗的工厂类：

package org.westos_02;

public class DogFactory implements Factory {

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

}

                工厂类：

package org.westos_02;

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

                测试类：

package org.westos_02;

//测试类
/**
 *    工厂方法模式
 */
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();
		
	}
}