设计模式资料

// 抽象类作为    1模板1
abstract class CornerKickTactic {
    // 模板方法，定义了战术角球的执行流程
    public final void executeTactic() {
        kick();
        pass();
        go();
        attack();
    }

    // 基本方法，开球
    void kick(){
        System.out.println("A开球");
    }

    // 基本方法，传球
    void pass(){
        System.out.println("B传球");
    }

    public abstract void go();

    // 基本方法，进攻
    void attack(){
        System.out.println("C射门");
    }
}

// 具体的战术角球实现类
class TacticA extends CornerKickTactic {

    @Override
    public void go() {
        System.out.println("C抢前点");
    }
}

class TacticB extends CornerKickTactic {

    @Override
    public void go() {
        System.out.println("C抢后点");
    }
}

// 示例使用
public class Main {
    public static void main(String[] args) {

        TacticA tacticA = new TacticA();
        TacticB tacticB = new TacticB();

        System.out.println("Tactic A:");
        tacticA.executeTactic();

        System.out.println("Tactic B:");
        tacticB.executeTactic();
    }
}

package aaa;

// 账户1状态1接口
interface AccountState {
    void deposit(double amount); // 存款
    void withdraw(double amount); // 取款
    void computeInterest(); // 计算利息
    void stateCheck();
}

// 正常状态
class NormalState implements AccountState {
    private Account account;
    private AccountState accountState;

    public NormalState(Account account) {
        this.account = account;
    }

    public NormalState(AccountState accountState) {
        this.accountState = accountState;
    }

    @Override
    public void deposit(double amount) {
        account.setBalance(account.getBalance() + amount);
        System.out.println("存款" + amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        account.setBalance(account.getBalance() - amount);
        System.out.println("取款" + amount);
        stateCheck();
    }

    @Override
    public void computeInterest() {
        System.out.println("无利息");
    }

    @Override
    public void stateCheck() {
        if (account.getBalance() < 0 && account.getBalance() > -2000) {
            account.setState(new OverdraftState(account));
        } else if (account.getBalance() <= -2000) {
            account.setState(new RestrictedState(account));
        }
    }
}

// 透支状态
class OverdraftState implements AccountState {
    private Account account;

    public OverdraftState(Account account) {
        this.account = account;
    }

    @Override
    public void deposit(double amount) {
        account.setBalance(account.getBalance() + amount);
        System.out.println("存款" + amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        account.setBalance(account.getBalance() - amount);
        System.out.println("取款" + amount);
        stateCheck();
    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息");
    }

    @Override
    public void stateCheck() {
        if (account.getBalance() > 0) {
            account.setState(new NormalState(account));
        } else if (account.getBalance() <= -2000) {
            account.setState(new RestrictedState(account));
        }
    }
}

// 受限状态
class RestrictedState implements AccountState {
    private Account account;

    public RestrictedState(Account account) {
        this.account = account;
    }

    @Override
    public void deposit(double amount) {
        account.setBalance(account.getBalance() + amount);
        System.out.println("存款" + amount);
        stateCheck();
    }

    @Override
    public void withdraw(double amount) {
        System.out.println("在受限状态下拒绝取款操作");
    }

    @Override
    public void computeInterest() {
        System.out.println("计算利息");
    }

    @Override
    public void stateCheck() {
        if (account.getBalance() > 0) {
            account.setState(new NormalState(account));
        } else if (account.getBalance() > -2000) {
            account.setState(new OverdraftState(account));
        }
    }
}

// 账户类
class Account {
    private String owner;
    private double balance;
    private AccountState state;

    public Account(String owner, double init) {
        this.owner = owner;
        this.balance = init;
        if (balance >= 0){
            setState(new NormalState(this));
        }else if(balance <= -2000){
            setState(new RestrictedState(this));
        }else {
            setState(new OverdraftState(this));
        }
    }

    public void deposit(double amount) {
        state.stateCheck();
        state.deposit(amount);
    }

    public void withdraw(double amount) {
        state.withdraw(amount);
    }

    public void computeInterest() {
        state.computeInterest();
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }

    public void setState(AccountState state) {
        this.state = state;
    }
}

public class Main {
    public static void main(String[] args) {
        Account account = new Account("zhangsan",0);

        account.withdraw(2000);
        account.computeInterest();

        account.withdraw(3000);
        account.computeInterest();

        account.deposit(2000);
        account.computeInterest();
    }
}

package aaa;
//
interface Discount {
    double calculate(double price);
}

class StudentDiscount implements Discount {
    @Override
    public double calculate(double price) {
        return price * 0.8;
    }
}

class ChildrenDiscount implements Discount {
    @Override
    public double calculate(double price) {
        if (price >= 20) {
            return price - 10;
        }
        return price;
    }
}

class VIPDiscount implements Discount {
    @Override
    public double calculate(double price) {
        return price / 2;
    }
}

class MovieTicket {
    private Discount discount;
    private double price;

