设计模式——第八次作业代理模式、外观模式、适配器模式

代理模式——送花代码实现 为其他对象提供一种代理以控制（隔离，使用接口）对这个对象的访问

模式一：无代理模式

public class Main4 {
	public static void main(String[] args) {
		SchoolGirl jj=new SchoolGirl();
		jj.setName("李娇娇");
		Pursuit zz=new Pursuit(jj);
		zz.GiveDolls();
		zz.GiveFlowers();
		zz.GiveChocolate();
	}
}
//追求者
class Pursuit{
	SchoolGirl mm;
	public Pursuit(SchoolGirl mm) {
		this.mm=mm;
	}
	public void GiveDolls() {
		System.out.println(mm.getName()+"送你洋娃娃");
	}
	public void GiveFlowers() {
		System.out.println(mm.getName()+"送你花");
	}
	public void GiveChocolate() {
		System.out.println(mm.getName()+"送你巧克力");
	}
}
//被追求者
class SchoolGirl{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String value){
		name=value;
	}
}

模式二：代理模式

public class Main4 {
	public static void main(String[] args) {
		SchoolGirl jj=new SchoolGirl();
		jj.setName("李娇娇");
		Proxy dd=new Proxy(jj);
		dd.GiveDolls();
		dd.GiveFlowers();
		dd.GiveChocolate();
	}
}
//被追求者
class SchoolGirl{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String value){
		name=value;
	}
}
//代理
class Proxy{
	SchoolGirl mm;
	public Proxy(SchoolGirl mm) {
		this.mm=mm;
	}
	public void GiveDolls() {
		System.out.println(mm.getName()+"送你洋娃娃");
	}
	public void GiveFlowers() {
		System.out.println(mm.getName()+"送你花");
	}
	public void GiveChocolate() {
		System.out.println(mm.getName()+"送你巧克力");
	}
}

模式三：接口实现

public class Main4 {
	public static void main(String[] args) {
		SchoolGirl jj=new SchoolGirl();
		jj.setName("李娇娇");
		Proxy dd=new Proxy(jj);
		dd.GiveDolls();
		dd.GiveFlowers();
		dd.GiveChocolate();
	}
}
//被追求者
class SchoolGirl{
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String value){
		name=value;
	}
}
interface IGiveGift{
	void GiveDolls();
	void GiveFlowers();
	void GiveChocolate();
}
//追求者实现送礼物接口
class Pursuit implements IGiveGift{
	SchoolGirl mm;
	public Pursuit(SchoolGirl mm) {
		this.mm=mm;
	}
	public void GiveDolls() {
		System.out.println(mm.getName()+"送你洋娃娃");
	}
	public void GiveFlowers() {
		System.out.println(mm.getName()+"送你花");
	}
	public void GiveChocolate() {
		System.out.println(mm.getName()+"送你巧克力");
	}
}
//代理实现送礼物接口
class Proxy implements IGiveGift{
	Pursuit  gg;
	public Proxy(SchoolGirl mm) {
		gg=new Pursuit(mm);
	}
	public void GiveDolls() {
		gg.GiveDolls();
	}
	public void GiveFlowers() {
		gg.GiveFlowers();
	}
	public void GiveChocolate() {
		gg.GiveChocolate();
	}
}

模式四：真正的代理模式实现

public class Main4 {
	public static void main(String[] args) {
		Proxy px = new Proxy();
		px.Request();
	}
}

abstract class Subject {
	public abstract void Request();
}

class RealSubject extends Subject {
	public void Request() {
		System.out.println("真实的请求");
	}
}

class Proxy extends Subject {
	RealSubject rs; // 真实实体
	public void Request() {
		if (rs == null) {
			rs = new RealSubject();
		}
		rs.Request();
	}
}

外观模式——股票投资

外观模式：为子系统中的一组接口提供一个一致的界面，
此模式定义了一个高层接口，这个接口是的这一子系统更加容易使用。
在外观模式中，通常只需要一个外观类，并且此外观类只有一个实例，换言之它是一个单例类。
当然这并不意味着在整个系统旦只能有一个外观类，而仅仅是说对每一个子系统只有一个外观类。
或者说，如果一个系统有好几个子系统的话，每一个子系统有一个外观类，整个系统可以有数个外观类。

