JAVA基础10 设计模式:结构型模式(适配器 代理模式 桥接模式 享元模式 组合模式 装饰器模式)

结构型模式： 
核心作用：是从程序的结构上实现松耦合，从而可以扩大整体的类结构，用来解决更大的问题
分类： 适配器模式 代理模式 桥接模式 装饰模式 组合模式 外观模式 享元模式
我们在学习中见过的场景
java.io.InputStreamReader(InputStream)

java.io.OutputStreamWriter(OutputStream)

案例 适配器模式

<span style="font-size:14px;">public class Client {
	public void test1(Target t){
		t.handleReq();
	}
	public static void main(String[] args) {
		Client  c = new Client();
		Adaptee a = new Adaptee();	
//		Target t = new Adapter();
		Target t = new Adapter2(a);
		c.test1(t);
	}
}

/**
 * 被适配的类
 * @author Administrator
 *
 */
public class Adaptee {
	public void request(){
		System.out.println("可以完成客户请求的需要的功能！");
	}
}

public interface Target {
	void handleReq();
}

/**
 * 适配器 (类适配器方式)
 * (相当于usb和ps/2的转接器)
 * @author Administrator
 *
 */
public class Adapter extends Adaptee implements Target {
	@Override
	public void handleReq() {
		super.request();
	}
}

/**
 * 适配器 (对象适配器方式,使用了组合的方式跟被适配对象整合)
 * (相当于usb和ps/2的转接器)
 * @author Administrator
 *
 */
public class Adapter2  implements Target {
	private Adaptee adaptee;
	@Override
	public void handleReq() {
		adaptee.request();
	}
	public Adapter2(Adaptee adaptee) {
		super();
		this.adaptee = adaptee;
	}
}</span>

代理模式

通过代理，控制对对象的访问！可以详细控制访问某个(某类)对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理
分类： 静态代理(静态定义代理类)
       动态代理(动态代理生成代理类)
    JDK自带的动态代理
javaassist字节码操作库实现
CGLIB
ASM(底层使用指令 可维护性较差)

案例 静态代理

<span style="font-size:14px;">public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收钱
	 */
	void collectMoney();
}		 

public class RealStar implements Star {
	@Override
	public void bookTicket() {
		System.out.println("RealStar.bookTicket()");
	}
	@Override
	public void collectMoney() {
		System.out.println("RealStar.collectMoney()");
	}
	@Override
	public void confer() {
		System.out.println("RealStar.confer()");
	}
	@Override
	public void signContract() {
		System.out.println("RealStar.signContract()");
	}
	@Override
	public void sing() {
		System.out.println("RealStar(周杰伦本人).sing()");
	}
}

public class ProxyStar implements Star {
	private Star star;
	
	public ProxyStar(Star star) {
		super();
		this.star = star;
	}
	@Override
	public void bookTicket() {
		System.out.println("ProxyStar.bookTicket()");
	}

	@Override
	public void collectMoney() {
		System.out.println("ProxyStar.collectMoney()");
	}
	@Override
	public void confer() {
		System.out.println("ProxyStar.confer()");
	}
	@Override
	public void signContract() {
		System.out.println("ProxyStar.signContract()");
	}
	@Override
	public void sing() {
		star.sing();
	}
}
public class Client {
	public static void main(String[] args) {
		Star real = new RealStar();
		Star proxy = new ProxyStar(real);
		
		proxy.confer();
		proxy.signContract();
		proxy.bookTicket();
		proxy.sing();
		
		proxy.collectMoney();
		
	}
}</span>

JDK自带的动态代理
1.java.lang.reflect.Proxy :动态生成代理类和对象
2.java.lang.reflect.InvocationHandler(处理器接口)
  可以通过invoke方法实现对真实角色的代理访问
  每次通过Proxy生产代理类对象对象时都要指定对应的代理器对象

 案例 动态代理