    public void setDiscount(Discount discount) {
        this.discount = discount;
    }

    public double getPrice() {
        price = discount.calculate(price);
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

}

public class Main {
    public static void main(String[] args) {
        MovieTicket movieTicket1 = new MovieTicket();
        movieTicket1.setPrice(100);
        movieTicket1.setDiscount(new StudentDiscount());
        double studentPrice = movieTicket1.getPrice();
        System.out.println("Student Price: " + studentPrice);

        MovieTicket movieTicket2 = new MovieTicket();
        movieTicket2.setPrice(100);
        movieTicket2.setDiscount(new ChildrenDiscount());
        double childPrice = movieTicket2.getPrice();
        System.out.println("Child Price: " + childPrice);

        MovieTicket movieTicket3 = new MovieTicket();
        movieTicket3.setPrice(100);
        movieTicket3.setDiscount(new VIPDiscount());
        double vipPrice = movieTicket3.getPrice();
        System.out.println("VIP Price: " + vipPrice);
    }
}

package aaa;

interface TakeOffStrategy {
    void takeOff();
}

interface FlyingStrategy {
    void flying();
}

class verticalTakeOff implements TakeOffStrategy {
    @Override
    public void takeOff(){
        System.out.println("起飞特征:垂直起飞");
    }
}

class LongTakeoff implements TakeOffStrategy {
    @Override
    public void takeOff(){
        System.out.println("起飞特征:长距离起飞");
    }
}

class SubSonicFly implements FlyingStrategy {
    @Override
    public void flying() {
        System.out.println("飞行特征:亚音速飞行");
    }
}

class SuperSonicFly implements FlyingStrategy {
    @Override
    public void flying() {
        System.out.println("飞行特征:超音速飞行");
    }
}

class Plane {

    private String name;
    private TakeOffStrategy takeOffStrategy;
    private FlyingStrategy flyingStrategy;

    public Plane(String name, TakeOffStrategy takeOffStrategy, FlyingStrategy flyingStrategy) {
        this.name = name;
        this.takeOffStrategy = takeOffStrategy;
        this.flyingStrategy = flyingStrategy;
    }

    public void display() {
        System.out.println("飞机种类: " + name);
        takeOffStrategy.takeOff();
        flyingStrategy.flying();
        System.out.println();
    }
}

public class Main {
    public static void main(String[] args) {
        Plane plane1 = new Plane("直升机",new verticalTakeOff(),new SubSonicFly());
        plane1.display();
        Plane plane2 = new Plane("客机",new LongTakeoff(),new SubSonicFly());
        plane2.display();
    }
}

package aaa;

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(float temperature, float humidity, float pressure);
}

interface Subject {
    void registerObserver(Observer observer);
    void remove(Observer observer);
    void notifyObservers();
}

class WeatherData implements Subject {
    private List<Observer> observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void remove(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void setMeasurements(float temperature, float humidity, float pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }

    private void measurementsChanged() {
        notifyObservers();
    }
}

class CurrentCondition implements Observer {
    @Override
    public void update(float temperature, float humidity, float pressure) {
        System.out.println("CurrentCondition:   Temperature: " + temperature + ", Humidity: " + humidity + ", Pressure: " + pressure);
    }
}

class Baidu implements Observer {
    @Override
    public void update(float temperature, float humidity, float pressure) {
        System.out.println("Baidu:  Temperature: " + temperature + ", Humidity: " + humidity + ", Pressure: " + pressure);
    }
}

class Sina implements Observer {
    @Override
    public void update(float temperature, float humidity, float pressure) {
        System.out.println("Sina:  Temperature: " + temperature + ", Humidity: " + humidity + ", Pressure: " + pressure);
    }
}

public class Main {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();

        CurrentCondition  currentCondition = new CurrentCondition();
        Baidu baidu = new Baidu();
        Sina sina = new Sina();

        weatherData.registerObserver(currentCondition);
        weatherData.registerObserver(baidu);
        weatherData.registerObserver(sina);

        float temperature = 25.5f;
        float humidity = 70.2f;
        float pressure = 1013.2f;
        weatherData.setMeasurements(temperature, humidity, pressure);

    }
}