设计模式之结构型模型
桥接模式
尽可能不要使用类的继承，而尽可能使用 合成/聚合
描述: 继承方法子类与父类的高依赖性限制了复用和程序的灵活性。
选择不同的接口实现选择不同的业务类型
import org.junit.Test;
public class 桥接模式 {
@Test
public void test()
{
ColocalateFactory a=new BlackFactory();
a.ColocalateMarking();
ColocalateFactory b=new WhilteFactory();
b.ColocalateMarking();
}
}
interface ColocalateFactory
{
void ColocalateMarking();
}
class BlackFactory implements ColocalateFactory
{
@Override
public void ColocalateMarking() {
// TODO Auto-generated method stub
System.out.println("生产黑色巧克力");
}
}
class WhilteFactory implements ColocalateFactory
{
@Override
public void ColocalateMarking() {
// TODO Auto-generated method stub
System.out.println("生产白色巧克力");
}
}
适配器模式
描述：维护人员处理功能相同或者相似，但方法不同。进行接口的统一调用。
- 注入需要适配的类的时候，使用set方法而不是new实例化对象，从而防止固化。
- 适配类的方法与要被适配类的方法不是平行关系而是调用关系。
public interface Charger {
void GetPower();
}
//充电器A
public class ChargerA implements Charger {
@Override
public void GetPower() {
// TODO Auto-generated method stub
System.out.println("使用220V经行充电");
}
}
//充电器B
public class ChargerB implements Charger {
@Override
public void GetPower() {
// TODO Auto-generated method stub
System.out.println("使用200V进行充电");
}
}
//万能充电器
import org.junit.Test;
public class MultCharger implements Charger {
private Charger charger;
public void setCharger(Charger charger) {
this.charger = charger;
}
@Override
public void GetPower() {
// TODO Auto-generated method stub
this.charger.GetPower();
}
@Test
public void test()
{
Charger a=new ChargerA();
Charger b=new ChargerB();
MultCharger Multcharger=new MultCharger();
Multcharger.setCharger(a);
Multcharger.GetPower();
Multcharger.setCharger(b);
Multcharger.GetPower();
}
}装饰器模式
描述：在不改变原有类文件和使用继承的情况下，动态扩展某个对象的功能。（这样决定了不能直接添加类方法）
- 适配器模式 适配对象和被适配器对象可以不存在实现统一接口的关系（即兄弟类）。 目的是：兼容
- 装饰器模式：是继承的一种替代方法，相对而言更加灵活。目的是：增强
import org.junit.Test;
public class 装饰器模式 {
@Test
public void test()
{
Soldier s=new SmallSoldier();
BigSoldier b=new BigSoldier();
b.setSoldier(s);
b.fighting();
}
}
interface Soldier
{
void fighting();
}
class SmallSoldier implements Soldier
{
@Override
public void fighting() {
// TODO Auto-generated method stub
System.out.println("普通士兵在战斗");
}
}
class BigSoldier implements Soldier
{
private Soldier soldier;
public void setSoldier(Soldier soldier) {
this.soldier = soldier;
}
@Override
public void fighting() {
// TODO Auto-generated method stub
soldier.fighting();
System.out.println("配置了远程兵在辅助");
}
}
组合模式
利用递归的思想
描述：将对象组合成树形结构以表示”部分-整体“的层次结构
补充：并且提供给了增加子节点、移除子节点、展示结构的三种方法。
应用场景：出现树形结构的地方，如文件目录显示，多级目录呈现等树形结构数据的操作。
方法：通过继承抽象类来实现
public abstract class Node {
protected String name;//名称
//构造器赋名
public Node(String name){
this.name = name;
}
//新增节点：文件节点无此方法，目录节点重写此方法
public void addNode(Node node) throws Exception{
throw new Exception("Invalid exception");
}
//删除节点
public void removeNode(Node node)throws Exception{
throw new Exception("Invalid exception");
}
//显示节点：文件与目录均实现此方法
abstract void display();
}
//文件结点
public class Filer extends Node {
public Filer(String name) {
super(name);
// TODO Auto-generated constructor stub
}
@Override
void display() {
// TODO Auto-generated method stub
System.out.println(name);
}
}
//目录结点
public class Noder extends Node{
//内部节点列表（包括文件和下级目录）
List<Node> nodeList = new ArrayList<Node>();
public Noder(String name) {
super(name);
// TODO Auto-generated constructor stub
}
//新增节点
public void addNode(Node node) throws Exception{
nodeList.add(node);
}
//删除节点
public void removeNode(Node node)throws Exception
{
nodeList.remove(node);
}
//向下递归打印名称
@Override
void display() {
System.out.println(name);
for(Node node:nodeList){
node.display();
}
}
}
//测试类
import java.io.File;
public class Clienter {
public static void createTree(Node node) throws Exception{
File file = new File(node.name);
File[] f = file.listFiles();
for(File fi : f){
//判断结点是不是文件
if(fi.isFile()){
//利用绝对路径给结点命名
Filer filer = new Filer(fi.getAbsolutePath());
node.addNode(filer);
}
//判断结点是不是目录
if(fi.isDirectory()){
//利用绝对路径给结点命名
Noder noder = new Noder(fi.getAbsolutePath());
node.addNode(noder);
createTree(noder);//使用递归生成树结构
}
}
}
public static void main(String[] args) {
Node noder = new Noder("G://WeGame");
try {
createTree(noder);
} catch (Exception e) {
e.printStackTrace();
}
noder.display();
}
}享元模式
描述：用一个类存储共享资源， 运行共享技术有效地支持大量细粒度对象的复用
方式：通过Map集合存储（HashMap）
提供 增加put、获取get 方法
public class Student {
private String name;
private int age;
public Student(String name,int age)
{
this.name=name;
this.age=age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
import java.util.HashMap;
import org.junit.Test;
public class StudentFactory {
static HashMap <String,Student>map=new HashMap<>();
public static Student getStudent(String name)
{
if(map.get(name)!=null)
{
return map.get(name);
}
return null;
}
public static void addStudent(Student s)
{
map.put(s.getName(), s);
}
public static void display()
{
System.out.println(map.entrySet());
}
@Test
public void test001()
{
StudentFactory.addStudent(new Student("luo", 18));
StudentFactory.addStudent(new Student("li", 17));
Student s= StudentFactory.getStudent("luo");
System.out.println(s);
StudentFactory.display();
}
}外观模式
不改变旧的类的内容，通过一个外观类对相关联的方法经行业务重组。
般用在子系统与访问之间，用于对访问屏蔽复杂的子系统调用，采用耳目一新的外观类提供的简单的调用方法，具体的实现由外观类去子系统调用。（业务逻辑整合）
import org.junit.Test;
public class 外观模式{
private FactoryA a=new FactoryA();
private FactoryB b=new FactoryB();
public void lookplay()
{
a.funcA();
b.funcB();
}
@Test
public void test()
{
new 外观模式().lookplay();
}
}
class FactoryA
{
public void funcA()
{
System.out.println("向别人表白");
}
}
class FactoryB
{
public void funcB()
{
System.out.println("答应别人的表白");
}
}
代理模式
描述：为第三方对象提供一种代理以控制对象的访问（第三方墙行为）
注：适配器是一对多，代理器是一对一的关系。
public interface FactoryInterface {
void Breakmaking();
}
public class Factory implements FactoryInterface{
@Override
public void Breakmaking() {
// TODO Auto-generated method stub
System.out.println("生产面包");
}
}
import org.junit.Test;
public class AgentFactory implements FactoryInterface{
FactoryInterface f =new Factory();
@Override
public void Breakmaking() {
// TODO Auto-generated method stub
f.Breakmaking();
}
@Test
public void test()
{
new AgentFactory().Breakmaking();
}
}