策略模式Strategy

首先说一下开闭原则：对拓展放开，对修改关闭。
灵活是程序的必要条件，也就是说处理同一件事情，怎样更加全面，更加灵活，实现高内聚，低耦合。
策略模式：
多个对象处理一个请求，选择最合适的策略。就好像你找对象，在人群中就是因为她多看了你一眼~~~
举例说明：
对象进行比较。
1.假如几个集合里面有N个对象，我们按照对象的年龄排序，被排序的类实现Comparable接口 重写CompareTo方法定义比较规则。

1.创建类实现Comparable接口，泛型写类
	public class Person implements Comparable<Person> {
2.在类里面重写comparableTo
	public int compareTo(Person o) {
			return this.age - o.age;
		}
 重写toString方便遍历
3.测试：
  public class StudentTest {
	public static void main(String[] args) {
		Person[] a = new Person[4];
		a[0] = new Person(10, "曹操", "男", 2, 91);
		a[1] = new Person(13, "刘备", "男", 4, 92);
		a[2] = new Person(19, "孙权", "男", 3, 90);
		a[3] = new Person(9, "许褚", "男", 1, 82);
		//请注意，此时是一个参数
		Arrays.sort(a); 
		for (Person person : a) {
			System.out.println(person);
		}
	}
}

这种实现方式可以完成对象的比较并排序，但是缺点是耦合度太高，假设我现在换成序号排序，又要回到这个类中，重新定义比较规则。怎么解决呢？=====》比较器

和Compareble不同的是，比较器可以直接采用匿名内部类的形式，直接在sort方法中新增比较规则，很灵活，如果按照序号排序，直接修改方法中的比较规则即可。

1.创建person类，创建成员，重写toString方法，以便遍历
2.测试类：
 public class PersonTest {
	public static void main(String[] args) {

		Person[] p = new Person[4];
	
		p[0] = new Person("曹操", 20, 99, 1, "男");
		p[1] = new Person("孫權", 18, 90, 4, "男");
		p[2] = new Person("劉備", 28, 91, 2, "男");
		p[3] = new Person("關羽", 19, 89, 3, "男");
		//这里采用匿名内部类的形式，省去了实现类的步骤。
		Arrays.sort(p, new Comparator<Person>() {
			public int compare(Person o1, Person o2) {
			//升序反之降序
				return o1.getAge() - o2.getAge();
			}
		});
		for (Person person : p) {
			System.out.println(person);
		}
	}
}

匿名内部类(匿名内部类的本质是对象)直接定义比较规则。灵活，对象里的属性灵活定义，Comparable是写死在实现类的ComparaTo方法里，只能实现单一的比较。
注意:集合的比较底层也是转换成对象数组来比较.