命令模式
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);
}
}
}