附近做网站的公司,平湖专业网站制作,房地产公司如何做网站,网站内部优化建设文章目录 1、简单工厂模式2、工厂方法模式3、抽象工厂模式4、建造者模式5、原型设计模式 设计模式即总结出来的一些最佳实现。23种设计模式可分为三大类#xff1a;
创建型模式#xff1a;隐藏了创建对象的过程#xff0c;通过逻辑方法进行创建对象#xff0c;而不是直接n… 文章目录 1、简单工厂模式2、工厂方法模式3、抽象工厂模式4、建造者模式5、原型设计模式 设计模式即总结出来的一些最佳实现。23种设计模式可分为三大类
创建型模式隐藏了创建对象的过程通过逻辑方法进行创建对象而不是直接new结构型模式主要关注类和对象的组合关系。继承的概念被用来组合接口和定义组合对象获得新的功能方式行为型模式主要关注对象之间的通信 1、简单工厂模式
即由一个工厂决定创建哪一种产品类型的实例。
//抽象的课程类
public abstract class Course{//有一个制作课程的抽象方法public abstract void make();
}以上抽象类的两个实现类
public class JavaCourse extends Course{Overridepublic void make(){System.out.println(制作Java课程);}
}public class PythonCourse extends Course{Overridepublic void make(){System.out.println(制作Python课程);}
}创建工厂类
public class CourseFactory{//获取课程对象返回类型为抽象类Coursepublic Course getCourse(String courseKey){ //形参为工厂关键字if(java.equalsIgnoreCase(courseKey)){//创建JavaCourse对象然会返回return new JavaCourse();}else if(python.equalsIgnoreCase(courseKey)){//创建PythonCourse对象然会返回return new PythonCourse();}return null;}
}测试下效果
public class Test{public static void mian(String[] args){//创建工厂对象CourseFactory factory new CourseFactory();//获取javaCourse 对象Course javaCourse factory.getCourse(java);//完成制作Java课程功能javaCourse.make();//获取pythonCourse 对象Course pythonCourse factory.getCourse(python);//完成制作python课程功能pythonCourse.make();}
}2、工厂方法模式
定义一个接口或者一个抽象的工厂类让它的实现类也是一个工厂来决定创建哪一个实例对象。根据每个工厂不同的方法来产生不同的所需要的对象
先定义一个基类接口或者抽象的工厂类
public abstract class CourseFactory{public abstract Course getCourse();
}写实现类
public class JavaCourseFactory extends CourseFactory{Overridepublic Course getCourse(){return new JavaCourse();}
}public class PythonCourseFactory extends CourseFactory{Overridepublic Course getCourse(){return new PythonCourse();}
}测试
public class Test{public static void mian(STring[] args){JavaCourseFactory javaCourseFactory new JavaCourseFactory();//获取javaCourse 对象Course javaCourse javaCourseFactory.getCourse();//完成制作Java课程功能javaCourse.make();PythonCourseFactory pythonCourseFactory new PythonCourseFactory();//获取pythonCourse 对象Course pythonCourse factory.getCourse();//完成制作python课程功能pythonCourse.make();}
}3、抽象工厂模式
前面的工厂方法模式生产的都是相同系列的对象如Java课程、python课程。抽象工厂模式则是提供创建一系列相关或相互依赖对象的接口。比如生产汽车将汽车分为车架、车门、底盘等各个零部件进行生产。
public interface CarFactory{//获取车门对象public CarDoor getCarDoor();//获取车架对象public CarFrame getCarFrame();//获取底盘对象public CarBasePlate getCarBasePlate();//制作汽车public void make();
}//车门工厂
public abstract class CarDoorFactory{public abstract void make();
}//底盘工厂
public abstract class CarBasePlateFactory{public abstract void make();
}//车架工厂
public abstract class CarFrameFactory{public abstract void make();
}//车门
public class CarDoor extends CarDoorFactory{Overridepublic abstract void make(){System.out.println(制作车门);}
}//底盘
public class CarBasePlate extends CarBasePlateFactory{public abstract void make(){System.out.println(制作车底盘);}
}//车架工厂
public class CarFrame extends CarFrameFactory{public abstract void make(){System.out.println(制作车架);}
}public class Car implements CarFactory{private CarDoor carDoor null;private CarFrame carFrame null;private CarBasePlate carBasePlate null;Overridepublic CarDoor getCarDoor(){carDoor new CarDoor();return carDoor;}Overridepublic CarFrame getCarFrame(){carFrame new new CarFrame();return carFrame;}Overridepublic CarBasePlate getCarBasePlate(){carBasePlate new CarBasePlate();return carBasePlate;}Overridepublic void make(){carDoor.make();carFrame.make();carBasePlate.make();System.out.print(小汽车制作完成);}
}测试
public class Test{public static void mian(STring[] args){Car car new Car();car.getCarBasePlate();car.getCarFrame();car.getCarDoor();car.make();}
}运行
4、建造者模式
将复杂的对象的创建 和 属性赋值所分离建造的过程和细节我们不需要知道只需要通过构建者去进行操作
Data
public class Car{private String basePlate; //车底盘private String frame; //车架private String door; //车门
}public abstract class Builder{//车底盘public abstract void buildBasePlate(String basePlate);//车架public abstract void buildCarFrame(String carFrame);//车门public abstract void buildCarDoor(String carDoor);//制作车public abstract Car makeCar();
}写实现类
public class CarBuilder extends Builder{private Car car new Car();Overridpublic abstract void buildBasePlate(String basePlate){car.setBasePlate(basePlate);}Overridepublic abstract void buildCarFrame(String carFrame){car.setFrame(frame);}Overridepublic abstract void buildCarDoor(String carDoor){car.setDoor(carDoor);}Overridepublic abstract Car makeCar(){return this.car;}}创建一个工程师
public class Engineer{private CarBuilder carBuilder;//自动注入、构造方法、set方法都行能完成赋值就行这里写setpublic void setCarBuilder(CarBuilder carBuilder){this.carBuilder carBuilder;}public Car mekeCar(String basePlate, String frame, String door){carBuilder.buildBasePlate(basePlate);carBuilder.buildCarFrame(frame);carBuilder.buildCarDoor(door);return carBuilder.makeCar();}
}测试
public class Test{public static void mian(STring[] args){Engineer engineer new Engineer();CarBuilder carBuilder new CarBuilder();engineer.setCarBuilder(carBuilder);Car car engineer.makeCar(制作汽车底盘,制作汽车车架,制作汽车车门);System.out.println(car);}
}运行 5、原型设计模式
用于创建重复的对象能够保证创建对象的性能是创建对象的最佳方式
Data
public class Pig{private String name; //名字private String doSomething; //喜欢做的事}现在要表示佩奇一家正常创建流程如下
public class Test{public static void mian(STring[] args){Pig peki new Pig();peki.setName(佩琪);peki.setDoSomething(喜欢吃蛋糕);System.out.println(peki);Pig george new Pig();george.setName(乔治);george.setDoSomething(喜欢睡觉);System.out.println(george);Pig pigDad new Pig();pigDad.setName(猪爸爸);pigDad.setDoSomething(喜欢开车);System.out.println(pigDad);Pig pigMum new Pig();pigMum.setName(猪妈妈);pigMum.setDoSomething(喜欢做饭);System.out.println(pigMum);}
}运行 采用原型设计模式后实体类实现Cloneable接口
Data
public class Pig implements Cloneable{public Pig() {System.out.println(小猪被初始化了...);}private String name; //名字private String doSomething; //喜欢做的事Overrideprotected Object clone() throws CloneNotSupportedException{return super.clone();}
}再次创建佩奇一家
public class Test{public static void mian(STring[] args){Pig peki new Pig(); //先new一个peki.setName(佩琪);peki.setDoSomething(喜欢吃蛋糕);System.out.println(peki);Pig george (Pig) peki.clone(); //后面就克隆george.setName(乔治); //如果这里不赋值那克隆出来的属性和克隆样本一样george.setDoSomething(喜欢睡觉);System.out.println(george);Pig pigDad (Pig) peki.clone() ;pigDad.setName(猪爸爸);pigDad.setDoSomething(喜欢开车);System.out.println(pigDad);Pig pigMum (Pig) peki.clone() ;pigMum.setName(猪妈妈);pigMum.setDoSomething(喜欢做饭);System.out.println(pigMum);}
}运行 发现构造方法只被调用了一次且出来的也照样是不同的对象。因此当对象属性很多而又要创建大量这种对象时就可以用原型设计模式。该模式产生的对象虽然都是不同的对象单如果不重新赋值属性却是与克隆样本保持一致的即使是一个新的对象。
