1、定义
java包含23中设计模式，是一套对代码设计经验的总结，被人们反复利用，多人熟知的代码设计方法
2、目的
为了提高代码的可读性，可扩展性及代码的复用性，为了解决在写代码过程中遇到的代码设计问题。
3、设计模式的六大原则
1、开闭原则：对扩展开放，对修改关闭（尽可能对代码少修改）
2、里式替换原则：它是面向对象基本原则之一，如何分类（基类）出现的地方，子类都可以出现，也就是子类可以替换分类的如何功能（体现了父类的扩展性）
3、依赖倒转原则：尽可能面向接口编程，依赖接口而不依赖类
4、接口隔离原则：一个类如果能实现多个接口，尽可能实现多个接口，为了降低依赖，降低耦合
5、最少知道原则：一个实体尽可能少的与其他实体产生相互共良宵，将实体的功能独立
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;
}
}
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、静态工厂模式
//电脑接口
public interface Computer {
//电脑办公
public void work();
}
//笔记本类
public class PersonComputer implements Computer{
@Override
public void work() {
System.out.println("这是笔记本电脑，正在办公");
}
}
//一体机类
public class WorkComputer implements Computer{
@Override
public void work() {
System.out.println("这是一体机正在办公");
}
}
public class ComputerFactory {
//根据不同的类型 生产不同的产品
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 TestStaticFactory {
public static void main(String[] args) {
// 通过工厂类创建对象
ComputerFactory factory = new ComputerFactory();
// 要对象 找工厂
Computer computer1 = factory.produce("workComputer");
computer1.work();
// 创建笔记本
Computer computer2 = factory.produce("personComputer");
computer2.work();
Computer computer3 = ComputerFactory2.produce("workComputer");
computer3.work();
}
}
3、工厂方法模式
//汽车接口
public interface Car {
public void showInfo();
}
//奥迪类
public class AudiCar implements Car {
@Override
public void showInfo() {
System.out.println("这是一台奥迪汽车。。");
}
}
//宝马类
public class BMWCar implements Car {
@Override
public void showInfo() {
System.out.println("这是一台宝马汽车。");
}
}
//生产汽车的工厂接口
public interface CarFactory {
public Car produce();
}
//奥迪工厂
public class AudiCarFactory implements CarFactory {
@Override
public Car produce() {
return new AudiCar();// 这里AudiCar是Car的实现类
}
}
//宝马工厂
public class BMWCarFactory implements CarFactory {
@Override
public Car produce() {
return new BMWCar();// 因为BWMCar是Car的实现类
}
}
public class TestFactory {
public static void main(String[] args) {
//先创建 汽车工厂
CarFactory bmwFactory = new BMWCarFactory();
// 这个工厂生产的汽车就是 宝马
Car bmw = bmwFactory.produce();
bmw.showInfo();
//这个模式对于同一级别的产品，可扩展性高
//可以扩展不同品牌的汽车，此时不需要修改代码，只需要增加代码即可
// 创建一个新的品牌汽车 大众汽车
CarFactory dazhongFactory = new DazhongCarFactory();
Car car = dazhongFactory.produce();
car.showInfo();
}
}
7、抽象工厂模式
//迷你汽车接口
public interface MiniCar {
public void showInfo();
}
//SUV汽车接口
public interface SUVCar {
public void showInfo();
}
//奥迪实现Mini接口类
public class AudiMiniCar implements MiniCar {
@Override
public void showInfo() {
System.out.println("这是奥迪迷你汽车 ");
}
}
//宝马实现Mini接口类
public class BMWMiniCar implements MiniCar {
@Override
public void showInfo() {
System.out.println("这是宝马Cooper迷你汽车");
}
}
//奥迪实现SUV接口类
public class AudiSUVCar implements SUVCar {
@Override
public void showInfo() {
System.out.println("这是一辆 奥迪SUV汽车");
}
}
//宝马实现SUV接口类
public class BMWSUVCar implements SUVCar {
@Override
public void showInfo() {
System.out.println("这宝马的SUV系列");
}
}
//汽车生产工厂接口
public interface CarFactory {
//生成不同型号的汽车 ，两条产品线
public MiniCar produceMiniCar();
public SUVCar produceSUVCar();
}
//奥迪汽车工厂实现汽车工厂接口
public class AudiCarFactory implements CarFactory {
@Override
public MiniCar produceMiniCar() {
return new AudiMiniCar();
}
@Override
public SUVCar produceSUVCar() {
return new AudiSUVCar();
}
}
//宝马汽车工厂实现汽车工厂接口
public class BMWCarFactory implements CarFactory {
// 生成迷你汽车的方法，返回MiniCar
@Override
public MiniCar produceMiniCar() {
return new BMWMiniCar();
}
//生成SUV汽车的方法， 返回SUVCar
@Override
public SUVCar produceSUVCar() {
return new BMWSUVCar();
}
}
public class Testabstractfactory{
public static void main(String[] args) {
//创建宝马迷你汽车 找工厂
CarFactory factory = new BMWCarFactory();
MiniCar car = factory.produceMiniCar();
car.showInfo();
}
}
总结： 对于简单工厂， 工厂方法模式和44抽象工厂的区别和用途
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();
}
}