文章目录
模板设计模式1.定义2.实现3.钩子方法
工厂设计模式一、简单工厂模式1.特点2.结构图3.实现
二、工厂方法模式1.特点2.结构图3.实现
代理设计模式1.特点2.本质3.实现
模板设计模式
1.定义
在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。
2.实现
abstract class Beverage{
final void prepareRecipe(){
boilwater();
brew();
pourInCup();
addCondiments();
}
abstract void addCondiments();
abstract void brew();
void boilwater(){
System
.out
.println("烧水");
}
void pourInCup(){
System
.out
.println("倒入杯中");
}
}
class Coffee extends Beverage{
@Override
void addCondiments() {
System
.out
.println("加糖和牛奶");
}
@Override
void brew() {
System
.out
.println("冲咖啡");
}
}
class Tea extends Beverage{
@Override
void addCondiments() {
System
.out
.println("加柠檬");
}
@Override
void brew() {
System
.out
.println("泡茶");
}
}
public class test{
public static void main(String
[]args
){
Tea tea
= new Tea();
tea
.prepareRecipe();
System
.out
.println("------------------");
Coffee coffee
= new Coffee();
coffee
.prepareRecipe();
}
}
3.钩子方法
abstract class Beverage{
final void prepareRecipe(){
boilwater();
brew();
pourInCup();
if(customerWant())
addCondiments();
}
abstract void addCondiments();
abstract void brew();
void boilwater(){
System
.out
.println("烧水");
}
void pourInCup(){
System
.out
.println("倒入杯中");
}
boolean customerWant(){
return true;
}
}
class Coffee extends Beverage{
@Override
void addCondiments() {
System
.out
.println("加糖和牛奶");
}
@Override
void brew() {
System
.out
.println("冲咖啡");
}
}
class Tea extends Beverage{
@Override
void addCondiments() {
System
.out
.println("加柠檬");
}
@Override
void brew() {
System
.out
.println("泡茶");
}
public boolean customerWant(){
String answer
= getUserInput();
if (answer
.equals("y")){
return true;
}else
return false;
}
private String
getUserInput(){
String answer
= null
;
System
.out
.println("请问您需要加柠檬吗？y/n");
Scanner scanner
= new Scanner(System
.in
);
answer
= scanner
.nextLine();
return answer
;
}
}
public class test{
public static void main(String
[]args
){
Tea tea
= new Tea();
tea
.prepareRecipe();
System
.out
.println("------------------");
Coffee coffee
= new Coffee();
coffee
.prepareRecipe();
}
}
工厂设计模式
一、简单工厂模式
1.特点
一个抽象产品类（接口）——computer 多个具体产品类——MacBook、surface 一个工厂（new操作在此工厂中进行）——客户端通过工厂类获取具体实例
2.结构图
3.实现
interface IComputer{
void buyComputer();
}
class Factory{
public static IComputer
getInstance(String classname
){
if("MacBook".equals(classname
)){
return new Macbook();
}else if("surface".equals(classname
)){
return new surface();
}else
return null
;
}
}
class Macbook implements IComputer{
@Override
public void buyComputer() {
System
.out
.println("买macbook");
}
}
class surface implements IComputer{
@Override
public void buyComputer() {
System
.out
.println("买suface电脑");
}
}
public class test{
public static void main(String
[]args
){
IComputer computer
= Factory
.getInstance("MacBook");
computer
.buyComputer();
}
}
二、工厂方法模式
1.特点
定义一个用来创建对象的接口，让子类决定实例化哪一个类。针对每个产品（产品族）提供一个工厂类，客户端需要判断使用哪个工厂。 a.一个抽象产品类 b.多个具体产品类 c.一个抽象工厂（针对抽象产品类） d多个具体工厂（每个产品族拥有自己的工厂）
2.结构图
3.实现
interface IComputer{
void buyComputer();
}
interface IComputerFactory{
IComputer
createComputer();
}
class MsFactory implements IComputerFactory{
@Override
public IComputer
createComputer() {
return new surface();
}
}
class AppleFactory implements IComputerFactory{
@Override
public IComputer
createComputer() {
return new Macbook();
}
}
class Macbook implements IComputer{
@Override
public void buyComputer() {
System
.out
.println("买macbook");
}
}
class surface implements IComputer{
@Override
public void buyComputer() {
System
.out
.println("买suface电脑");
}
}
public class test{
public static void main(String
[]args
){
IComputer computer
= new MsFactory().createComputer();
computer
.buyComputer();
}
}
代理设计模式
1.特点
两个子类共同实现同一个接口，其中一个子类负责真实业务实现，另外一个子类完成辅助真实业务主题的操作。
2.本质
所有的真实业务操作都会有一个与之辅助的工具类（功能类）共同完成。
3.实现
interface ISubject{
void buyComputer();
}
class RealSubject implements ISubject{
@Override
public void buyComputer() {
System
.out
.println("买一台笔记本电脑");
}
}
class ProxySubject implements ISubject{
private ISubject iSubject
;
public ProxySubject(ISubject iSubject
){
this.iSubject
= iSubject
;
}
public void produceComputer(){
System
.out
.println("生产一台笔记本电脑");
}
public void afterSale(){
System
.out
.println("笔记本售后");
}
@Override
public void buyComputer() {
this.produceComputer();
this.iSubject
.buyComputer();
this.afterSale();
}
}
class Factory {
public static ISubject
getInstance(){
return new ProxySubject(new RealSubject()) ;
}
}
public class TestDemo {
public static void main(String
[] args
) {
ISubject subject
= Factory
.getInstance() ;
subject
.buyComputer() ;
}
}
