java工厂模式

工厂模式可以将大量实现某个共同接口的类实例化，工厂模式可以动态的决定哪个类的实例化，不必事先知道需要实例化哪个类。

分为：简单工厂模式，又分为静态方法工厂模式

          工厂方法，抽象工厂

简单工厂模式：

Animal抽象类
public abstract class Animal {
        abstract void bark();
}
dog cat 类
public class Cat extends Animal {

	@Override
	void bark() {
		System.out.println("喵喵");
		
	}

}
public class dog extends Animal {

	@Override
	void bark() {
		System.out.println("汪汪");

	}
工厂类
public class factory {
	private static Animal a;
   public static Animal creatAnimal(String s) {
	   if(s.equals("cat")) {
		   a=new Cat();
	   }else if(s.equals("dog")) {
		   a=new dog();
	   }
	return a;
}
}
测试类

public class test {
public static void main(String[] args) {
	Animal creatAnimal = factory.creatAnimal("cat");
	creatAnimal.bark();
	Animal creatAnimal1 = factory.creatAnimal("dog");
	creatAnimal1.bark();
}
}

利用工厂造动物，要什么给什么，修改代码时直接在工厂里面改，新加动物时实现animal接口就行了。扩展性比较差

如果需要加入新的动物就要在代码上进行修改，违背了开闭原则，如果获取的动物的名字写错也不会造出来

工厂方法模式：

将工厂抽象，用不同的工厂去继承这个工厂，实现新的子类猫工厂狗工厂造特定对象。

工厂抽象类
public abstract class abfacory {
     abstract Animal creatAnimal();
}

猫工厂
public class catFactory extends abfacory {

	Animal creatAnimal() {
		// TODO Auto-generated method stub
		return new Cat();
	}

}
狗工厂
public class dogFactory extends abfacory {

	Animal creatAnimal() {
		// TODO Auto-generated method stub
		return new dog();
	}

}
测试
catFactory cat=new catFactory();
	Animal creatAnimal2 = cat.creatAnimal();
	creatAnimal2.bark();

实现了解耦合，但是实例太多了的话不好处理。

抽象工厂模式的优点：

（1）具有工厂方法模式解耦的优点。

（2）工厂模式针对的是一个产品等级结构，抽象工厂模式针对的是面向多个产品等级结构的。

最主要的是可以在类内部对产品族的关联关系进行定义和描述。

抽象工厂模式的缺点：

（1）产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。

（2）在具体工厂类的方法中，对于产品族里的产品，只能使用其中一个。这也比较容易理解，比如，一款车子不可以搭载两种空调。

现在如今，造动物时需要指定他们喜欢吃的东西，可以在工厂中指定这种

抽象工厂类
public abstract class abstactFacyory {
abstract Animal creatAnimal();
abstract eat creatEat();
}
抽象动物类一致
接口吃类
interface eat {
 
}
猫吃类，与狗吃类的实现
public class dogEat implements eat {

	public  eat() {
		System.out.println("狗吃骨头");

	}

}
public class catEat implements eat {

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

}
猫，狗工厂在造的时候将这种吃这个种类造进去
public class catFactory extends abstactFacyory {

	Animal creatAnimal() {
		// TODO Auto-generated method stub
		return new Cat();
	}

	@Override
	eat creatEat() {
		// TODO Auto-generated method stub
		return new catEat();
	}

}
public class dogFactory extends abstactFacyory {

	Animal creatAnimal() {
		// TODO Auto-generated method stub
		return new dog();
	}

	@Override
	eat creatEat() {
		// TODO Auto-generated method stub
		return new dogEat();
	}

}
test
public class test {
public static void main(String[] args) {
	catFactory c= new catFactory();
	Animal cat = c.creatAnimal();
	cat.bark();
	c.creatEat();
	
}
}

在造动物时给动物配上动物应有行为所以用接口，接口代表标准，新加的动物的吃法都与新动物组合，而不用修改其他代码
1) 工厂模式的意义

将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项 目的扩展和维护性。

2) 三种工厂模式 (简单工厂模式、工厂方法模式、抽象工厂模式)

3) 设计模式的依赖抽象原则  创建对象实例时，不要直接 new 类, 而是把这个 new 类的动作放在一个工厂的方法中，并返回。有的书上说， 变量不要直接持有具体类的引用。

不要让类继承具体类，而是继承抽象类或者是实现 interface(接口)

不要覆盖基类中已经实现的方法。

在具体应用中，因为工厂类都是抽象的，所以可以使用多态，在运行时再决定哪个子类去实现，如果要新出的子类的话，不用改客户端代码，直接新加一个子类，提高扩展性，减少耦合性。