Java设计模式——Comparable接口&&Comparator（CC系）策略模式的应用[续]
2017-03-04 17:24
459 查看
转自：http://blog.csdn.net/acmman/article/details/46634565
现在我们对其进行实现。大家想想看，我们想对两个对象比较大小的方式进行拓展，这个方式就不能定义为具体的，要定义为抽象的，所以我们定义这样一个接口：
比较器Comparator.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
//interface类里面的方法默认都是public
public interface Comparator {
/*实现这个接口的对象使用这个方法进行比较时，
*返回1是比那个对象大，返回0是相等，返回-1是比那个对象小*/
int compare(Object o1,Object o2);
}
我们之前对狗进行的是利用高度进行排序，现在我们用其重量来比较大小。
我们重新创建一个类，叫做"狗的根据重量的比较器"，它去实现Comparator接口
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class DogWeightComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
Dog d1=(Dog)o1;
Dog d2=(Dog)o2;
if(d1.getWeight()>d2.getWeight()) return 1;
else if(d1.getWeight()<d2.getWeight()) return -1;
return 0;
}
}
对于狗来说，我们之前实现Comparable接口了，此时比较逻辑不要在comparaTo()方法中写死，我们在comparaTo()中new出一个DogWeightComparator比较器，来比较当前的对象和传进来的对象的大小。
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Dog implements Comparable{
//狗的身高
private int height;
//狗的体重
private int weight;
public Dog(int height, int weight) {
super();
this.height = height;
this.weight = weight;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public int compareTo(Object o) {
return new DogWeightComparator().compare(this, o);
}
@Override
public String toString() {
return this.getHeight()+"|"+this.getWeight();
}
}
这个时候你就会发现好处:假如我对重量比较不满意了，我可以换成new别的来实现别的比较方法。
我们最好设置一个成员变量，是比较器Comparator类型的，设好它的get和set方法，具体向里面放什么样的比较器，我们在comparaTo()方法中就引用什么样的比较器来比较大小。
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Dog implements Comparable{
//狗的身高
private int height;
//狗的体重
private int weight;
//比较器(默认指定DogWeightComparator)
private Comparator comparator=new DogWeightComparator();
public Dog(int height, int weight) {
super();
this.height = height;
this.weight = weight;
}
public Comparator getComparator() {
return comparator;
}
public void setComparator(Comparator comparator) {
this.comparator = comparator;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public int compareTo(Object o) {
return comparator.compare(this, o);
}
@Override
public String toString() {
return this.getHeight()+"|"+this.getWeight();
}
}
测试：
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Test {
public static void main(String[] args) {;
Dog[] dogs={new Dog(3,8),new Dog(5,4),new Dog(1,2)};
DataSorter.sort(dogs);
DataSorter.p(dogs);
}
}
结果:
1|2 5|4 3|8
我们发现使用狗的重量来排序了。
当我们使用新创建的Comparator接口的时候，你会发现世界又美好了一些，因为我写完一个Dog类之后我还可以跟着设置他们两个对象之间的比较方式，这样我们类的扩展能力就更强了。
大家仔细想想Comparable、Comparator接口与DataSorter和比较类Dog、Cat之间的关系，就会总结出Comparator接口出现的好处。
下一篇总结收尾。
转载请注明出处：http://blog.csdn.net/acmman/article/details/46634565
转自：http://blog.csdn.net/acmman/article/details/46634607
我们对之前的Dog和Dog的比较类DogWeightComparator的实现进行修改：
Dog.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Dog implements java.lang.Comparable<Dog>{
//狗的身高
private int height;
//狗的体重
private int weight;
//比较器(默认指定DogWeightComparator)
private java.util.Comparator<Dog> comparator=new DogWeightComparator();
public Dog(int height, int weight) {
super();
this.height = height;
this.weight = weight;
}
public java.util.Comparator getComparator() {
return comparator;
}
public void setComparator(java.util.Comparator comparator) {
this.comparator = comparator;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public int compareTo(Dog o) {
return comparator.compare(this, o);
}
@Override
public String toString() {
return this.getHeight()+"|"+this.getWeight();
}
}
DogWeightComparator.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class DogWeightComparator implements java.util.Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
Dog d1=(Dog)o1;
Dog d2=(Dog)o2;
if(d1.getWeight()>d2.getWeight()) return 1;
else if(d1.getWeight()<d2.getWeight()) return -1;
return 0;
}
}
DataSorter中的类型也要改成java.lang.Comparable
DataSorter.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class DataSorter {
public static void sort(Object[] a) {
for (int i = a.length; i >0; i--) {
for (int j = 0; j < i-1; j++) {
java.lang.Comparable o1=(java.lang.Comparable)a[j];
java.lang.Comparable o2=(java.lang.Comparable)a[j+1];
if(o1.compareTo(o2)==1){
swap(a,j,j+1);
}
}
}
}
private static void swap(Object[] a, int x, int y) {
Object temp=a[x];
a[x]=a[y];
a[y]=temp;
}
public static void p(Object[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
}
}
测试(按重量排序)：
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Test {
public static void main(String[] args) {
//int[] a={9,5,3,7,1};
Dog[] dogs={new Dog(3,8),new Dog(5,4),new Dog(1,2)};
DataSorter.sort(dogs);
DataSorter.p(dogs);
/*
Cat[] cats={new Cat(21),new Cat(15),new Cat(9)};
DataSorter.sort(cats);
DataSorter.p(cats);*/
}
}
测试结果：
1|2 5|4 3|8
我们探讨了JDK的Comparable和Comparator接口的使用，是不是和我们自己写的那个使用方法和效果完全一样(唯一区别就是JDK的接口使用了泛型，泛型的好处就是不用再强制转换了)？说明我们已经成功模拟出了JDK的Comparable和Comparator接口。
再来看，刚刚我们自己写了sort方法，其实我们也不用写这个方法，可以使用java.Util.Arrays.sort(a);进行排序，前提是只要实现了java.lang.Comparable接口即可。
测试：
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Test {
public static void main(String[] args) {
//int[] a={9,5,3,7,1};
Dog[] dogs={new Dog(3,8),new Dog(5,4),new Dog(1,2)};
java.util.Arrays.sort(dogs);
DataSorter.p(dogs);
}
}
测试结果：
1|2 5|4 3|8
是不是也可以？当然可以
为什么说数据结构和算法在日常工作中不重要了，是因为这些东西在Java中已经给大家封装的很好了，大家只需要懂得原理，巧妙的去使用他们即可。
写了这些我们发现JDK中都有，是不是白写了？不是，写完Comparable和Comparator接口，我们就学习了策略模式，深入学习了Comparable和Comparator接口的设计模式。
那么什么是策略模式？在本例中就是：当进行比较大小的时候，定义一个策略的比较器，然后由具体的比较策略来决定到底谁大谁小。
作业:
封装一下商场的打折策略
现在商场都有许多打折活动，我们的打折策略不能写死，所以我们最好把打折策略定义成一个可以拓展的策略。
作业在以后总结总解答
转载请注明出处：http://blog.csdn.net/acmman/article/details/46634607
接着上一篇总结继续探讨。
之前我们的DataSorter的Sort方法虽然可以对任何实现了Comparable接口的对象进行排序，不过，麻烦事在于，这些对象实现的comparaTo方法只有一种实现，只能写一种，不能写太多，而且将来我想任意的扩展怎么计算两个对象谁大谁小的规范，这个时候这个类该如何设计呢？现在我们对其进行实现。大家想想看，我们想对两个对象比较大小的方式进行拓展，这个方式就不能定义为具体的，要定义为抽象的，所以我们定义这样一个接口：
比较器Comparator.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
//interface类里面的方法默认都是public
public interface Comparator {
/*实现这个接口的对象使用这个方法进行比较时，
*返回1是比那个对象大，返回0是相等，返回-1是比那个对象小*/
int compare(Object o1,Object o2);
}
我们之前对狗进行的是利用高度进行排序，现在我们用其重量来比较大小。
我们重新创建一个类，叫做"狗的根据重量的比较器"，它去实现Comparator接口
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class DogWeightComparator implements Comparator{
@Override
public int compare(Object o1, Object o2) {
Dog d1=(Dog)o1;
Dog d2=(Dog)o2;
if(d1.getWeight()>d2.getWeight()) return 1;
else if(d1.getWeight()<d2.getWeight()) return -1;
return 0;
}
}
对于狗来说，我们之前实现Comparable接口了，此时比较逻辑不要在comparaTo()方法中写死，我们在comparaTo()中new出一个DogWeightComparator比较器，来比较当前的对象和传进来的对象的大小。
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Dog implements Comparable{
//狗的身高
private int height;
//狗的体重
private int weight;
public Dog(int height, int weight) {
super();
this.height = height;
this.weight = weight;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public int compareTo(Object o) {
return new DogWeightComparator().compare(this, o);
}
@Override
public String toString() {
return this.getHeight()+"|"+this.getWeight();
}
}
这个时候你就会发现好处:假如我对重量比较不满意了，我可以换成new别的来实现别的比较方法。
我们最好设置一个成员变量，是比较器Comparator类型的，设好它的get和set方法，具体向里面放什么样的比较器，我们在comparaTo()方法中就引用什么样的比较器来比较大小。
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Dog implements Comparable{
//狗的身高
private int height;
//狗的体重
private int weight;
//比较器(默认指定DogWeightComparator)
private Comparator comparator=new DogWeightComparator();
public Dog(int height, int weight) {
super();
this.height = height;
this.weight = weight;
}
public Comparator getComparator() {
return comparator;
}
public void setComparator(Comparator comparator) {
this.comparator = comparator;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public int compareTo(Object o) {
return comparator.compare(this, o);
}
@Override
public String toString() {
return this.getHeight()+"|"+this.getWeight();
}
}
测试：
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Test {
public static void main(String[] args) {;
Dog[] dogs={new Dog(3,8),new Dog(5,4),new Dog(1,2)};
DataSorter.sort(dogs);
DataSorter.p(dogs);
}
}
结果:
1|2 5|4 3|8
我们发现使用狗的重量来排序了。
当我们使用新创建的Comparator接口的时候，你会发现世界又美好了一些，因为我写完一个Dog类之后我还可以跟着设置他们两个对象之间的比较方式，这样我们类的扩展能力就更强了。
大家仔细想想Comparable、Comparator接口与DataSorter和比较类Dog、Cat之间的关系，就会总结出Comparator接口出现的好处。
下一篇总结收尾。
转载请注明出处：http://blog.csdn.net/acmman/article/details/46634565
转自：http://blog.csdn.net/acmman/article/details/46634607
接着上边总结继续探讨。
我们之前用自己的方式来实现了JDK的Comparable和Comparator接口，我们下面来看看实际当中JDK给我们的Comparable和Comparator接口。我们对之前的Dog和Dog的比较类DogWeightComparator的实现进行修改：
Dog.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Dog implements java.lang.Comparable<Dog>{
//狗的身高
private int height;
//狗的体重
private int weight;
//比较器(默认指定DogWeightComparator)
private java.util.Comparator<Dog> comparator=new DogWeightComparator();
public Dog(int height, int weight) {
super();
this.height = height;
this.weight = weight;
}
public java.util.Comparator getComparator() {
return comparator;
}
public void setComparator(java.util.Comparator comparator) {
this.comparator = comparator;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getWeight() {
return weight;
}
public void setWeight(int weight) {
this.weight = weight;
}
@Override
public int compareTo(Dog o) {
return comparator.compare(this, o);
}
@Override
public String toString() {
return this.getHeight()+"|"+this.getWeight();
}
}
DogWeightComparator.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class DogWeightComparator implements java.util.Comparator<Dog>{
@Override
public int compare(Dog o1, Dog o2) {
Dog d1=(Dog)o1;
Dog d2=(Dog)o2;
if(d1.getWeight()>d2.getWeight()) return 1;
else if(d1.getWeight()<d2.getWeight()) return -1;
return 0;
}
}
DataSorter中的类型也要改成java.lang.Comparable
DataSorter.java:
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class DataSorter {
public static void sort(Object[] a) {
for (int i = a.length; i >0; i--) {
for (int j = 0; j < i-1; j++) {
java.lang.Comparable o1=(java.lang.Comparable)a[j];
java.lang.Comparable o2=(java.lang.Comparable)a[j+1];
if(o1.compareTo(o2)==1){
swap(a,j,j+1);
}
}
}
}
private static void swap(Object[] a, int x, int y) {
Object temp=a[x];
a[x]=a[y];
a[y]=temp;
}
public static void p(Object[] a) {
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]+" ");
}
System.out.println();
}
}
测试(按重量排序)：
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Test {
public static void main(String[] args) {
//int[] a={9,5,3,7,1};
Dog[] dogs={new Dog(3,8),new Dog(5,4),new Dog(1,2)};
DataSorter.sort(dogs);
DataSorter.p(dogs);
/*
Cat[] cats={new Cat(21),new Cat(15),new Cat(9)};
DataSorter.sort(cats);
DataSorter.p(cats);*/
}
}
测试结果：
1|2 5|4 3|8
我们探讨了JDK的Comparable和Comparator接口的使用，是不是和我们自己写的那个使用方法和效果完全一样(唯一区别就是JDK的接口使用了泛型，泛型的好处就是不用再强制转换了)？说明我们已经成功模拟出了JDK的Comparable和Comparator接口。
再来看，刚刚我们自己写了sort方法，其实我们也不用写这个方法，可以使用java.Util.Arrays.sort(a);进行排序，前提是只要实现了java.lang.Comparable接口即可。
测试：
[java] view
plain copy
package cn.edu.hpu.Strategy;
public class Test {
public static void main(String[] args) {
//int[] a={9,5,3,7,1};
Dog[] dogs={new Dog(3,8),new Dog(5,4),new Dog(1,2)};
java.util.Arrays.sort(dogs);
DataSorter.p(dogs);
}
}
测试结果：
1|2 5|4 3|8
是不是也可以？当然可以
为什么说数据结构和算法在日常工作中不重要了，是因为这些东西在Java中已经给大家封装的很好了，大家只需要懂得原理，巧妙的去使用他们即可。
写了这些我们发现JDK中都有，是不是白写了？不是，写完Comparable和Comparator接口，我们就学习了策略模式，深入学习了Comparable和Comparator接口的设计模式。
那么什么是策略模式？在本例中就是：当进行比较大小的时候，定义一个策略的比较器，然后由具体的比较策略来决定到底谁大谁小。
作业:
封装一下商场的打折策略
现在商场都有许多打折活动，我们的打折策略不能写死，所以我们最好把打折策略定义成一个可以拓展的策略。
作业在以后总结总解答
转载请注明出处：http://blog.csdn.net/acmman/article/details/46634607
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Java设计模式——Comparable接口&&Comparator（CC系）策略模式的应用
- JAVA设计模式(13) —<行为型>策略模式(strategy)
- JAVA设计模式-策略模式应用实例
- JAVA设计模式-策略模式应用实例
- Java中的DAO设计模式应用举例 ------> 来自Java WEB 开发实战经典
- JAVA设计模式-策略模式应用实例
- java之设计模式--->策略模式
- JAVA设计模式-策略模式应用实例
- JAVA设计模式-策略模式应用实例
- JAVA设计模式-策略模式应用实例
- JAVA设计模式-策略模式应用实例
- Java 接口应用案例 (策略设计模式使用)
- java设计模式之策略模式及项目中的应用
- JAVA设计模式-策略模式应用实例
- JAVA设计模式-策略模式应用实例
- java接口应用—策略设计模式
- JAVA设计模式 · 策略模式
- JAVA设计模式-策略模式应用实例
- JAVA设计模式-策略模式应用实例
- JAVA设计模式-策略模式应用实例