如何利用setFlyBehavior()和setQuackBehavior()动态地设置鸭子的飞行和叫声行为
时间: 2024-03-03 17:50:20 浏览: 21
要动态地设置鸭子的飞行和叫声行为,可以在Duck类的子类中覆盖setFlyBehavior()和setQuackBehavior()方法,以便在运行时动态地改变鸭子的行为。例如,如果你想创建一只会飞的鸭子,你可以创建一个继承自Duck的FlyingDuck类,并覆盖其构造函数,在其中调用setFlyBehavior()方法,将其飞行行为设置为FlyWithWings对象。代码如下:
```
public class FlyingDuck extends Duck {
public FlyingDuck() {
flyBehavior = new FlyWithWings();
quackBehavior = new Quack();
}
public void display() {
System.out.println("I am a flying duck");
}
}
```
这样,在创建FlyingDuck对象时,它的飞行行为就会被设置为FlyWithWings对象,而叫声行为则会被设置为Quack对象。同样地,你可以创建一个不会飞的鸭子,只需要创建一个继承自Duck的NonFlyingDuck类,并覆盖其构造函数,在其中调用setFlyBehavior()方法,将其飞行行为设置为FlyNoWay对象。
相关问题
设计模式详细教程
设计模式是一种经过验证的经验,被广泛认可并被用来解决特定类型问题的解决方案。设计模式可以帮助我们更好地组织和维护代码,并提高代码的可重用性、可扩展性和可维护性。下面我将介绍几种常见的设计模式及其详细教程。
1. 单例模式
单例模式是一种常用的创建型模式,它保证一个类只有一个实例,并提供一个全局访问点。单例模式的实现方式有多种,以下是其中一种基于懒汉式的实现:
```java
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
```
2. 工厂模式
工厂模式是一种常用的创建型模式,它提供一个统一的接口来创建对象,而不需要暴露对象的创建逻辑。工厂模式可以根据需要动态地创建对象,使代码更加灵活。以下是其中一种基于简单工厂的实现:
```java
public interface Shape {
void draw();
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Circle.draw()");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Square.draw()");
}
}
public class ShapeFactory {
public static Shape getShape(String type) {
if (type.equalsIgnoreCase("circle")) {
return new Circle();
} else if (type.equalsIgnoreCase("square")) {
return new Square();
}
return null;
}
}
```
3. 观察者模式
观察者模式是一种常用的行为型模式,它定义了一种一对多的关系,让多个观察者对象同时监听某一个主题对象。当主题对象发生变化时,会通知所有的观察者对象,使它们能够自动更新。以下是其中一种基于 Java 内置 Observer 接口的实现:
```java
import java.util.Observable;
import java.util.Observer;
public class WeatherData extends Observable {
private float temperature;
private float humidity;
private float pressure;
public void measurementsChanged() {
setChanged();
notifyObservers();
}
public void setMeasurements(float temperature, float humidity, float pressure) {
this.temperature = temperature;
this.humidity = humidity;
this.pressure = pressure;
measurementsChanged();
}
public float getTemperature() {
return temperature;
}
public float getHumidity() {
return humidity;
}
public float getPressure() {
return pressure;
}
}
public class CurrentConditionsDisplay implements Observer {
private float temperature;
private float humidity;
public void display() {
System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
}
@Override
public void update(Observable o, Object arg) {
if (o instanceof WeatherData) {
WeatherData weatherData = (WeatherData) o;
this.temperature = weatherData.getTemperature();
this.humidity = weatherData.getHumidity();
display();
}
}
}
```
4. 策略模式
策略模式是一种常用的行为型模式,它定义了一系列的算法,将每个算法封装起来,并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。以下是其中一种基于接口和组合的实现:
```java
public interface FlyBehavior {
void fly();
}
public class FlyWithWings implements FlyBehavior {
@Override
public void fly() {
System.out.println("I'm flying with wings");
}
}
public class FlyNoWay implements FlyBehavior {
@Override
public void fly() {
System.out.println("I can't fly");
}
}
public abstract class Duck {
FlyBehavior flyBehavior;
public void performFly() {
flyBehavior.fly();
}
public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior = flyBehavior;
}
public abstract void display();
}
public class MallardDuck extends Duck {
public MallardDuck() {
flyBehavior = new FlyWithWings();
}
@Override
public void display() {
System.out.println("I'm a Mallard duck");
}
}
public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay();
}
@Override
public void display() {
System.out.println("I'm a Model duck");
}
}
```
以上是几种常见的设计模式及其详细教程,希望能对你有所帮助。当然,设计模式并不是万能的,需要根据具体情况选择合适的模式来解决问题。