首页人工智能 › 工厂模式,首先有个汽车类的接口叫做Car

工厂模式,首先有个汽车类的接口叫做Car

1、概述

概述

工厂方式属于创设型情势,必要转移的对象叫产品,生产指标的地方叫工厂。实现了调用者和创小编的分离。

工厂格局的长处

1. 
 特出的封装性,代码结构清晰。八个指标成立是有约束的,入三个调用者要求三个有血有肉的出品对象,只要明白类名就能够,不用知道创设对象的艰巨历程,裁减模块之间的耦合。

2. 
 工厂方式的扩展也不行的绝妙,只要扩张适用的厂子类如故扩大三个工厂,就可以达成扩展。

3. 
 工厂格局使标准的解耦框架。高层模块只要求知道产品的抽象类,其余达成类都没有须要关心。

厂子情势的简练分类

1.简短工厂形式

2.厂子方法方式

3.抽象工程方式

简言之工程情势完结

/** * 创立小车接口 */

public interface Car { public void run(); }

/** * 制造宝马车类完结Car接口重写run方法 */

public class BMW implements Car {

    @Override public void run() { System.out.println("BWM run"); }

}

/** * 定义小车工厂类,成效生产小车   创建者  */

public class simpleFactory {

    public static Car factory(String name){     

        Car car = null;

        if("BWM".equals(name)){     

                return car = new BMW();

            }else if("BYD".equals(name)){

                return car = new BYD();

            }else{

                return null;

              }

        }

}

/** * 测验轻巧工厂类    调用者*/

public class SimpleFactoryDemo {

        public static void main(String[] args) {

                Car bwm = simpleFactory.factory("BWM");

                Car byd = simpleFactory.factory("BYD");

                bwm.run();

                byd.run();

            }

}

简易工厂情势用来生产一样等级结构中的任性产品。对于新扩充的事物必要修改已某个代码,违反了面型对象设计的开闭原则。

工厂方法格局

/** * 定义小车接口 */

public interface Car { public void run(); }

/** * 华骐类完毕Car接口达成相应的点子 */

public class BYD implements Car{

    @Override public void run() {

           System.out.println("BYD is run");

        }

}

/** * 创立宝马类达成Car接口实现相应的秘技 */

public class BWM implements Car{

    @Override public void run() {

            System.out.println("BWM run");

    }

}

/** * CarFactory接口用于生产小车 */

public interface CarFactory { Car createCar(); }

/** * 创建BYDFactory类实现CarFactory创建BYD */

public class BYDFactory implements CarFactory{

        @Override public Car createCar() {

                      return new BWM();

            }

}

/** * 生产BWMFactory类用于生产BWM小车 */

public class BWMFactory implements CarFactory{

        @Override public Car createCar() {

                return new BWM();

        }

}

/** * 调用者 */

public class Demo {

    public static void main(String[] args) {

            Car byd = new BYDFactory().createCar();

            Car bwm = new BWMFactory().createCar();

            byd.run();

            bwm.run();

         }

}

厂子方法方式避免了简易工厂的瑕疵OCP原则。

厂子方法形式和轻巧工厂的另三个分别正是,简单工厂形式唯有三个厂子类,而工厂方法情势是有一组达成平等接口的工厂类。

架空工厂情势

/** * 发动机 */

public interface Engine {

    void run();

    void statr();

}

class HightEngine implements Engine{

        @Override public void run() { System.out.println("跑得快"); }

        @Override public void statr() { System.out.println("启动快");
}

}

class LowEngine implements Engine{

        @Override public void run() { System.out.println("跑得慢"); }

        @Override public void statr() { System.out.println("启动慢");
}

}

/** * 座椅 */

public interface Set { void massage(); }

class HightSet implements Set{

        @Override public void massage() {
System.out.println("真皮座椅"); }

}

class LowSet implements Set{

        @Override public void massage() {
System.out.println("普通座椅"); }

}

/** * 轮胎 */

public interface Tire { void tire(); }

class HightTire implements Tire{

        @Override public void tire() { System.out.println("橡胶轮胎");
}

}

class LowTire implements Tire{

        @Override public void tire() {
System.out.println("塑料轮胎");}

}

/** * 创立部件 */

public interface CarFactory {

        Engine createEngine();

        Set createSet();

        Tire createTire();

}

/** * 高级小车工厂 */

public class HightCarFactory implements CarFactory{

        @Override public Engine createEngine() { return new
HightEngine(); }

        @Override public Set createSet() { return new HightSet(); }

        @Override public Tire createTire() { return new HightTire(); }

}

/** * 调用者 */

public class Client {

        public static void main(String[] args) {

            CarFactory carFactory =new HightCarFactory();

            Engine engine = carFactory.createEngine();

            engine.run();

            engine.statr();

            }

}

用来生产差别品族的全部成品,对于新增加的出品不只怕。

厂子方式的接纳场景

        JDBC中Connection对象的获得

        SpringIOC容器创设和保管bean

        反射中Class对象的newInstance()

