目录
1.适配器模式
代码示例：
package designPattern;
/**
* 适配器模式
* 假设你的电脑只有一个Type-C接口，现在你想要将电脑接入网线和USB
* 那么我们就可以使用一个适配器Adapter来作为这个不兼容接口之间的桥梁
*/
public class AdapterMode {
public static void main(String[] args) {
Adapter adapter = new Adapter();
adapter.transmission("usb");
adapter.transmission("network");
//无法适配GVA信号
adapter.transmission("GVA");
}
}
/**
* 网线接口
*/
interface NetworkInterface {
void transmission();
}
/**
* USB接口
*/
interface USBInterface {
void transmission();
}
/**
* 适配器接口
*/
interface AdapterInterface {
/**
* 适配不同的传输信号
*
* @param signalsName 信号名称
*/
void transmission(String signalsName);
}
/**
* NetworkInterface的实现类
*/
class Network implements NetworkInterface {
@Override
public void transmission() {
System.out.println("i'm transmitting network signals");
}
}
/**
* USBInterface的实现类
*/
class USB implements USBInterface {
@Override
public void transmission() {
System.out.println("i'm transmitting USB signals");
}
}
/**
* AdapterInterface的实现类
*/
class Adapter implements AdapterInterface {
private Network network = new Network();
private USB usb = new USB();
@Override
public void transmission(String signalsName) {
if (signalsName.equalsIgnoreCase("network")) network.transmission();
else if (signalsName.equalsIgnoreCase("usb")) usb.transmission();
else System.out.println("signals error");
}
}
2.桥接模式
代码示例：
package designPattern;
/**
* 桥接模式
* 将具体类与接口实现者类分开，是它们都可以独立的变化
*/
public class BridgingMode {
public static void main(String[] args) {
Color black = new Black();
Shape circle = new Circle();
circle.setColor(black);
circle.print();
}
}
interface Color {
void getColor();
}
/**
* Color接口的三个实现类
*/
class White implements Color {
@Override
public void getColor() {
System.out.println("i am a white");
}
}
class Black implements Color {
@Override
public void getColor() {
System.out.println("i am a black");
}
}
class Blue implements Color {
@Override
public void getColor() {
System.out.println("i am a blue");
}
}
/**
* Shape在此处充当接口实现类和具体类之间的一个桥梁
*/
abstract class Shape {
Color color;
public void setColor(Color color) {
this.color = color;
}
public abstract void print();
}
class Circle extends Shape {
@Override
public void print() {
color.getColor();
System.out.println("big Circle");
}
}
class Rectangle extends Shape {
@Override
public void print() {
color.getColor();
System.out.println("big Rectangle");
}
}
class Square extends Shape {
@Override
public void print() {
color.getColor();
System.out.println("big Square");
}
}
3.过滤器模式（标准模式）
代码示例：
package designPattern;
import java.util.ArrayList;
import java.util.List;
/**
* 过滤器模式（标准模式）
*/
public class FilterMode {
public static void main(String[] args) {
List<Person> persons = new ArrayList<Person>();
persons.add(new Person("Robert", "Male", "Single"));
persons.add(new Person("John", "Male", "Married"));
persons.add(new Person("Laura", "Female", "Married"));
persons.add(new Person("Diana", "Female", "Single"));
persons.add(new Person("Mike", "Male", "Single"));
persons.add(new Person("Bobby", "Male", "Single"));
Criteria male = new Male();
Criteria female = new Female();
Criteria single = new Single();
//单身男士过滤器
Criteria singleMale = new AndCriteria(male, single);
singleMale.meetCriteria(persons).forEach(System.out::println);
}
}
/**
* 人类
*/
class Person {
private String name;
//性别
private String gender;
//婚姻状况
private String maritalStatus;
public Person(String name, String gender, String maritalStatus) {
this.name = name;
this.gender = gender;
this.maritalStatus = maritalStatus;
}
public String getName() {
return name;
}
public String getGender() {
return gender;
}
public String getMaritalStatus() {
return maritalStatus;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", gender='" + gender + '\'' +
", maritalStatus='" + maritalStatus + '\'' +
'}';
}
}
/**
* 标准接口
*/
interface Criteria {
//返回符合标准的人集合
public List<Person> meetCriteria(List<Person> persons);
}
/**
* 根据女性这个标准来过滤对象
*/
class Male implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> malePersons = new ArrayList<Person>();
for (Person person : persons) {
if (person.getGender().equalsIgnoreCase("MALE")) {
malePersons.add(person);
}
}
return malePersons;
}
}
/**
* 根据男性这个标准来过滤对象
*/
class Female implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> femalePersons = new ArrayList<Person>();
for (Person person : persons) {
if (person.getGender().equalsIgnoreCase("FEMALE")) {
femalePersons.add(person);
}
}
return femalePersons;
}
}
/**
* 根据单身这个标准来过滤对象
*/
class Single implements Criteria {
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> singlePersons = new ArrayList<Person>();
for (Person person : persons) {
if (person.getMaritalStatus().equalsIgnoreCase("SINGLE")) {
singlePersons.add(person);
}
}
return singlePersons;
}
}
/**
* 两层过滤，要都满足才可通过
*/
class AndCriteria implements Criteria {
private Criteria criteria;
private Criteria otherCriteria;
public AndCriteria(Criteria criteria, Criteria otherCriteria) {
this.criteria = criteria;
this.otherCriteria = otherCriteria;
}
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);
return otherCriteria.meetCriteria(firstCriteriaPersons);
}
}
/**
* 两层过滤，满足至少有一项满足即可通过
*/
class OrCriteria implements Criteria {
private Criteria criteria;
private Criteria otherCriteria;
public OrCriteria(Criteria criteria, Criteria otherCriteria) {
this.criteria = criteria;
this.otherCriteria = otherCriteria;
}
@Override
public List<Person> meetCriteria(List<Person> persons) {
List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);
//求两种过滤方法后的集合的并集
for (Person person : otherCriteriaItems) {
if (!firstCriteriaItems.contains(person)) {
firstCriteriaItems.add(person);
}
}
return firstCriteriaItems;
}
}
4.组合模式
package designPattern;
import java.util.ArrayList;
import java.util.List;
/**
* 组合模式,模拟公司人员结构
* 组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构
*/
public class CombinationMode {
public static void main(String[] args) {
Employee CEO = new Employee("John", "CEO", 30000);
Employee headSales = new Employee("Robert", "Head Sales", 20000);
Employee headMarketing = new Employee("Michel", "Head Marketing", 20000);
Employee clerk1 = new Employee("Laura", "Marketing", 10000);
Employee clerk2 = new Employee("Bob", "Marketing", 10000);
Employee salesExecutive1 = new Employee("Richard", "Sales", 10000);
Employee salesExecutive2 = new Employee("Rob", "Sales", 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.getSubordinates()) {
System.out.println(headEmployee);
for (Employee employee : headEmployee.getSubordinates()) {
System.out.println(employee);
}
}
}
}
/**
* 雇员类
*/
class Employee {
private String name;
//部门
private String department;
//薪水
private int salary;
//下属集合
private List<Employee> subordinates;
//构造函数
public Employee(String name, String dept, int sal) {
this.name = name;
this.department = dept;
this.salary = sal;
subordinates = new ArrayList<Employee>();
}
/**
* 为该雇员添加手下
*
* @param e
*/
public void add(Employee e) {
subordinates.add(e);
}
public void remove(Employee e) {
subordinates.remove(e);
}
public List<Employee> getSubordinates() {
return subordinates;
}
public String toString() {
return ("Employee :[ Name : " + name
+ ", dept : " + department + ", salary :"
+ salary + " ]");
}
}
