说明：本文版本有二个版本，每个版本都不断深化的
一、模式的提出
它定义了算法家族，分别封装起来， 让他们之间可以互相替换，此模式让算法变化，不会影响到使用算法的客户。
当不同的行为堆砌在一个类中时，就很难避免使用条件语句来选择合适的行为。将这些行为封装在一个个独立的Strategy类中，可以在使用这些行为的类消除条件语句。策略模式是一种定义一系列算法的方法，从概念上来看，所有这些算法的完成的都是相同的工作，只是实现不同，它可以以相同的方式调用所有的算法，减少了各种算法类与使用算法类之间的耦合。
二、业务背景
对狗和猫相关信息如何进行排序？
三、UML图
四、代码详解
所有类型比较的公共接口
package cn.com.hewen.strategy;
/**
* 所有类型排序的一个公共接口，一个类型要进行排序必须要实现该接口，
* 比如：对猫的身高和狗的食量进行排序，这两个类都要实现该接口
* @author Administrator
*
*/
public interface Comparable {
public int compareTo(Object o);
}
对狗食量进行排序
package cn.com.hewen.strategy;
/**
* 对狗的食量大小进行比较，模仿JDK实现comparable接口
* @author Administrator
*
*/
public class Dog implements Comparable{
private int height;
private int foodWeight;
public Dog(int height, int foodWeight) {
this.height = height;
this.foodWeight = foodWeight;
}
/**
* 狗的食量进行比较
*/
public int compareTo(Object o) {
if(o instanceof Dog){
Dog dog=(Dog)o;
if(this.foodWeight>dog.foodWeight)
return 1;
}
return 0;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getFoodWeight() {
return foodWeight;
}
public void setFoodWeight(int foodWeight) {
this.foodWeight = foodWeight;
}
@Override
public String toString() {
return "狗的食量排列顺序是"+this.foodWeight+"|"+this.height;
}
}
猫的身高进行排序
package cn.com.hewen.strategy;
public class Cat implements Comparable{
private int height;//猫的高度
private int weight;//猫的重量
public Cat(int height, int weight) {
this.height = height;
this.weight = weight;
}
/**
* Object 对象进行比较猫的大小
* return 如果本对象大于比较的对象的高度就返回1
*/
public int compareTo(Object o) {
if (o instanceof Cat) {//对象转化的时候最好判断一下是否是该对象
Cat cat = (Cat) o;
if (this.height > cat.height)
return 1;
}
return 0;
}
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 String toString() {
return "猫的高度排列顺序："+this.height+"|"+this.weight;
}
}
冒泡排序的类
package cn.com.hewen.strategy;
/**
* 大小的比较进行冒泡排序
* @author Administrator
*
*/
public class DateSorter {
/**
* 冒泡算法
* @param a
*/
public static void sort(Comparable[] a) {
for(int i=a.length;i>0;i--)
for(int j=0;j<a.length-1;j++){
if(a[j].compareTo(a[j+1])==1)
swap(a,j,j+1);
}
}
/**
* 数组的顺序换顺序
* @param a 数组
* @param x 数组元素
* @param y 数组元素
*/
private static void swap(Object[] a, int x, int y) {
Object temp=a[x];
a[x]=a[y];
a[y]= temp;
}
/**
* 打印数组中的相关信息
* @param a数组
*/
public static void p(Object[] a) {
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
客户端的代码
package cn.com.hewen.strategy;
/**
* 排序口诀
* 冒择插入兮（希）快归堆
* @author Administrator
*
*/
public class Test {
public static void main(String[] args){
// int[] a={9,4,7,5,1,6};
Comparable[] a={new Cat(9,9),new Cat(4,4),new Cat(7,7),new Cat(1,1),new Cat(5,5)};
// Comparable[] a={new Dog(20,20),new Dog(3,3),new Dog(32,32),new Dog(7,7),new Dog(17,17)};
DateSorter.sort(a);
DateSorter.p(a);
}
}
运行的结果
猫的高度排列顺序：1|1 猫的高度排列顺序：4|4 猫的高度排列顺序：5|5 猫的高度排列顺序：7|7 猫的高度排列顺序：9|9
业务背景添加新的需求：如果需要对猫的身高、猫的体重、狗的身高、狗的食量进行排序那应该如何处理这样的变化？
解决方案：添加一个简单的工厂方法，来判断用户是根据什么信息排序？
代码详解
新添加一个接口：什么类型具体信息的比较的通用接口
package cn.com.hewen.strategy;
/**
* 什么类型具体信息的比较的通用接口，
* 如要实现按照猫的体重进行排序必须要实现给接口
* @author Administrator
*
*/
public interface Comparator {
public int compare(Object o1, Object o2);
}
所有具体信息的比较类型排序必须实现Comparator
package cn.com.hewen.strategy;
/**
* 按照猫的身高进行比较
* @author Administrator
*
*/
public class CatHeightCompare implements Comparator {
public int compare(Object o1, Object o2) {
if(o1 instanceof Cat && o2 instanceof Cat){
Cat cat1=(Cat)o1;
Cat cat2=(Cat)o2;
if(cat1.getHeight()>cat2.getHeight())
return 1;
}
return 0;
}
}
package cn.com.hewen.strategy;
/**
* 按照猫的重量进行排序
* @author Administrator
*
*/
public class CatWeightCompare implements Comparator {
public int compare(Object o1, Object o2) {
if(o1 instanceof Cat && o2 instanceof Cat){
Cat cat1=(Cat)o1;
Cat cat2=(Cat)o2;
if(cat1.getWeight()>cat2.getWeight())
return 1;
}
return 0;
}
}
package cn.com.hewen.strategy;
public class DogFoodCompare implements Comparator{
public int compare(Object o1, Object o2) {
if(o1 instanceof Dog && o2 instanceof Dog){
Dog dog1=(Dog)o1;
Dog dog2=(Dog)o2;
if(dog1.getFoodWeight()>dog2.getFoodWeight())
return 1;
}
return 0;
}
}
什么类型的比较的通用接口，定义一个类型的排序派实现该接口
package cn.com.hewen.strategy;
/**
* 什么类型的比较的通用接口，
* 定义一个类型的排序派实现该接口
* @author Administrator
*
*/
public interface Comparable {
public int compareTo(Object o1);
}
实现一个类型的排序的该接口
package cn.com.hewen.strategy;
public class Cat implements Comparable{
private int height;
private int weight;
private String compareName;
/**
* 客户调用的构造函数
* @param height
* @param weight
* @param compareName 按照猫的什么信息进行比较
*/
public Cat(int height, int weight,String compareName) {
this.height = height;
this.weight = weight;
this.compareName=compareName;
}
public int compareTo(Object o) {
/**
* 这个按什么类型进行比较的判断就转交给比较工厂做判断
*/
return CompareFactory.getCompareTypeClass(compareName).compare(this,o);
}
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 String toString() {
return compareName+this.height+"|"+this.weight;
}
public String getCompareName() {
return compareName;
}
public void setCompareName(String compareName) {
this.compareName = compareName;
}
}
package cn.com.hewen.strategy;
public class Dog implements Comparable{
private int height;//狗的身高
private int foodWeight;//狗的食量
private String compareName;//按照什么信息进行排序
public Dog(int height, int foodWeight,String compareName) {
this.height = height;
this.foodWeight = foodWeight;
this.compareName=compareName;
}
public int compareTo(Object o) {
/*
* 这个按什么类型进行比较的判断就转交给比较工厂做判断
*/
return CompareFactory.getCompareTypeClass(compareName).compare(this,o);
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public int getFoodWeight() {
return foodWeight;
}
public void setFoodWeight(int foodWeight) {
this.foodWeight = foodWeight;
}
@Override
public String toString() {
return compareName+this.foodWeight+"|"+this.height;
}
public String getCompareName() {
return compareName;
}
public void setCompareName(String compareName) {
this.compareName = compareName;
}
}
一个通用的冒泡排序算法
package cn.com.hewen.strategy;
public class DateSorter {
public static void sort(Comparable[] a) {
for(int i=a.length;i>0;i--)
for(int j=0;j<a.length-1;j++){
if(a[j].compareTo(a[j+1])==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]+" ");
}
}
}
根据客户的需要，什么类型是按照什么信息(compareName)进行排序
package cn.com.hewen.strategy;
/**
* 根据客户的需要，什么类型是按照什么信息(compareName)进行排序
* 比如 按照猫的体重还是按照猫的身高进行排序
* @author Administrator
*
*/
public class CompareFactory{
private static Comparator comparator=null;//具体类型的具体信息比较器的接口
public static Comparator getCompareTypeClass(String compareName){
if(compareName.equals("按猫的重量")){
return comparator=new CatWeightCompare();
}else if(compareName.equals("按猫的身高")){
return comparator=new CatHeightCompare();
}if(compareName.equals("按狗的食量")){
return comparator=new DogFoodCompare();
}
return null;
}
}
客户测试类
package cn.com.hewen.strategy;
/**
* 排序口诀
* 冒择插入兮（希）快归堆
* @author Administrator
*
*/
public class Test {
public static void main(String[] args){
// int[] a={9,4,7,5,1,6};
/*高度 ，重量*/
Comparable[] a={new Cat(9,3,"按猫的重量"),new Cat(4,2,"按猫的重量"),
new Cat(7,1,"按猫的重量"),new Cat(1,4,"按猫的重量"),new Cat(5,9,"按猫的重量")};
// Comparable[] a={new Dog(20,20,"按狗的食量"),new Dog(3,3,"按狗的食量"),
// new Dog(32,32,"按狗的食量"),new Dog(7,7,"按狗的食量"),new Dog(17,17,"按狗的食量")};
DateSorter.sort(a);
DateSorter.p(a);
}
}
按猫的重量7|1 按猫的重量4|2 按猫的重量9|3 按猫的重量1|4 按猫的重量5|9
分享到：
相关推荐
策略模式结合模板方法模式的设计思路 策略模式结合模板方法模式是策略模式的一种变形，目的是为了解决策略模式中的一些共性问题。在策略模式中，经常会出现这样一种情况，就是发现这一系列算法的实现上存在公共功能...
SpringBoot结合策略模式实战套路 策略模式是一种常用的设计模式，它可以使我们的代码更加灵活、可维护和可扩展。在SpringBoot项目中，策略模式可以与依赖注入机制相结合，实现更加灵活的业务逻辑处理。在本文中，...
设计模式之策略模式 鸭子问题 策略模式是一种经典的设计模式，通过鸭子问题，可以让学习者更好地了解设计模式的概念和实现。策略模式的主要思想是定义一系列的算法，并将每一个算法封装起来，使它们可以相互替换。...
桥接模式和策略模式是软件设计模式中的两种重要模式，它们在实现上有着相似之处，但各自的应用场景和设计理念有所不同。下面将详细阐述这两种模式的特点、区别以及它们在实际编程中的应用。 首先，桥接模式（Bridge...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通过定义一系列的算法，并将每一个算法封装起来，使它们可以相互替换，让算法独立于使用它的客户而变化。这种模式通常用于处理多种...
在Spring框架中，策略模式是一种常见的设计模式，它允许我们定义一组可互换的策略，这些策略可以在运行时根据需求动态选择。这篇文章将深入探讨如何在Spring中运用策略模式，并结合源码分析其工作原理。 策略模式的...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通常用于将算法封装到不同的类中，使得可以根据需要动态选择并应用这些算法。本示例将详细介绍如何通过两种方法实现策略模式：一种...
本文将探讨三个重要的设计模式：抽象工厂模式、工厂方法模式以及策略模式，并结合一个实际的场景——手机加工厂，来具体阐述它们的应用。 首先，我们来看**抽象工厂模式**。这个模式主要用于创建相关或依赖对象的...
Java 设计模式之策略模式与状态模式 策略模式是 Java 中的一种设计模式，它主要用于解决系统与第三方接口进行数据交互的问题。当系统需要与多种格式的数据进行交互时，使用策略模式可以很好地解决这个问题。例如，...
在"策略模式封装的几个加密解密算法源码"中，我们主要关注的是如何使用策略模式来封装常见的加密解密算法，如BASE64和MD5。 1. **BASE64编码**：BASE64是一种用于将二进制数据编码为ASCII字符的编码方式，以便在...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同条件或选择执行不同算法的情况。策略模式提供了一种将算法封装到独立可互换的策略对象中，使得算法的变化独立...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同的条件或场景来执行不同算法的情况。策略模式就是为了解决这类问题而提出的，它将每种算法封装到具有共同接口...
策略模式和代理模式是设计模式中的两种常见模式，它们在软件开发中扮演着重要的角色，尤其是在JavaScript中，这两种模式提供了更加灵活和可维护的代码结构。 策略模式（Strategy Pattern）是一种行为设计模式，它...
策略模式（Template模式） 策略模式是设计模式中的一种 객체行为型模式，它定义了一系列算法，封装每一个算法，并使它们可以互相替换。策略模式使得算法可以独立于使用它的客户而变化。 概述 在软件开发中，经常...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式主要通过定义一系列的算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户而变化。 首先，策略模式的...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通常涉及接口或抽象类的实现，允许程序在运行时选择并应用不同的算法或策略。这种模式的核心在于将算法封装到独立的可互换的策略中...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式允许我们定义一组算法或策略，并将每个策略封装为一个类，使得它们可以互换，而不会影响到客户端代码。这种模式的核心在于"策略"，...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在策略模式中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为模式。 策略模式定义了一系列的算法，并将每一个算法封装起来，使...
策略模式的设计与实现 策略模式是一种常用的设计模式，它定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。策略模式的主要优点是它可以使得算法的变化独立于使用算法...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件工程中，当一个系统需要在不同时间执行不同的算法或者行为时，策略模式就显得尤为有用。这种模式将算法封装到独立的可相互替换的策略类中，使得...