总结:

        不难工厂方式即便违背了开闭原则,然而设计简约。工厂方法形式在不修改类的前提下,通过新的厂子类来达成扩张,符合开闭原则的正式。抽象方法格局,无法扩大产品只是足以追加产品族。

工厂情势

一、轻松工厂方式

那二日忽然想学学java源代码,但是总的来看一篇小说说看java源代码要先看设计格局,那样更便于驾驭源代码的组织,所以就图谋学学java设计格局,首先当然是看java成立情势的厂子格局了,刚初叶一贯看抽象工厂方式是怎么意思,百度宏观的莫过于是看不懂,后来又在英特网看了看其余的文章,留神揣摩后,还算是掌握了,未来跟大家享用下。

、定义

  实现创制者和调用者的告辞

归纳工厂的定义:提供七个创造对象实例的意义,而无须关怀其切实完结。被成立实例的品种能够是接口、抽象类,也得以是具体的类

      首先说说简练工厂形式,作者用实际中的小车工厂举个例子子,首先有个小车类的接口叫做Car,里面有个发车的不二等秘书诀叫做drive(),然后有个吉利车的类叫做Jili,达成了car的接口,还或许有个奇瑞车的类叫做Qirui,也落到实处了Car的接口(因为都以车嘛,当然能开了)。

概念贰个用以创造对象的接口,让子类决定实例化哪一个类。工厂形式使贰个类的实例化延迟到其子类。

简单的讲工厂,工厂方法,抽象工厂方式。

完成小车接口

       interface Car{

、目的

面向对象的计划条件:OCP:软件的规划应该对扩大开放,对修改关闭

public interface Car {

            public void drive(){

厂子格局的要紧指标:解耦

          DIP:应该针对接口编制程序,不该针对落到实处编制程序。

String getName();

                     System.out.println("我开车");

、类图

简易工厂:

}

            }

图片 1

例:

奔驰类

       class Jili implements Car{

2、简单样例

//一流接口

public class Benz implements Car {

            public Jili(){

、工厂方式

public interface Car extends Runnable{

@Override

                     System.out.println("生产一台吉利车");

AbstractCarFactory,工厂抽象类/**

}

public String getName() {

            }

* 抽象工厂类

//子接口

return "Benz";

            pulic void drive(){

*/

public class Audi implements Car{
  @Override
  public void run() {
    System.out.println;
  }
}

}

                     System.out.println("笔者开吉利车");

public abstract class AbstractCarFactory {

//子接口

}

            }

public abstract <T extends Car> T creatCar(Class<T> car);

public class Byd implements Car{
  @Override
  public void run() {
    System.out.println;
  }
}

宝马类

      }

}

因此给不相同的工厂传分化种类的参数,再次回到不相同的目的

public class BMW implements Car {

      class Qirui implements Car{

CarFactory 工厂实现类,承继工厂抽象类/**

public class CarFactory {

@Override

            public  Qirui(){

* 工厂完结类

  public Car getInstance(String type) {
    if("奥迪".equals {
      return new Audi();
    }else if("比亚迪".equals {
      return new Byd();
    }else {
      return null;
    }

public String getName() {

                     System.out.println("生产一台Chery车");

*/

  }

return "BMW";

            }

public class CarFactory extends AbstractCarFactory {

}

}

            pulic void drive(){

@Override

简短工厂也叫做静态工厂,因为只能生成已知的指标;同一时候,轻易工厂违反了开闭原则。

}

                     System.out.println("作者开Chery车");

public <T extends Car> T creatCar(Class<T> car) {

工厂方法情势

不难工厂,不只能生产BMW又能生育Benz

            }

Car c = null;

扬言三个车子工厂的接口

public class SimpleFactory {

      }

try {

public interface CarFactory {

public Car getCar(String name){

那未来假如本身要用Jili那些类,最中央的点子就是

c = Class.forName(car.getName.newInstance();

  public Car getInstance();

if (name.equals{

      Jili jili=new Jili();

} catch (Exception e) {

}

return new BMW();

若是用Qirui这些类,最宗旨的章程也是

e.printStackTrace();

让产生不一样的车辆的厂子实现抽象车辆工厂

}else if (name.equals{

      Qirui qirui=new Qirui();

}

生儿育女奥迪(Audi)的厂子

return new Benz();

啊,那未来借使有个江铃车就得new
Biyadi();然后同样有个drive()的格局,这样各样都得new个汽车对象,不过实际上吉利,Chery和荣威他们都属于小车,同样都有drive()方法,那是或不是咱们能成立贰个生育小车的厂子,然后您想要什么小车只要告诉工厂就能够,工厂就帮你生产了,那样您不用管生儿育女的内部原因职业(也便是new对象的经过),那样会越来越好呢,到此,轻巧工厂方式就出去了,轻便工厂形式正是创立具有一样特征的类的实例,然后把成立小车的格局静态化,这样就可以直接用工厂生产了,代码如下

转载本站文章请注明出处:金莎娱乐官网最全网站 http://www.djliuxue.com/?p=419

上一篇:

下一篇:

相关文章