策略模式的定义：
定义了算法簇，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。
首先看策略模式的定义，
算法簇也就是一群实现了同一个接口的实现类，
让它们之间可以相互替换的意思也就是要针对接口编程，而不是针对类编程。
此模式让算法的变化独立于使用算法的客户是说，采用何种算法只取决于调用者。
现在说说例子：
一个格斗游戏，角色类Fighter可以使用很多武器，不同武器攻击力以及特殊效果不同，比如使用剑能有一定几率造成额外伤害，斧子有一定几率造成双倍伤害。如果不使用模式的情况下实现这个游戏的话,Fighter就应该有一些方法：attackWithSword()，attackWithAxe()。如果剑类武器又有：铁剑、霜之哀伤，又要为这两把剑写两个方法。如果有1000个武器呢？（当然实现这个的方法还有很多，尤其是笨方法很多。。。）
为了避免以上情况，我们定义一个接口：
package com.Weapon;
import com.fighter.Fighter;
public interface WeaponBehavior {
public void attackWithWeapon(Fighter fighter);
public String getName();
public void setName(String name);
}
让所有武器去实现这个接口，所有实现了这个接口的类，都叫算法簇。
现在，抽象类剑，实现了这个接口，这里剑是一个种类，而不是一个具体武器，所以是抽象类：
package com.Weapon;
import java.util.Random;
import com.fighter.Fighter;
//剑类武器有一定几率造成额外的伤害
public abstract class Sword implements WeaponBehavior {
// 普通伤害
int damage;
String name;
// 特殊攻击的伤害
int specialDamage;
// 特殊攻击的触发几率
int probability;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getDamage() {
return damage;
}
public void setDamage(int damage) {
this.damage = damage;
}
@Override
public void attackWithWeapon(Fighter fighter) {
normalAttack(fighter);
specialAttack(fighter);
}
protected void normalAttack(Fighter fighter) {
System.out.println("用" + this.getName() + "对" + fighter.getName()
+ "造成了" + this.getDamage() + "基本伤害。");
fighter.loseLife(this.getDamage());
}
protected void specialAttack(Fighter fighter) {
Random r = new Random();
int i = r.nextInt(100);
if (i < this.probability) {
System.out.println(this.getName() + "触发了特殊效果，对" + fighter.getName()
+ "造成了" + this.specialDamage + "点额外伤害。");
fighter.loseLife(this.specialDamage);
}
}
}
剑这个类里定义了伤害值，特殊攻击的伤害值,特殊攻击的触发几率，并且在这里定义了特殊攻击的算法。这样做有什么好处呢？看了子类就知道了：
package com.Weapon;
import com.fighter.Fighter;
/*
* 霜之哀伤，攻击力100，有百分之50造成额外的50点伤害。
* */
public class Frostmourne extends Sword {
public Frostmourne()
{
this.setName("霜之哀伤");
this.setDamage(100);
specialDamage=50;
probability=50;
}
@Override
protected void specialAttack(Fighter fighter) {
super.specialAttack(fighter);
}
}
大家看到了，子类很简单，只要定义一下名字，伤害，以及特殊攻击伤害、特殊攻击几率而已，因为具体算法实现已经由父类实现了。
同样的，还有斧类武器：
package com.Weapon;
import java.util.Random;
import com.fighter.Fighter;
//斧类武器有一定几率造成双倍伤害
public abstract class Axe implements WeaponBehavior {
// 普通伤害
int damage;
String name;
// 特殊攻击的伤害
int specialDamage;
// 特殊攻击的触发几率
int probability;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getDamage() {
return damage;
}
public void setDamage(int damage) {
this.damage = damage;
}
@Override
public void attackWithWeapon(Fighter fighter) {
normalAttack(fighter);
specialAttack(fighter);
}
protected void normalAttack(Fighter fighter) {
System.out.println("用" + this.getName() + "对" + fighter.getName()
+ "造成了" + this.getDamage() + "基本伤害。");
fighter.loseLife(this.getDamage());
}
protected void specialAttack(Fighter fighter) {
Random r = new Random();
//斧子有一定几率造成双倍伤害
this.specialDamage=damage*2;
int i = r.nextInt(100);
if (i < this.probability) {
System.out.println(this.getName() + "触发了特殊效果，对" + fighter.getName()
+ "造成了" + this.specialDamage + "点额外伤害。");
fighter.loseLife(this.specialDamage);
}
}
}
package com.Weapon;
import com.fighter.Fighter;
/*
* 公正使者，攻击力100，有百分之30几率造成双倍伤害。
* */
public class Axe1 extends Axe {
public Axe1()
{
this.setName("公正使者");
this.setDamage(100);
probability=30;
}
@Override
protected void specialAttack(Fighter fighter) {
super.specialAttack(fighter);
}
}
武器就写这么多吧，现在看看Fighter,它就是策略模式定义中的
使用算法的客户
package com.fighter;
import com.Weapon.WeaponBehavior;
public class Fighter {
private int life;
private String name;
private WeaponBehavior weapon;
public Fighter(String name,WeaponBehavior weapon)
{
this.weapon=weapon;
this.name=name;
this.life=1000;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void hit(Fighter fighter)
{
this.weapon.attackWithWeapon(fighter);
}
public int getLife() {
return life;
}
private void setLife(int life) {
this.life = life;
}
public WeaponBehavior getWeapon() {
return weapon;
}
public void setWeapon(WeaponBehavior weapon) {
this.weapon = weapon;
}
public void loseLife(int damage)
{
this.setLife(this.getLife()-damage);
}
public void changeWeapon(WeaponBehavior weapon)
{
System.out.println(this.getName()+"装备了"+weapon.getName());
this.setWeapon(weapon);
}
}
可以看到，Fighter攻击的时候只是去调用了自身武器的attackWithWeapon(Fighter fighter)方法。这就证实了策略模式的定义，
定义了算法簇，分别封装起来，让他们之间可以相互替换,这些武器就是算法簇，使用者只要更换掉自己想要使用的实现类就行了，在调用算法的时候，依然只是调用算法实现的接口。
看下测试类
package com.main;
import com.Weapon.Axe1;
import com.Weapon.Frostmourne;
import com.fighter.Fighter;
public class Main {
public static void main(String[] args) {
Fighter player=new Fighter("player",new Frostmourne());
Fighter computer=new Fighter("computer",new Frostmourne());
player.hit(computer);
System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");
player.hit(computer);
System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");
//这里更换了算法（武器）
player.changeWeapon(new Axe1());
player.hit(computer);
System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");
player.hit(computer);
System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");
player.hit(computer);
System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");
player.hit(computer);
System.out.println(computer.getName()+"还剩下"+computer.getLife()+"生命");
}
}
测试结果：
用霜之哀伤对computer造成了100基本伤害。
霜之哀伤触发了特殊效果，对computer造成了50点额外伤害。
computer还剩下850生命
用霜之哀伤对computer造成了100基本伤害。
霜之哀伤触发了特殊效果，对computer造成了50点额外伤害。
computer还剩下700生命
player装备了公正使者
用公正使者对computer造成了100基本伤害。
computer还剩下600生命
用公正使者对computer造成了100基本伤害。
公正使者触发了特殊效果，对computer造成了200点额外伤害。
computer还剩下300生命
用公正使者对computer造成了100基本伤害。
computer还剩下200生命
用公正使者对computer造成了100基本伤害。
computer还剩下100生命
分享到：
相关推荐
而"StrategyProject"可能是一个Java项目，包含了策略模式的实例代码。在这个项目中，可能定义了一个策略接口，比如`SortingStrategy`，包含了各种排序算法（如快速排序、冒泡排序、插入排序）。然后，会有多个实现类...
策略模式例子，纯代码，copy后即可运行； 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中...
策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在软件开发中，我们经常遇到需要根据不同条件或选择执行不同算法的情况。策略模式提供了一种将算法封装到独立可互换的策略对象中，使得算法的变化独立...
Java策略模式是一种行为设计模式，它使你能在运行时改变对象的行为。在Java中，策略模式通常涉及到定义一系列算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户。这个"java策略模式示例....
在给定的"01-策略模式"代码实例中，我们可能看到以下几个关键部分： 1. **策略接口（Strategy）**：这是定义了所有支持的算法或行为的公共接口。例如，我们可以有一个`SortingStrategy`接口，其中包含一个`sort()`...
总结来说，这个"java 策略模式demo"是学习和理解如何在Java项目中应用策略模式的一个很好的实例。它展示了如何通过接口定义策略，如何实现这些策略，以及如何在上下文中使用它们。通过分析和研究这个示例，开发者...
策略模式是一种设计模式，主要目的是将算法或策略的实现与使用它们的客户端代码解耦，使得算法可以在不修改客户端代码的情况下进行扩展或更改。在Java中，策略模式通常通过定义接口和实现这些接口的具体策略类来实现...
在Java中，我们可以这样实现策略模式： ```java // 抽象策略 public interface Duck { void quack(); } // 具体策略1 public class MallardDuck implements Duck { @Override public void quack() { System....
让我们通过一个简单的实例来深入理解策略模式。假设我们有一个应用程序，需要对不同的数据进行排序。我们可以创建一个SortStrategy接口，定义一个sort方法。然后，我们可以创建多个ConcreteStrategy类，如BubbleSort...
在Java中，策略模式通常用于将算法封装到不同的类中，使得可以根据需要动态选择并应用这些算法。本示例将详细介绍如何通过两种方法实现策略模式：一种是通过Map存储方式，另一种是通过配置文件加反射方式。 首先，...
1. **策略模式(01-策略模式)**：策略模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，让算法独立于使用它的客户。在Java中，通常通过接口或抽象类实现策略，允许在运行时动态选择执行的算法。 2....
在Java中，策略模式主要通过定义一系列的算法，并将每一个算法封装起来，使它们可以互相替换，让算法独立于使用它的客户而变化。这种模式的核心在于策略类，它封装了具体的算法，并负责执行这些算法。 在提供的...
策略模式是设计模式的一种，属于行为模式，它在Java开发中广泛应用，主要解决的是当算法有多种变化，而这些变化需要以不同的方式处理时的问题。通过策略模式，我们可以将算法封装在独立的策略类中，使得算法的变化...
5. **策略模式（Strategy）**：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，让算法独立于使用它的客户端。 6. **代理模式（Proxy）**：为其他对象提供一种代理以控制对这个对象的访问，可以用于...
在Java中，策略模式主要通过定义一系列的算法，并将每一个算法封装起来，使得它们可以互相替换，让算法独立于使用它的客户。这种模式的核心在于它能提供多态性的行为选择，而不仅仅是静态的方法调用。 在"JAVA策略...
Web MVC 框架、网站性能优化与安全策略、设计模式与架构、网站设计与网页配色、Java Web典型项目开发案例等。配书光盘附带了实例的源程序。 《Java Web开发实例大全（提高卷）》既适合Java Web程序员参考和查阅，也...
以下是一个简单的Java实例，演示如何使用Spymemcached连接到Memcached服务器并执行基本操作： 1. **添加依赖** 首先，你需要在项目中添加Spymemcached的依赖。如果你使用的是Maven，可以在pom.xml文件中添加以下...
"250个Java实例源代码"的压缩包文件显然旨在帮助学习者通过实践理解Java编程的各种概念和技术。这些实例涵盖了从基础语法到高级特性的各种主题，包括但不限于： 1. **基本语法**：如变量声明、数据类型（包括原始...
在这个“JAVA设计模式例程-策略模式”的压缩包中，我们可以深入探讨策略模式的原理及其应用。 策略模式的核心思想是定义一系列算法，并将每一个算法封装起来，使它们可以相互替换。策略对象的使用让算法的变化独立...
策略模式定义了一系列算法，并让它们之间可以互相替换；模板方法模式定义一个操作中的算法骨架，而将一些步骤延迟到子类中；访问者模式表示一个作用于某对象结构中的各元素的操作。 在“DesignJava.PDF”和...