<span style="font-size:14px;">public class Client {
	public static void main(String[] args) {
		
		Star realStar = new RealStar();
		StarHandler handler = new StarHandler(realStar);
		
		Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), 
				new Class[]{Star.class}, handler);
		proxy.sing();
	}
}
public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收钱
	 */
	void collectMoney();
}
public class RealStar implements Star {
	@Override
	public void bookTicket() {
		System.out.println("RealStar.bookTicket()");
	}
	@Override
	public void collectMoney() {
		System.out.println("RealStar.collectMoney()");
	}
	@Override
	public void confer() {
		System.out.println("RealStar.confer()");
	}
	@Override
	public void signContract() {
		System.out.println("RealStar.signContract()");
	}
	@Override
	public void sing() {
		System.out.println("RealStar(周杰伦本人).sing()");
	}
}
public class StarHandler implements InvocationHandler {
	Star realStar;
	public StarHandler(Star realStar) {
		super();
		this.realStar = realStar;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object object = null;
		System.out.println("真正的方法执行前！");
		System.out.println("面谈，签合同，预付款，订机票");
		if(method.getName().equals("sing")){
			object = method.invoke(realStar, args);
		}
		System.out.println("真正的方法执行后！");
		System.out.println("收尾款");
		return object;
	}
}</span>

案例 桥接模式

<span style="font-size:14px;">public interface Brand {
	void sale();
}
class Lenovo implements Brand {
	@Override
	public void sale() {
		System.out.println("销售联想电脑");
	}
}

class Dell implements Brand {
	@Override
	public void sale() {
		System.out.println("销售Dell电脑");
	}
	
}
}
 public class Computer2 {
	
	protected Brand brand;
	
	public Computer2(Brand b) {
		this.brand = b;
	}
	public void sale(){
		brand.sale();
	}
	
}

class Desktop2 extends Computer2 {

	public Desktop2(Brand b) {
		super(b);
	}
	@Override
	public void sale() {
		super.sale();
		System.out.println("销售台式机");
	}
}
class Laptop2 extends Computer2 {
	
	public Laptop2(Brand b) {
		super(b);
	}
	
	@Override
	public void sale() {
		super.sale();
		System.out.println("销售笔记本");
	}
}
public class Client {
	public static void main(String[] args) {
		//销售联想的笔记本电脑
		Computer2  c = new Laptop2(new Lenovo());
		c.sale();
		
		//销售神舟的台式机
		Computer2 c2 = new Desktop2(new Shenzhou());
		c2.sale();	
	}
}</span>

享元模式
内存属于稀缺资源，不要随便浪费， 如果有多个完全相同或相似的对象，我们可以通过享元模式，节省内存


核心：
   享元模式以共享的方式高效地支持大量细粒度对象的重用
   享元对象能做到共享的关键是区分了内部状态和外部状态
      内部状态：可以共享 不会随环境变化而改变
 外部状态：不可以共享，会随环境变化而改变




优点：减少内存中对象的数量
      相同或相似对象内存中只存一份， 极大的节约资源，提高系统性能
      外部状态相对独立  不影响内部状态
缺点
     模式较复杂， 使程序逻辑复杂化
     为了节省内存 共享了内部状态 分离出外部状态，而读取外部状态使时间变长，用时间换取了空间  

案例 享元模式

<span style="font-size:14px;">public class Client {
	public static void main(String[] args) {
		ChessFlyWeight chess1 = ChessFlyWeightFactory.getChess("黑色");
		ChessFlyWeight chess2 = ChessFlyWeightFactory.getChess("黑色");
		System.out.println(chess1);
		System.out.println(chess2);
		
		System.out.println("增加外部状态的处理===========");
		chess1.display(new Coordinate(10, 10));
		chess2.display(new Coordinate(20, 20));
	}
}
public class Coordinate {
	private int x,y;
	public Coordinate(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
}

public interface ChessFlyWeight {
	void setColor(String c);
	String getColor();
	void display(Coordinate c);
}


class ConcreteChess implements ChessFlyWeight {
	private String color;
	public ConcreteChess(String color) {
		super();
		this.color = color;
	}
	@Override
	public void display(Coordinate c) {
		System.out.println("棋子颜色："+color);
		System.out.println("棋子位置："+c.getX()+"----"+c.getY());
	}
	@Override
	public String getColor() {
		return color;
	}
	@Override
	public void setColor(String c) {
		this.color = c;
	}
}  
public class ChessFlyWeightFactory {
	//享元池
	private static Map<String,ChessFlyWeight> map = new HashMap<String, ChessFlyWeight>();
	public static ChessFlyWeight  getChess(String color){
		if(map.get(color)!=null){
			return map.get(color);
		}else{
			ChessFlyWeight cfw = new ConcreteChess(color);
			map.put(color, cfw);
			return cfw;
		}	
	}
}</span>

使用组合模式的场景：
 把部分和整体的关系用树形结构来表示， 从而使客户端可以使用统一的方式处理部分对象和整体对象
组合模型核心：
  抽象构件角色：定义了叶子和容器构件的共同点
  叶子构件角色：无子节点
  容器构件角色：有容器特征 可以包含子节点
  


开发中的应用场景
 操作系统的资源管理器
 GUI中的容器层次图
 XML文件解析
 OA系统中，组织结构的处理
 Junit单元测试框架  
 

案例 组合模式  非常适合处理树形结构

