java设计模式
- 含义：对软件设计中的普遍存在的问题的解决方法
原则：
- 开闭原则
-
- 对扩展开放,对修改关闭
- 里氏替换原则
-
- 任何基类出现的地方，子类一定可以出现
- 依赖倒转原则
-
- 核心内容：针对接口编程,高层模块不应该依赖底层模块，二者都应该依赖抽象而不依赖于具体
- 接口隔离原则
-
- 使用多个隔离的接口,降低耦合度
- 单一职责原则
-
- 类的职责要单一,不能讲多个职责放在一个类中
- 最少知道原则
-
- 一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立
- 合成复用原则
-
- 在一个新的对象里通过关联关系(组合，聚合)来使用一些已有的对象
- 创建型模式，共5种：工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式。
- 结构型模式，共7种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
- 行为型模式，共11种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
工厂模式
- 工厂通常是创建其他对象的对象
-
- 创建对象时不会暴露给客户端创建逻辑，并且通过一个共同的接口指向新对象
- 分为三种:
-
- 普通工厂 (工厂类中只有一个方法)
-
- 多个工厂方法 (多个方法,每个方法对应一个创建对象)
-
- 静态工厂方法 (方法是静态的)
- 静态工厂方法 (方法是静态的)
编写code：
package com.designSchema;
import javax.swing.text.html.Option;
import java.util.Optional;
//编写接口类
interface father{
void say();
}
//子类
class Male implements father{
@Override
public void say(){
System.out.println("I am a man");
}
}
//子类
class Famale implements father{
@Override
public void say(){
System.out.println("I am a woman");
}
}
//工厂类
class TestFactory{
//普通工厂
public Optional<father> createAll(String name){
if(name.equals("male")){
return Optional.ofNullable(new Male());
}else if(name.equals("famale")){
return Optional.ofNullable(new Famale());
}
return Optional.empty();
}
//多方法工厂
public Optional<Male> createMale(){
return Optional.ofNullable(new Male());
}
public Optional<Famale> createFamale(){
return Optional.ofNullable(new Famale());
}
//静态方法
public static Optional<Male> createStaticMale(){
return Optional.ofNullable(new Male());
}
}
//测试
public class FactoryMode {
public static void main(String[]args){
TestFactory factory = new TestFactory();
//普通
factory.createAll("male").get().say();
//多个方法
factory.createFamale().get().say();
//静态
TestFactory.createStaticMale().get().say();
}
}
抽象工厂模式
- 就是在工厂的一个分类工厂,将具有同一主题的单独工厂封装起来
package com.designSchema;
//抽象食物
interface Food{
public String getFoodName();
}
//抽象餐具
interface TableWare{
public String getToolName();
}
//抽象工厂
interface KitChenFactory{
public Food getFood();
public TableWare getTool();
}
//继承
class Apple implements Food{
@Override
public String getFoodName(){
return "apple";
}
}
class Knife implements TableWare{
@Override
public String getToolName(){
return "knife";
}
}
//工厂
class AKitchen implements KitChenFactory{
@Override
public Food getFood(){
return new Apple();
}
@Override
public TableWare getTool(){
return new Knife();
}
}
//测试
public class AbstractFactoryMode {
public static void main(String[]args){
AKitchen aKitchen = new AKitchen();
System.out.println("food:"+aKitchen.getFood().getFoodName()+",tool:"+aKitchen.getTool().getToolName());
}
}
工厂方法模式：针对的是 一个产品等级结构。
抽象工厂模式：针对 多个产品等级结构
适配器模式
- 类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作
package com.designSchema;
//target
interface Target{
void test();
}
//被适配
class Adaptee{
public void test(){
System.out.println("I already adapter");
}
}
public class Adapter implements Target{
private Adaptee adaptee;
public Adapter(Adaptee adaptee){
this.adaptee = adaptee;
}
@Override
public void test() {
adaptee.test();
}
public static void main(String[]args){
Adaptee adaptee = new Adaptee();
Target t = new Adapter(adaptee);
t.test();
}
}
装饰器模式
- 装饰者模式（Decorator Pattern，有的也用 Wrapper Pattern）就是动态地把职责附加到已有对象上去，实现功能扩展。这种特性，使得装饰者模式提供了比继承更具有弹性的解决方案
package com.designSchema;
import com.sun.javafx.iio.gif.GIFImageLoader2;
abstract class Girl{
public String info = "Gril";
public String disriction(){
return info;
}
}
class AmericanGirl extends Girl{
public AmericanGirl() {
info+="+AmericanGirl";
}
}
class ChineseGirl extends Girl{
public ChineseGirl() {
info+="+ChineseGirl";
}
}
//装饰器Girl
abstract class DecorateGirl extends Girl{
@Override
abstract public String disriction();
}
//金黄色的头发
class GoldenHair extends DecorateGirl {
Girl girl;
public GoldenHair(Girl girl) {
this.girl = girl;
}
@Override
public String disriction() {
return girl.info += " GoldenHair";
}
}
//测试
public class Decorate {
public static void main(String[]args){
Girl g = new AmericanGirl();
System.out.println(g.disriction());
GoldenHair hair = new GoldenHair(g);
System.out.println(hair.disriction());
}
}
观察者模式
观察者模式（Observer Pattern）就是一种 “发布者-订阅者” 的模式
package com.designSchema;
import java.util.ArrayList;
import java.util.List;
//主题接口
interface Subject{
public void registerObserver(ObserverDemo o);
public void removeObserver(ObserverDemo o);
public void notifyAllObserver();
}
//被观察者
class ReverseObserverDemo implements Subject{
//观察者列表和信息列表
private List<ObserverDemo> observerDemos;
private List<String> information;
public ReverseObserverDemo(){
this.observerDemos = new ArrayList<ObserverDemo>();
this.information = new ArrayList<String>();
}
@Override
public void registerObserver(ObserverDemo o) {
this.observerDemos.add(o);
}
@Override
public void removeObserver(ObserverDemo o) {
this.observerDemos.remove(o);
}
@Override
public void notifyAllObserver() {
this.observerDemos.forEach(x->x.update());
}
public void addinformation(String information){
this.information.add(information);
notifyAllObserver();
}
}
//观察者
interface ObserverDemo{
public void update();
}
class PeopleObserver implements ObserverDemo{
private String name;
public PeopleObserver(String name){
this.name = name;
}
@Override
public void update() {
System.out.println(name+" We knows!!!");
}
}
public class Observer {
public static void main(String []args){
//创建一个被观察者对象
ReverseObserverDemo reverse = new ReverseObserverDemo();
//创建观察者
ObserverDemo o1 = new PeopleObserver("Tom");
ObserverDemo o2 = new PeopleObserver("Jim");
ObserverDemo o3 = new PeopleObserver("Rose");
//注册
reverse.registerObserver(o1);
reverse.registerObserver(o2);
reverse.registerObserver(o3);
//通知
reverse.addinformation("hello");
}
}
单列模式
单例模式（Singleton Pattern），顾名思义，就是被单例的对象只能有一个实例存在
有两种：懒汉模式和饿汉模式
懒汉模式：调用才创建
饿汉模式：直接先创建
package com.designSchema;
//懒汉模式
class SingleT1{
private static volatile SingleT1 singleT1;
private SingleT1(){
}
public static SingleT1 getSingle(){
if(singleT1==null) {
synchronized (SingleT1.class){
if(singleT1 ==null){
singleT1 = new SingleT1();
}
}
}
return singleT1;
}
}
//饿汉模式
class SingleT2{
private static SingleT2 singleT2 = new SingleT2();
private SingleT2(){
}
public static SingleT2 getSingle(){
return singleT2;
}
}
//测试
public class Single {
public static void main(String []args){
SingleT1 t1 = SingleT1.getSingle();
SingleT1 t2 = SingleT1.getSingle();
System.out.println(t1==t2);
SingleT2 t3 = SingleT2.getSingle();
SingleT2 t4 = SingleT2.getSingle();
System.out.println(t3==t4);
}
}
//枚举
enum Wife{
INSTANCE;
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