public class Main4 {
	public static void main(String[] args) {
		Fund jin = new Fund();
		jin.BuyFund();
		jin.SellFund();
	}
}

class Stock1 {
	// 买股票
	public void Sell() {
		System.out.println("股票1卖出");
	}

	// 卖股票
	public void Buy() {
		System.out.println("股票1买入");
	}
}

class Stock2 {
	// 买股票
	public void Sell() {
		System.out.println("股票2卖出");
	}

	// 卖股票
	public void Buy() {
		System.out.println("股票2买入");
	}
}

class Fund {
	Stock1 gu1;
	Stock2 gu2;

	public Fund() {
		gu1 = new Stock1();
		gu2 = new Stock2();
	}

	public void BuyFund() {
		gu1.Buy();
		gu2.Buy();
	}

	public void SellFund() {
		gu1.Sell();
		gu2.Sell();
	}
}

外观模式

public class Main4 {
	public static void main(String[] args) {
		Facade fa=new Facade();
		fa.MethodA();
		fa.MethodB();
	}
}

class SubSystemOne {
	public void MethodOne() {
		System.out.println("子系统方法一");
	}
}

class SubSystemTwo {
	public void MethodTwo() {
		System.out.println("子系统方法二");
	}
}

class SubSystemThree {
	public void MethodThree() {
		System.out.println("子系统方法三");
	}
}

class SubSystemFour {
	public void MethodFour() {
		System.out.println("子系统方法四");
	}
}

//外观类
class Facade {
	SubSystemOne one;
	SubSystemTwo two;
	SubSystemThree three;
	SubSystemFour four;
	public Facade() {
		one=new SubSystemOne();
		two=new SubSystemTwo();
		three=new SubSystemThree();
		four=new SubSystemFour();
	}
	public void MethodA() {
		System.out.println("\n方法组A()---");
		one.MethodOne();
		two.MethodTwo();
		four.MethodFour();
	}
	public void MethodB() {
		System.out.println("\n方法组B()---");
		two.MethodTwo();
		three.MethodThree();
	}
}

/*

适配器模式：把一个类的接口变换成客户端所期待的另一个接口， 从而使原本接口不匹配而无法在一起工作的两个类能够一起工作。

适配器adapter适配者adaptee：霄要适配的类
1、类运配器模式：适配器与适配者之间是继承（或实现）关系；
2、对象运配器模式：运配器与运配者之间是关联关系。
主要讲解对象适配器模式

public class Main4 {
	public static void main(String[] args) {
		Target t=new Adapter();
		t.Request();
	}
}
//客户所期待的接口，目标可以是具体的或抽次昂的类，也可以是接口
abstract class Target{
	public  abstract void Request();
}
//需要适配的类
class Adapt{
	public void SpecificRequest() {
		System.out.println("特殊请求");
	}
}
class Adapter extends Target{
	private Adapt ad=new Adapt();
	public void Request() {
		ad.SpecificRequest();
		
	}
}

客户端需妥调用requestO方法，而运配者类Adaptee没有该方法，但是客户端需要的是它所提供的SpecificRequestO方法。
为了使客户能够使用Adaptee类，提供一个中间不节：Adapter类，Adapter类实现了Target接口，并继承Adaptee，
Adapter类的Request方法重新封装了Adaptee的SpecificRequest方法，实现了适配的目的。

public class Main4 {
	public static void main(String[] args) {
		ITarget t=new Adapter();
		t.Request();
	}
}
interface ITarget{
	void Request();
}
class Adaptee{
	public void SpecificRequest() {
		System.out.println("特殊请求");
	}
}
class Adapter extends Adaptee implements ITarget{
	public void Request() {
		this.SpecificRequest();
	}
}

**Adapter模式主要应用于“希望复用一些现存的类，但是接口又与复用环境要求不一致的情况”，在遗留代码复用、类库迁移等方面非常有用。

• Adapter模式有对象运配器和类运配器两种形式的实现结构
• 类运配器采用“多继承”的实现方式，带来了不良的高祸合，所以一般不推荐使用。
• 对象适配器采用“对象组合或关联”的方式，更符合松耦合精神。**