java策略设计模式

1.概念：举个例子讲解，比如写一个person，有一个show（）方法，她之前是一个丑女，所以去整容了，整容前，-100，整容后，+100，

现在要用编程实现这个例子。

那么普通的想法就是写一个person类，然后整容前，整容后分别写两个子类继承它，并实现不同的show（）方法。

代码如下：

public class InterfaceAppDemo1{
	public static void main(String[] args){
		Person p = new BeforeGongPerson("美眉");
		System.out.println("-----整容前-----");
		
		p.show();

		p = new AfterGongPerson("美眉");
		System.out.println("-----整容后-----");
		
		p.show();
	}
}

abstract class Person{
	private String name;
	
	public Person(String name){
		this.name = name;
	}

	//这个方法的实现是变化的
	abstract public void show();
}

class BeforeGongPerson extends Person{
	public BeforeGongPerson(String name){//重复了
		super(name);
	}
	public void show(){
		System.out.println("漂亮指数：-100!");
	}
}

class AfterGongPerson extends Person{
	public AfterGongPerson(String name){//重复了
		super(name);
	}
	public void show(){
		System.out.println("漂亮指数：+100!");
	}
}

那么这么设计有问题的，因为这只是一个人，只不过show（）这个方法不一样，不应该用两个子类对象去重写它。（逻辑上有问题）

代码其实是有冗余的。

我们仔细思考这个问题，其实只有一个show（）方法是不同的，因此可以把这个方法抽象出来作为一个接口，并将它作为person

类的一个属性。只需要在show方法中实现不同的属性就行了。

1，show（）接口：

//把展示的行为抽象出一个接口
interface Ishow{
	public void show();
}

2，实现接口：

class BeforeGong implements Ishow{
	public void show(){
		System.out.println("漂亮指数：-100!");
	}
}

class AfterGong implements Ishow{
	public void show(){
		System.out.println("漂亮指数：+100!");
	}
}

3，写人的类，在其中把接口作为类的一个属性。提供不同的实现。

class Person{
	private String name;
	
	//把可变化的行为抽象出来，定义成接口，并提供不同的实现

	private Ishow ishow;//把接口作为类中的一个属性(组合)

	public void setIshow(Ishow ishow){
		this.ishow = ishow;
	}

	public Person(String name){
		this.name = name;
	}

	//这个方法的实现是变化的
	public void show(){
		ishow.show();
	}
}

4，main方法中调用：在这里只产生了一个Person对象，通过她的setIshow（）方法，将不同的状态（方法实现）展现出来。

public class InterfaceAppDemo{
	public static void main(String[] args){
		Person p = new Person("美眉");
		System.out.println("-----整容前-----");
		p.setIshow(new BeforeGong());
		p.show();
		System.out.println("-----整容后-----");
		p.setIshow(new AfterGong());
		p.show();
	}
}