标签：简单工厂模式 参数 end span void switch static nts bst
注：第二篇章讲的是设计模式，主要是LZ对《大话设计模式》这书的记录，以及一些简单例子。
首先工厂模式分为三种：简单工厂模式、工厂方法模式、抽象工厂模式。下面分别介绍这三种模式。
一：简单工厂模式
简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个种类（这些种类继承自一个父类或接口）的实例。如上面AnimalFactory是工厂类，Animal类是父类，Bird、Dog都是种类，因此如果要在加一个Pig类，只需要继承父类，并在工 类种加入类型判断即可。代码如下：
//Animal.java
public class Animal {
private String type;
public Animal(){
}
public void speak(){
System.out.println( "动物叫" );
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
//Dog.java：里面除了重写了speak方法外，还有自己的属性和方法
public class Dog extends Animal{
private String color;
public Dog(String color){
this.color = color;
}
public void speak(){
System.out.println("狗叫声:"+super.getType() );
}
public void dogMethod() {
System.out.println("狗的颜色："+color);
}
}
//Bird.java：里面除了重写了speak方法外，还有自己的属性和方法
public class Bird extends Animal{
private Boolean can_fly;
public Bird(Boolean can_fly){
this.can_fly = can_fly;
}
public void speak(){
System.out.println( "鸟叫声：" + super.getType() );
}
public void birdMethod(){
System.out.println("鸟能飞吗："+can_fly);
}
}
//AnimalFactory.java：根据参数type来创建对应的实例
public class AnimalFactory {
public static Animal createAnimal(String type){
Animal animal = null;
switch (type) {
case "dog" : animal = new Dog("黄色"); break;
case "bird" : animal = new Bird(true); break;
default:animal = new Animal(); break;
}
return animal;
}
}
//测试类：
public class Test {
public static void main(String[] args) {
Animal animal;
animal = AnimalFactory.createAnimal("dog");
animal.setType("汪汪");
animal.speak();
animal = AnimalFactory.createAnimal("bird");
animal.setType("吱吱");
animal.speak();
}
}
运行结果：
狗叫声:汪汪
鸟叫声：吱吱
二：工厂方法模式
工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪个类。在简单工厂模式中，新增类型需要改动工厂类，而工厂方法模式使之前的体系无需修改，完全符合了开发-封闭原则。但工厂方法模式在客户端中还是需要进行逻辑判断，决定需要实例化哪一个工厂来实现实现类。例子代码如下:
public interface Animal {
abstract void eat();
abstract void sleep();
}
//狗
public class Dog implements Animal{
@Override
public void eat(){
System.out.println("狗吃东西");
}
@Override
public void sleep(){
System.out.println("狗睡觉");
}
}
//鸟
public class Bird implements Animal{
@Override
public void eat(){
System.out.println("鸟吃东西");
}
@Override
public void sleep(){
System.out.println("鸟睡觉");
}
}
public interface IAnimalFactory {
Animal createAnimal();
}
//创建狗的接口类
public class DogFactory implements IAnimalFactory{
@Override
public Animal createAnimal() {
return new Dog();
}
}
//创建鸟的接口类
public class BirdFactory implements IAnimalFactory{
@Override
public Animal createAnimal() {
return new Bird();
}
}
//测试类
public class Test {
public static void main(String[] args) {
//dog
IAnimalFactory iAnimalFactory = new DogFactory();
Animal animal = iAnimalFactory.createAnimal();
animal.eat();
animal.sleep();
//bird
iAnimalFactory = new BirdFactory();
animal = iAnimalFactory.createAnimal();
animal.eat();
animal.sleep();
}
}
运行结果：
狗吃东西
狗睡觉
鸟吃东西
鸟睡觉
三：抽象工厂模式
抽象工厂模式：多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。 一个抽象工厂类，可以派生出多个具体工厂类。 每个具体工厂类可以创建多个具体产品类的实例。
//抽象产品类1
public interface IProduct1 {
public void show();
}
//抽象产品类2
public interface IProduct2 {
public void show();
}
//具体产品类1
public class Product1 implements IProduct1 {
public void show() {
System.out.println("产品1");
}
}
//也是具体产品类1
public class Product1_1 implements IProduct1 {
public void show() {
System.out.println("也是产品1");
}
}
//具体产品类2
public class Product2 implements IProduct2 {
public void show() {
System.out.println("产品2");
}
}
//抽象工厂类
public interface IFactory {
public IProduct1 createProduct1();
public IProduct2 createProduct2();
}
//具体工厂类One
public class OneFactory implements IFactory{
public IProduct1 createProduct1() {
return new Product1();
}
public IProduct2 createProduct2() {
return new Product2();
}
}
//具体工厂类Two
public class TwoFactory implements IFactory{
public IProduct1 createProduct1() {
return new Product1_1();
}
public IProduct2 createProduct2() {
return new Product2();
}
}
//测试类
public class Test {
public static void main(String[] args){
IFactory factory = new OneFactory();
factory.createProduct1().show();
factory.createProduct2().show();
factory = new TwoFactory();
factory.createProduct1().show();
factory.createProduct2().show();
}
}
运行结果：
产品1
产品2
也是产品1
产品2
四：总结：
简单工厂模式：用来生产同一等级结构中的任意产品。
工厂方法模式 ：用来生产同一等级结构中的固定产品。
抽象工厂模式 ：用来生产不同产品族的全部产品。
标签：简单工厂模式 参数 end span void switch static nts bst
原文地址：http://www.cnblogs.com/Tony-Anne/p/6411764.html
