一、设计模式概念
1、定义
Java包含23种设计模式，是一套对代码设计经验的总结，被人们反复利用，多人熟知的代码设计方式。
2、目的：
为了提高代码的可读性，可扩展性以及代码的复用性 ，为了解决在写代码过程中遇到的代码设计问题。
3、设计模式的六大原则
3.1 开闭原则： 对扩展开发，对修改关闭（尽可能对代码少修改）
3.2 里式替换原则： 它是面向对象基本原则之一，任何父类（基类）出现的地方，子类都可以出现，也就是子类可以替换父类的任何功能（体现了父类的可扩展性）
3.3 依赖倒转原则 ： 尽可能面向接口编程， 依赖接口而不依赖类
3.4 接口隔离原则： 一个类如果能实现多个接口，尽可能实现多个 ，为了降低依赖，降低耦合
3.5 最少知道原则： 一个实体尽可能少的与其他实体产生相互关联关系，将实体的功能独立
3.6 合成复用原则： 尽量使用合成，聚合的方式，而不使用继承
4、设计模式的分类：
1、创建型模式（5个）
工厂方法模式、 抽象工厂模式、单例模式， 建造者模式，原型模式
2、结构型模式（7个）
适配器模式，装饰模式，代理模式，外观模式，桥接模式，享元模式，组合模式
3、行为型模式（11个）
策略模式，模板方法模式，观察者模式，迭代子模式 ，责任链模式，命令模式，状态模式，访问者模式，中介模式，解释器模式，备忘录模式
5、单例模式
单例模式是创建对象的一种特殊方式，程序从始至终都只创建一个对象叫单例（单实例）
分为两类
1、懒汉式单例
public class Person { // 为了不让其他类直接访问该成员 懒汉式单例，在使用时创建对象 // 1 私有静态变量 private static Person person=null; //2、将构造器私有化 private Person (){ } //3 提供一个静态的方法，并可返回该类的对象 public static Person getInstance(){ if(person==null){ // 第一次访问 person = new Person(); } return person; } public void sayHello(){ System.out.println("sayHello方法"); }}2、饿汉式单例
public class Student { //1、 饿汉式单例模式， 在类加载时创建一个对象 private static Student student = new Student(); // 2 构造器私有化 private Student(){ } // 3 提供返回类对象的静态方法 public static Student getInstance(){ if(student !=null){ return student; } return null; }}6、工厂方法模式
创建对象的过程不再由当前类实例化，而是由工厂类完成 ，在工厂类中只需要告知 对象类型即可。 工厂模式中必须依赖接口
1、简单工厂模式
以生产 "电脑 " 为例，电脑有办公的功能 ， 可以生产一体机 或 笔记本
代码与静态工厂一样 2、静态工厂模式
/** * 简单工厂模式 * @param type * @return *///创建一体机与笔记本的共同接口 Computerpublic interface Computer { //创建方法work：电脑办公 public void work(); }//创建私人电脑类 PersonComputer 实现接口 Computer public class PersonComputer implements Computer{ @Override //重写 实现接口方法 public void work() { System.out.println("这是笔记本电脑，正在办公"); }}//创建一体机类 workComputer 实现接口方法public class WorkComputer implements Computer{ @Override //重写 实现接口方法 public void work() { System.out.println("这是一体机正在办公"); }}//创建工厂类 CompuerFactorypublic class ComputerFactory { /** * 根据不同的类型 生产不同的产品 * @param type * @return */ public Computer produce(String type){ Computer computer =null; //定义一个空对象 if(type.equals("personComputer")){ //判要断实现的对象 computer = new PersonComputer(); //实现对象的赋值，获取要实现的对象 }else if(type.equals("workComputer")){ computer = new WorkComputer(); }else{ System.out.println("不能生产"); } return computer; //返回获得的对象 } /** * 静态工厂方法 * @param type * @return */ public static Computer produce(String type){ // 定义一个接口的引用 通过接口new 一个实现类的对象 // 提高扩展性 Computer computer=null; if(type.equals("workComputer")){ computer = new WorkComputer(); }else if(type.equals("personComputer")){ computer = new PersonComputer(); }else{ System.out.println("不能创建对象"); } return computer; }}//测试实现 简单工厂模式与静态工厂方法public class Test1 { public static void main(String[] args) { // 通过工厂类创建对象 ComputerFactory factory = new ComputerFactory();//通过工厂创建对象 // 要对象 找工厂 （简单工厂模式） Computer computer1 = factory.produce("workComputer"); //通过工厂方法获取要调用的对象 computer1.work(); //由返回获得的对象调用它的方法 // 创建笔记本 Computer computer2 = factory.produce("personComputer"); computer2.work(); //静态的方法调用，不需要通过工厂new对象来调用方法，可直接调用工厂方法获取要实现的对象 （静态工厂模式） Computer computer3 = ComputerFactory2.produce("workComputer"); computer3.work(); }} 3、工厂方法模式
//创建BMWCar类与AudiCar类共同接口Carpublic interface Car { public void showInfo();}//创建AudiCar类public class AudiCar implements Car { @Override public void showInfo() { System.out.println("这是一台奥迪汽车。。"); }}//创建BMWCar类public class BMWCar implements Car { @Override public void showInfo() { System.out.println("这是一台宝马汽车。"); }}/**生产汽车的工厂接口 CarFactory**/public interface CarFactory { public Car produce();}//创建工厂接口的实现类AudiCarFactorypublic class AudiCarFactory implements CarFactory { @Override public Car produce() { return new AudiCar();// 这里AudiCar是Car的实现类（要调用方法需要的对象）；返回要调用的对象 }}//创建工厂接口的实现类BMWCarFactorypublic class BMWCarFactory implements CarFactory { @Override public Car produce() { return new BMWCar();// 因为BWMCar是Car的实现类 }}//测试 public class Test1 { public static void main(String[] args) { //先创建 汽车工厂 对象 CarFactory bmwFactory = new BMWCarFactory(); // 通过工厂对象调用方法produce()来获取要调用的对象（返回值） Car bmw = bmwFactory.produce(); bmw.showInfo(); //通过获取的对象调用它的方法 //这个模式对于同一级别的产品，可扩展性高 //可以扩展不同品牌的汽车，此时不需要修改代码，只需要增加代码即可 // 创建一个新的品牌汽车 大众汽车 CarFactory dazhongFactory = new DazhongCarFactory(); Car car = dazhongFactory.produce(); car.showInfo(); } }7、抽象工厂模式
对于在工厂方法的基础上，对同一个品牌的产品有不同的分类，并对分类产品创建的过程 ，一个汽车产品 会分为不同的种类（迷你汽车 ， SUV汽车 ）
/** * 迷你汽车接口 */public interface MiniCar { public void showInfo();}//SUV汽车接口public interface SUVCar { public void showInfo();}//迷你接口实现类（奥迪汽车：AudiMiniCar）public class AudiMiniCar implements MiniCar { @Override public void showInfo() { System.out.println("这是奥迪迷你汽车 "); }}//迷你接口实现类（宝马汽车：BMWMiniCar）public class BMWMiniCar implements MiniCar { @Override public void showInfo() { System.out.println("这是宝马Cooper迷你汽车"); }}//SUV汽车接口实现类（奥迪汽车：AudiMiniCar）public class AudiSUVCar implements SUVCar { @Override public void showInfo() { System.out.println("这是一辆 奥迪SUV汽车"); }}//SUV汽车接口实现类（宝马汽车：BMWMiniCar）public class BMWSUVCar implements SUVCar { @Override public void showInfo() { System.out.println("这宝马的SUV系列"); }}//工厂接口public interface CarFactory { //生成不同型号的汽车 ，两条产品线 public MiniCar produceMiniCar(); public SUVCar produceSUVCar();}//工厂接口的实现类（奥迪汽车：AudiCarFactoryr）public class AudiCarFactory implements CarFactory { @Override public MiniCar produceMiniCar() { //迷你型汽车方法 return new AudiMiniCar(); //返回对象AudiMiniCar() } @Override public SUVCar produceSUVCar() { //SUV型汽车方法 return new AudiSUVCar(); //返回对象AudiMiniCar() }}//工厂接口的实现类（宝马汽车：BMWCarFactory）public class BMWCarFactory implements CarFactory { // 生成迷你汽车的方法，返回MiniCar @Override public MiniCar produceMiniCar() {//迷你型汽车方法 return new BMWMiniCar(); //返回对象BMWMiniCar() } //生成SUV汽车的方法， 返回SUVCar @Override public SUVCar produceSUVCar() {//SUV型汽车方法 return new BMWSUVCar(); //返回对象BMWMiniCar() }}//测试：public class Test1 { public static void main(String[] args) { //创建宝马迷你汽车 找工厂（创建工厂对象） CarFactory factory = new BMWCarFactory(); MiniCar car = factory.produceMiniCar(); //通过工厂对象调用方法获取目标对象 car.showInfo(); //通过获取的对象调用方法 }}总结： 对于简单工厂， 工厂方法模式和抽象工厂的区别和用途
1、对于简单工厂（静态和非静态），用于生产同一结构中的任意产品，对于新增产品不适用。
2、对于工厂方法，在简单工厂的基础上，生产同一个等级结构中的固定产品，可以支持新增产品。
3、抽象工厂： 用于生产不同种类（品牌）的相同类型（迷你，SUV） ，对于新增品牌可以，不支持新增类型。
8、模板方法
定义：
模板方法是一种行为模式，父类的一个方法定义完成这个方法的步骤，但不具体实现具体细节，由子类完成各个步骤的实现，在创建子类对象时，最终的实现过程是子类的方法。
模板方法的准备：
1、继承关系
2、父类是抽象类 ：抽象类实现了模板方法，定义了算法的估计
3、子类继承抽象类：实现抽象方法，完成完整的算法
public abstract class AbstractPerson { /** * 定义一个模板方法，用于实现这个方法的基本"骨架" * 每一步骤的具体实现由子类完成 */ public void preparedSchool(){ getUp(); dressing(); eat(); } //起床 public abstract void getUp(); //穿衣服 public abstract void dressing(); //吃早餐 public abstract void eat();}public class Teacher extends AbstractPerson { @Override public void getUp() { System.out.println("老师起床，7点半起床"); } @Override public void dressing() { System.out.println("老师要衣服得体，穿工装"); } @Override public void eat() { System.out.println("老师吃早餐。"); }}public class Test1 { public static void main(String[] args) { Student stu = new Student();//创建学生类对象 stu.preparedSchool(); Teacher teacher = new Teacher(); //创建老师类对象 teacher.preparedSchool(); }}原文转载：http://www.shaoqun.com/a/481029.html
outfit：https://www.ikjzd.com/w/938
blibli：https://www.ikjzd.com/w/1676
patents：https://www.ikjzd.com/w/857
一、设计模式概念1、定义Java包含23种设计模式，是一套对代码设计经验的总结，被人们反复利用，多人熟知的代码设计方式。2、目的：为了提高代码的可读性，可扩展性以及代码的复用性，为了解决在写代码过程中遇到的代码设计问题。3、设计模式的六大原则3.1开闭原则：对扩展开发，对修改关闭（尽可能对代码少修改）3.2里式替换原则：它是面向对象基本原则之一，任何父类（基类）出现的地方，子类都可以出现，
tinypic：https://www.ikjzd.com/w/114
转运中国：https://www.ikjzd.com/w/1549
亚马逊三种引流的方式，提升曝光：https://www.ikjzd.com/tl/6127
迦递货运：https://www.ikjzd.com/w/1834
做独立站推广Google AdWords与Facebook广告应该如何抉择？：https://www.ikjzd.com/home/128740
没有评论:
发表评论