 public interface AbstractFile {
	void killVirus();  //杀毒
}
class ImageFile implements AbstractFile {
	private String name;
	public ImageFile(String name) {
		super();
		this.name = name;
	}
	@Override
	public void killVirus() {
		System.out.println("---图像文件："+name+",进行查杀！");
	}
}
class TextFile implements AbstractFile {
	private String name;
	public TextFile(String name) {
		super();
		this.name = name;
	}
	@Override
	public void killVirus() {
		System.out.println("---文本文件："+name+",进行查杀！");
	}
}
class VideoFile implements AbstractFile {
	private String name;
	public VideoFile(String name) {
		super();
		this.name = name;
	}
	@Override
	public void killVirus() {
		System.out.println("---视频文件："+name+",进行查杀！");
	}
}
class Folder implements AbstractFile {
	private String name;
	//定义容器，用来存放本容器构建下的子节点
	private List<AbstractFile> list = new ArrayList<AbstractFile>();
	public Folder(String name) {
		super();
		this.name = name;
	}
	public void add(AbstractFile file){
		list.add(file);
	}
	public void remove(AbstractFile file){
		list.remove(file);
	}
	public AbstractFile getChild(int index){
		return list.get(index);
	}
	@Override
	public void killVirus() {
		System.out.println("---文件夹："+name+",进行查杀");
		for (AbstractFile file : list) {
			file.killVirus();
		}
	}
}
public class Client {
	public static void main(String[] args) {
		AbstractFile f2,f3,f4,f5;
		Folder f1 = new Folder("我的收藏");
		
		f2 = new ImageFile("老高的大头像.jpg");
		f3 = new TextFile("Hello.txt");
		f1.add(f2);
		f1.add(f3);
		
		Folder f11 = new Folder("电影");
		f4 = new VideoFile("笑傲江湖.avi");
		f5 = new VideoFile("神雕侠侣.avi");
		f11.add(f4);
		f11.add(f5);
		f1.add(f11);
//		f2.killVirus();
		f1.killVirus();
	}
}

案例 装饰器模式

动态的为一个对象增加新的功能
 是一种代替继承的技术，无需通过继承增加子类就能扩张对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀

public interface ICar {
	void move();
}
//ConcreteComponent 具体构件角色(真实对象)
class Car implements ICar {
	@Override
	public void move() {
		System.out.println("陆地上跑！");
	}
}

//Decorator装饰角色
class SuperCar implements ICar {
	protected ICar car;
	public SuperCar(ICar car) {
		super();
		this.car = car;
	}

	@Override
	public void move() {
		car.move();
	}
}
//ConcreteDecorator具体装饰角色
class FlyCar extends SuperCar {

	public FlyCar(ICar car) {
		super(car);
	}
	
	public void fly(){
		System.out.println("天上飞！");
	}

	@Override
	public void move() {
		super.move();
		fly();
	}
	
}
//ConcreteDecorator具体装饰角色
class WaterCar extends SuperCar {
	
	public WaterCar(ICar car) {
		super(car);
	}
	public void swim(){
		System.out.println("水上游！");
	}
	@Override
	public void move() {
		super.move();
		swim();
	}
}
//ConcreteDecorator具体装饰角色
class AICar extends SuperCar {
	public AICar(ICar car) {
		super(car);
	}
	public void autoMove(){
		System.out.println("自动跑！");
	}
	@Override
	public void move() {
		super.move();
		autoMove();
	}
}
public class Client {
	public static void main(String[] args) {
		Car car  = new Car();
		car.move();
		System.out.println("增加新的功能，飞行----------");
		FlyCar flycar = new FlyCar(car);
		flycar.move();
		System.out.println("增加新的功能，水里游---------");
		WaterCar  waterCar = new WaterCar(car);
		waterCar.move();
		System.out.println("增加两个新的功能，飞行，水里游-------");
		WaterCar waterCar2 = new WaterCar(new FlyCar(car));
		waterCar2.move();
//		Reader r = new BufferedReader(new InputStreamReader(new FileInputStream(new File("d:/a.txt"))));
	}
}

案例 外观模式

    一个软件实体应尽可能少的与其他实体发生相互作用
    为子系统提供统一的入口，分装子系统的复杂性 便于客户端调用