java-函數式編程-設計模式

命令模式

package pattern;

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


public class CommandPattern {

    public static void main(String[] args) {

        Editor editor = new Editor() {
            @Override
            public void save() {
                System.out.println("save");
            }

            @Override
            public void open() {
                System.out.println("open");
            }

        };


        Macro macro = new Macro();
        macro.record(editor::open);
        macro.record(editor::save);

        macro.run();
    }
}

interface Editor {
    public void save();
    public void open();
}

interface Action {
    public void perform();
}

class Macro {
    private final List<Action> actions;

    public Macro() {
        actions = new ArrayList<>();
    }

    public void record(Action action) {
        actions.add(action);
    }

    public void run() {
        actions.forEach(Action::perform);
    }
} 

觀察者模式

package pattern;

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


public class ObserverPattern {

    public static void main(String[] args) {
        Moon moon = new Moon();
        moon.startSpying(name -> {
            if (name.contains("Apollo"))
                System.out.println(name+":"+"We made it!");
        });
        moon.startSpying(name -> {
            if (name.contains("An asteroid"))
                System.out.println(name+":"+"They're distracted, lets invade earth!");
        });
        moon.land("An asteroid");
        moon.land("Apollo 11");
    }
}


interface LandingObserver {
    public void observeLanding(String name);
}


class Moon {
    private final List<LandingObserver> observers = new ArrayList<>();

    public void land(String name) {
        for (LandingObserver observer : observers) {
            observer.observeLanding(name);
        }
    }

    public void startSpying(LandingObserver observer) {
        observers.add(observer);
    }
}

策略模式

package pattern;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.zip.GZIPOutputStream;
import java.util.zip.ZipOutputStream;


public class StrategyPattern {

    public static void main(String[] args) throws IOException {

        Path  inFile = Paths.get("c:\\data\\myfile.txt");
        File  outFile = new File("output");

        Compressor gzipCompressor = new Compressor(GZIPOutputStream::new);
        gzipCompressor.compress(inFile, outFile);
        Compressor zipCompressor = new Compressor(ZipOutputStream::new);
        zipCompressor.compress(inFile, outFile);
    }

}

interface CompressionStrategy {
    public OutputStream compress(OutputStream data) throws IOException;
}

class Compressor {
    private final CompressionStrategy strategy;
    public Compressor(CompressionStrategy strategy) {
        this.strategy = strategy;
    }
    public void compress(Path inFile, File outFile) throws IOException {
        try (OutputStream outStream = new FileOutputStream(outFile)) {
            Files.copy(inFile, strategy.compress(outStream));
        }
    }
}

class GzipCompressionStrategy implements CompressionStrategy {
    @Override
    public OutputStream compress(OutputStream data) throws IOException {
        return new GZIPOutputStream(data);
    }
}

class ZipCompressionStrategy implements CompressionStrategy {
    @Override
    public OutputStream compress(OutputStream data) throws IOException {
        return new ZipOutputStream(data);
    }
} 

模板方法模式

package pattern;



public class TemplatePattern {
}


//abstract class LoanApplication {
//    public void checkLoanApplication() throws ApplicationDenied {
//        checkIdentity();
//        checkCreditHistory();
//        checkIncomeHistory();
//        reportFindings();
//    }
//
//    protected abstract void checkIdentity() throws ApplicationDenied;
//
//    protected abstract void checkIncomeHistory() throws ApplicationDenied;
//
//    protected abstract void checkCreditHistory() throws ApplicationDenied;
//
//    private void reportFindings() {
//
//    }
//}


interface Criteria {
    public void check() throws ApplicationDenied;
}


class LoanApplication {
    private final Criteria identity;
    private final Criteria creditHistory;
    private final Criteria incomeHistory;

    public LoanApplication(Criteria identity,
                           Criteria creditHistory,
                           Criteria incomeHistory) {
        this.identity = identity;
        this.creditHistory = creditHistory;
        this.incomeHistory = incomeHistory;
    }

    public void checkLoanApplication() throws ApplicationDenied {
        identity.check();
        creditHistory.check();
        incomeHistory.check();
        reportFindings();
    }

    private void reportFindings() {
    }
}

class PersonalLoanApplication extends LoanApplication {

    public PersonalLoanApplication(Criteria identity, Criteria creditHistory, Criteria incomeHistory) {
        super(identity, creditHistory, incomeHistory);
    }

    protected void checkIncomeHistory() {
        
    }

}


class EmployeeLoanApplication extends PersonalLoanApplication {

    public EmployeeLoanApplication(Criteria identity, Criteria creditHistory, Criteria incomeHistory) {
        super(identity, creditHistory, incomeHistory);
    }

    @Override
    protected void checkIncomeHistory() {
        
    }
}


class CompanyLoanApplication extends LoanApplication {
    public CompanyLoanApplication(Company company) {
        super(company::checkIdentity,
                company::checkHistoricalDebt,
                company::checkProfitAndLoss);
    }

}


class ApplicationDenied extends Exception {
}


class Company {

    public void checkIdentity() {
    }

    public void checkHistoricalDebt() {
    }

    public void checkProfitAndLoss() {

    }
} 

依賴反轉

package pattern;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;


public class IocPattern {

    public List<String> findHeadings(Reader input) {
        return withLinesOf(input,
                lines -> lines.filter(line -> line.endsWith(":"))
                        .map(line -> line.substring(0, line.length()-1))
                        .collect(Collectors.toList()),
                RuntimeException::new);
    }


    private <T> T withLinesOf(Reader input,
                              Function<Stream<String>, T> handler,
                              Function<IOException, RuntimeException> error) {
        try (BufferedReader reader = new BufferedReader(input)) {
            return handler.apply(reader.lines());
        } catch (IOException e) {
            throw error.apply(e);
        }
    }


}