工厂模式

 

 

 

    一、简单的工厂模式：


        1、概念：简单的工厂模式属于类的创建型模式，又称为静态的工厂模式。


              通过专门的一个类来创建其他类的实例，被创建的实例通常都有相同的父类。


        2、三者关系：

    1、工厂类:它负责实现创建所有实例,厂类可以被外界直接调用，创建所需的产品对象。也就是创建相应的对象。


                     2、抽象类（接口）：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。


                                也就是实现它的方法。

     3、具体对象的类：也就是实现接口后，重写接口方法，完成不同的方法体；


    3、代码如下：


            1、工厂类：


                public class AnimalFactory {

public static Animal getDog(){
return new Dog();
}

public static Animal getCat(){
return new Cat();
}

public Animal getYingWu(){
return new YingWu();
}


}

2、接口：


    public interface Animal {
public void eat();
}

3、具体的对象类：
    
Dog类

    public class Dog implements Animal {
@Override
public void eat() {
System.out.println("啃骨头");
}
}

Cat类

    public class Cat implements Animal {

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


}

YingWu类

public class YingWu implements Animal {


@Override
public void eat() {
System.out.println("爱吃虫子");
}



}

4、在主方法中实现不同类的功能：

    public class MainClass {

public static void main(String[] args) {

Animal Dog = AnimalFactory.getDog();
Animal Cat = AnimalFactory.getCat();
//另外，如果工厂类中不是静态的方法，那么实例类的时候如下：
Animal YingWu = new AnimalFactory().getYingWu();

Dog.eat();
Cat.eat();
YingWu.eat();
}


}



4、简单化：

    1、工厂类：

    public static Animal getAnimal(String type) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
  Class animals = Class.forName(type);
  return (Animal)animals.newInstance();
}

2、主方法中：

    Animal cat = AnimalFactory.getAnimal("Cat");
            cat.eat();
通过传入的值进行创建相应的实例对象



           
  
  
二、工厂方法模式：


        1、概念：  工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建

 产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个

 抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系

 统在不修改具体工厂角色的情况下引进新的产品。




    2、关系：
                               1.抽象工厂（Creator）：工厂方法模式的核心，任何工厂类都必须实现这个接口。


2.具体工厂（ Concrete  Creator）：具体工厂类是抽象工厂的一个实现，负责实例化产品对象。


3.抽象（Product）：工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。


4.具体产品（Concrete Product）：工厂方法模式所创建的具体实例对象。




        3、代码：


                1、具体的对象类（同上）


                2、 接口（同上）


                3、 工厂类（接口）：


                    public interface AnimalFactory {
public Animal getAnimal();
}

4、对象工厂：
    
      创建cat的工厂
              public class CatFactory implements AnimalFactory {
        public Animal getAnimal() {
return new Cat();
}
}

创建dog的工厂
public class DogFactory implements AnimalFactory {
public Animal getAnimal() {
return new Dog();
}
}

5、主方法中:

        public static void main(String[] args) {
//创建一个cat工厂
CatFactory cats = new CatFactory();
 Animal cat = cats.getAnimal();
cat.eat();   
//创建一个dog工厂
DogFactory dogs = new DogFactory();
  Animal dog = dogs.getAnimal();
dog.eat();
}
                   
  
三、抽象工厂模式：


        1、概念：
        抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端


                        提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。


2、关系：
                                1.抽象工厂：抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。


2.具体工厂：具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。


3.抽象：抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。


4.具体产品：抽象模式所创建的具体实例对象。

总结：抽象工厂中方法对应产品结构，具体工厂对应产品族。


        3、代码：


                1、动物接口（同上）


                2、创建抽象对象类
  
                    抽象的猫类
                    public abstract class Cat implements Animal {
public abstract void eat();
}

                    抽象的狗类
                    public abstract class Dog implements Animal {
public abstract void eat();
}


                3、创建白色的猫类和黑色的猫类
                    public class WhiteCat extends Cat {
public void eat() {
System.out.println("白色的猫");
}

                    public class BrackCat extends Cat {
public void eat() {
 System.out.println("黑色的猫");
}
}


                4、创建白色的狗类和黑色的狗类
    public class WhiteDog extends Dog {
public void eat() {
         System.out.println("白色的狗");
}
}
   public class BrackDog extends Dog {
public void eat() {
 System.out.println("黑色的狗");
}
}

5、创建动物工厂，用来创建两个不同颜色的动物
     public interface AnimalFactory {
public Animal getWhiteAnimal();
public Animal getBrackAnimal();
}

6、创建白色和黑色猫的工厂
    public class WhiteAndBrackCat implements AnimalFactory {
        public Animal getWhiteAnimal() {
return new WhiteCat();

 

 

 

 

}

 

 

    public Animal getBrackAnimal() {
return new BrackCat();
}
}

7、创建白色和黑色狗的工厂
     public class WhiteAndBrackDog implements AnimalFactory {
public Animal getWhiteAnimal() {
return new WhiteDog();
}

     public Animal getBrackAnimal() {
return new BrackDog();
}
}

8、主方法：

     public static void main(String[] args) {

            //创建一个白黑狗工厂
    WhiteAndBrackDog wab1 = new WhiteAndBrackDog();
    Animal brackDog = wab1.getBrackAnimal();
    Animal whiteDog = wab1.getWhiteAnimal();
     brackDog.eat();
     whiteDog.eat();

    //创建一个白黑猫工厂
    WhiteAndBrackCat wab2 = new WhiteAndBrackCat();
    Animal brackCat = wab2.getBrackAnimal();
    Animal whiteCat = wab2.getWhiteAnimal();
      brackCat.eat();
      whiteCat.eat();
}