设计模式二——结构型模式（笔记）

一、适配器模式

简介：

作为两个不兼容的接口之间的桥梁。 解决正在运行使用的项目的问题。 eg：安卓的耳机搭上接口转换器便可在苹果手机上使用。

何时使用： 1、系统想使用一个现有的类，但类的接口不符合系统要求。 2、通过接口转换，将一个类插入另一个类系中（适配器继承或依赖已有的对象，实现想要的目标接口）。 优点： 1、可一起运行两个无关联的类； 2、类复用性提高（通过继承或依赖）； 3、类的透明性增加； 4、灵活性。 缺点： 1、过多使用使得系统整体凌乱 2、Java最多继承一个类，故最多只能适配一个适配器类，且目标必须为抽象类。

实现：

创建接口 package interfaceofthis; public interface MediaPlayer { public void play(String audioType,String filename); } package interfaceofthis; public interface AdvancedMediaPlayer { public void playVlc(String fileName); public void playMpe(String fileName); } 创建一个接口的实体类 package interfaceentity; import interfaceofthis.AdvancedMediaPlayer; public class Mp4Player implements AdvancedMediaPlayer { @Override public void playVlc(String fileName) { // TODO 自动生成的方法存根 } @Override public void playMpe(String fileName) { // TODO 自动生成的方法存根 System.out.println("这是MP4文件"+fileName); } } package interfaceentity; import interfaceofthis.AdvancedMediaPlayer; public class VlcPlayer implements AdvancedMediaPlayer{ @Override public void playVlc(String fileName) { // TODO 自动生成的方法存根 System.out.println("这是Vlc文件"+fileName); } @Override public void playMpe(String fileName) { // TODO 自动生成的方法存根 } } 创建另一个接口的适配器类 package adapterclass; import interfaceentity.Mp4Player; import interfaceentity.VlcPlayer; import interfaceofthis.AdvancedMediaPlayer; import interfaceofthis.MediaPlayer; public class MediaAdapter implements MediaPlayer{ AdvancedMediaPlayer advancedMediaPlayer; public void play(String audioType, String filename) { // TODO 自动生成的方法存根 if(audioType.equalsIgnoreCase("vlc")) { advancedMediaPlayer.playVlc(filename); } if(audioType.equalsIgnoreCase("mp4")) { advancedMediaPlayer.playMpe(filename); } } public MediaAdapter(String audioType) { if(audioType.equals("vlc")) { advancedMediaPlayer =new VlcPlayer(); } else if(audioType.equals("mp4")) { advancedMediaPlayer=new Mp4Player(); } } } 创建接口的实体类 package interfaceentity; import adapterclass.MediaAdapter; import interfaceofthis.MediaPlayer; public class AudioPlayer implements MediaPlayer{ MediaAdapter mediaAdapter; @Override public void play(String audioType, String filename) { // TODO 自动生成的方法存根 if(audioType.equalsIgnoreCase("mp3") ) { System.out.println("这是MP3文件"+filename); } else if(audioType.equalsIgnoreCase("vlc")||audioType.equalsIgnoreCase("mp4")) { mediaAdapter=new MediaAdapter(audioType); mediaAdapter.play(audioType, filename); } else { System.out.println("这是未知格式"+filename); } } } 测试输出 package test; import interfaceentity.AudioPlayer; public class test { public static void main(String[] args) { AudioPlayer aPlayer=new AudioPlayer(); aPlayer.play("mp3","听海"); aPlayer.play("mp4","我"); aPlayer.play("vlc","你"); aPlayer.play("avi","风"); } }

二、桥接模式

简介

将抽象化和实现化解耦（分离抽象部分和实现部分）。

何时使用：实现系统可能有多个角度分类，每一种角度都可能变化。对于两个独立变化的维度，使用桥接模式再适合不过了。

优点：

分离抽象和实现扩展能力细节对用户透明

缺点：

增加了理解和设计难度。针对抽象设计编程

实现

创建桥接实现接口 package interfaceofthis; public interface DrawAPI { public void drawGirl(String type); } 创建接口的实现类 package interfaceentity; import interfaceofthis.DrawAPI; public class BlackHair implements DrawAPI{ @Override public void drawGirl(String type) { // TODO 自动生成的方法存根 System.out.println("发色：黑发"+" "+"风格："+type); } } package interfaceentity; import interfaceofthis.DrawAPI; public class RedHair implements DrawAPI { @Override public void drawGirl(String type) { // TODO 自动生成的方法存根 System.out.println("发色：红发"+" "+"风格："+type); } } 使用接口创建抽象类 package abstractclass; import interfaceofthis.DrawAPI; public abstract class Type { protected DrawAPI drawAPI; protected Type(DrawAPI drawAPI){ this.drawAPI=drawAPI; } public abstract void draw(); } 创建抽象类的实体类 package abstractentity; import abstractclass.Type; import interfaceofthis.DrawAPI; public class Girl extends Type{ private String type; public Girl(String type,DrawAPI drawAPI) { super(drawAPI); // TODO 自动生成的构造函数存根 this.type=type; } @Override public void draw() { // TODO 自动生成的方法存根 drawAPI.drawGirl(type); } } 使用接口和抽象类测试 package test; import abstractclass.Type; import abstractentity.Girl; import interfaceentity.BlackHair; import interfaceentity.RedHair; public class test { public static void main(String[] args) { Type redGirl=new Girl("甜美可爱型",new RedHair()); Type blackGirl=new Girl("甜美可爱型",new BlackHair()); redGirl.draw(); blackGirl.draw(); } }

三、过滤器模式

简介 使用不同的标准（结合成单一标准）来过滤一组对象。

实现 创建一个类（产生待过滤对象）

package befiltedclass; public class Person { private String name,gender,status; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getGender() { return gender; } public void setGender(String gender) { this.gender = gender; } public String getStatus() { return status; } public void setStatus(String status) { this.status = status; } public Person(String name, String gender, String status) { this.name = name; this.gender = gender; this.status = status; } }

为不同的标准创建一个接口

package filterrules; import java.util.List; import befiltedclass.Person; public interface Rules { public List<Person> meetRules(List<Person> persons); }

创建接口的实体类

package rulesentity; import java.util.ArrayList; import java.util.List; import befiltedclass.Person; import filterrules.Rules; public class BoyGirl implements Rules{ @Override public List<Person> meetRules(List<Person> persons) { // TODO 自动生成的方法存根 List<Person> girlPersons=new ArrayList<>(); for(Person person:persons) { if(person.getGender().equalsIgnoreCase("男")) { girlPersons.add(person); } } return girlPersons; } } package rulesentity; import java.util.ArrayList; import java.util.List; import befiltedclass.Person; import filterrules.Rules; public class GirlPerson implements Rules { @Override public List<Person> meetRules(List<Person> persons) { // TODO 自动生成的方法存根 List<Person> girlPersons=new ArrayList<>(); for(Person person:persons) { if(person.getGender().equalsIgnoreCase("女")) { girlPersons.add(person); } } return girlPersons; } } package rulesentity; import java.util.ArrayList; import java.util.List; import befiltedclass.Person; import filterrules.Rules; public class NotSingle implements Rules { @Override public List<Person> meetRules(List<Person> persons) { // TODO 自动生成的方法存根 List<Person> girlPersons=new ArrayList<>(); for(Person person:persons) { if(person.getGender().equalsIgnoreCase("Married")) { girlPersons.add(person); } } return girlPersons; } } package rulesentity; import java.util.ArrayList; import java.util.List; import befiltedclass.Person; import filterrules.Rules; public class Single implements Rules { @Override public List<Person> meetRules(List<Person> persons) { // TODO 自动生成的方法存根 List<Person> girlPersons=new ArrayList<>(); for(Person person:persons) { if(person.getGender().equalsIgnoreCase("Single")) { girlPersons.add(person); } } return girlPersons; } }

测试

package test; import java.util.ArrayList; import java.util.List; import befiltedclass.Person; import filterrules.Rules; import rulesentity.BoyGirl; import rulesentity.GirlPerson; public class test { public static void printPersons(List<Person> persons){ for (Person person : persons) { System.out.println("他们是 : [ 姓名 : " + person.getName() +", 性别 : " + person.getGender() +", 婚姻状态 : " + person.getStatus() +" ]"); } } public static void main(String[] args) { List<Person> persons = new ArrayList<Person>(); persons.add(new Person("Robert","男", "Single")); persons.add(new Person("John","男", "Married")); persons.add(new Person("Laura","女", "Married")); persons.add(new Person("Diana","女", "Single")); persons.add(new Person("Mike","男", "Single")); persons.add(new Person("Bobby","男", "Single")); Rules female = new GirlPerson(); Rules male = new BoyGirl(); System.out.println("男孩们: "); printPersons(male.meetRules(persons)); System.out.println("女孩们: "); printPersons(female.meetRules(persons)); } }

四、组合模式

简介： 把一组相似的对象当作一个单一的对象。依据树形结构来组合对象。

何时使用： 1、表示对象的部分-整体层次结构（树形结构）。 2、用户统一地使用组合结构中的所有对象。

优点： 1、调用高层模块简单 2、节点自由增加

缺点：都是实现类。

实现：

创建带有对象列表的类

import java.util.ArrayList; import java.util.List; public class Employee { private String name,dname; private int salary; private List<Employee> EmployeeList; public Employee(String name, String dname, int salary) { this.name = name; this.dname = dname; this.salary = salary; EmployeeList = new ArrayList<Employee>(); } public void add(Employee e) { EmployeeList.add(e); } public void remove(Employee e) { EmployeeList.remove(e); } public List<Employee> getEmployeeList(){ return EmployeeList; } public String toString(){ return ("员工:[姓名: "+ name +", 部门 : "+ dname + ", 工资 :" + salary+" ]"); } }

测试

public class test { public static void main(String[] args) { Employee CEO = new Employee("蛋挞菌1","Boss", 30000); Employee headSales = new Employee("蛋挞菌2","行政主管", 20000); Employee headMarketing = new Employee("蛋挞菌3","市场经理", 20000); Employee clerk1 = new Employee("蛋挞菌4","市场部", 10000); Employee clerk2 = new Employee("蛋挞菌5","市场部", 10000); Employee salesExecutive1 = new Employee("蛋挞菌6","行政部", 10000); Employee salesExecutive2 = new Employee("蛋挞菌7","行政部", 10000); CEO.add(headSales); CEO.add(headMarketing); headSales.add(salesExecutive1); headSales.add(salesExecutive2); headMarketing.add(clerk1); headMarketing.add(clerk2); System.out.println(CEO); for (Employee headEmployee : CEO.getEmployeeList()) { System.out.println(headEmployee); for (Employee employee : headEmployee.getEmployeeList()) { System.out.println(employee); } } } }

Bye~