标签（空格分隔）： android
设计模式六大原则
- 单一职责原则：就一个类来说，应该仅有一个引起他变化的原因。
- 开源封闭原则：类、模板、函数等应该可以拓展，但不可修改。
- 里氏替换原则：所有引用基类的地方必须透明地使用其子类的对象。
- 依赖倒置的原则：高层模块不应该依赖低层模块，两者都应该依赖于抽象，抽象不应该依赖于细节，细节应该依赖于抽象。
- 迪米特原则：一个软件实体应当尽可能少地与其他实体发生相互作用。
- 接口隔离原则：一个类对另一个类的依赖应建立在一个最小的接口。
单例模式
（1）饿汉模式
public class Sington{
private static Sington sington = new Sington();
private Sington(){
}
public static Sington getInstance(){
return sington;
}
}
(2)懒汉模式
//懒汉模式（线程不安全）
public class Sington{
private static Sington sington;
private Sington(){
}
public static Sington getInstance(){
if(sington == null){
sington = new Sington();
}
return sington;
}
}
//懒汉模式（线程安全）
public class Sington{
private static Sington sington;
private Sington(){
}
public static synchronized Sington getInstance(){
if(sington == null){
sington = new Sington();
}
return sington;
}
}
(3)双重检查模式（DCL）
//双重检查模式
public class DCL {
private static volatile DCL dcl;
private DCL(){};
public static DCL getInstance(){
if(dcl == null){
synchronized (DCL.class){
if(dcl == null){
dcl = new DCL();
}
}
}
return dcl;
}
}
(4)静态内部类单例模式和枚举单例模式
/静态内部类单例模式
public class StaicSington {
private StaicSington(){
}
public static StaicSington getInstance(){
return SingletonHolder.singleton;
}
private static class SingletonHolder{
private static final StaicSington singleton = new StaicSington();
}
}
//枚举单例，线程安全
enum Singleton{
INSTANCE;
public void doSomeThing(){
}
}
简单工厂模式
定义：属于建造型模式，又一个工厂对象创建出哪一种产品类实例。
//调用
public class Simple {
public static void main(String[] args){
ComputerFactory.createComputer("hp").start();
}
}
//抽象产品类
abstract class Computer{
public abstract void start();
}
//具体产品类
class LenovoComputer extends Computer{
@Override
public void start() {
System.out.println("Lenovo电脑");
}
}
class HPComputer extends Computer{
@Override
public void start() {
System.out.println("hp电脑");
}
}
//工厂类
class ComputerFactory{
public static Computer createComputer(String type){
Computer computer = null;
switch (type){
case "lenovo":
computer = new LenovoComputer();
break;
case "hp":
computer = new HPComputer();
break;
default:
break;
}
return computer;
}
}
优点：避免直接实例化类，降低耦合性。
缺点：实例化对象在编译阶段就已经确定，添加新类型，需要修改工厂，这不符合开放封闭原则。
工厂方法模式
定义：定义一个用于创建对象接口，让子类决定实例化哪一个类，工厂方法让一个类的实例化延迟到他的子类。
//调用
public class Simple {
public static void main(String[] args){
ComputerFactory computerFactory =new GDComputerFactory();
LenovoComputer lenovoComputer = computerFactory.createCompter(LenovoComputer.class);
lenovoComputer.start();
HPComputer hpComputer = computerFactory.createCompter(HPComputer.class);
hpComputer.start();
}
}
//抽象产品类
abstract class Computer{
public abstract void start();
}
//具体产品类
class LenovoComputer extends Computer{
@Override
public void start() {
System.out.println("Lenovo电脑");
}
}
class HPComputer extends Computer{
@Override
public void start() {
System.out.println("hp电脑");
}
}
abstract class ComputerFactory{
public abstract T createCompter(Class tClass);
}
//运用反射的知识
class GDComputerFactory extends ComputerFactory{
@Override
public T createCompter(Class tClass) {
Computer computer = null;
String className = tClass.getName();
try{
computer = (Computer) Class.forName(className).newInstance();
}catch (Exception e){
e.printStackTrace();
}
return (T)computer;
}
}
建造者模式
定义：将一个复杂对象的构建和它的表示分离，使得同样的构建过程可以建造不同的表示。
public class BuilderUse {
public static void main(String[] args){
Builder mbuilder = new MoonComputerBuilder();
Director director = new Director(mbuilder);
director.CreateCompter("i7","haha","三星DDr4");
}
}
class ComputerOne{
private String cpu;
private String mainboard;
private String ram;
public void setCpu(String cpu) {
this.cpu = cpu;
}
public void setMainboard(String mainboard) {
this.mainboard = mainboard;
}
public void setRam(String ram) {
this.ram = ram;
}
}
//抽象的建造者
abstract class Builder{
public abstract void buildeCpu(String cpu);
public abstract void bulidMainboard(String mainboard);
public abstract void buildRam(String ram);
public abstract ComputerOne create();
}
class MoonComputerBuilder extends Builder{
private ComputerOne computer = new ComputerOne();
@Override
public void buildeCpu(String cpu) {
computer.setCpu(cpu);
}
@Override
public void bulidMainboard(String mainboard) {
computer.setMainboard(mainboard);
}
@Override
public void buildRam(String ram) {
computer.setRam(ram);
}
@Override
public ComputerOne create() {
return computer;
}
}
class Director{
Builder builder = null;
public Director(Builder builder){
this.builder = builder;
}
public ComputerOne CreateCompter(String cpu,String mainboard,String ram){
this.builder.buildeCpu(cpu);
this.builder.buildRam(ram);
this.builder.bulidMainboard(mainboard);
return builder.create();
}
}
优点：客户端不必知道产品内部细节，构建者类相互独立，易于拓展。
缺点:产生了多余的对象Build对象和Director对象。
代理模式
定义：为其他对象提供一种代理以控制对这个对象的访问。
//抽象主题类
public interface IUser {
void save();
void get();
}
//实际主题类
public class User implements IUser {
public void save(){
System.out.println("User类调用");
}
@Override
public void get() {
System.out.println("User类调用---get");
}
}
//静态代理
public class UserProxy implements IUser {
private IUser target;
public UserProxy(IUser target){
this.target = target;
}
public void save(){
System.out.println("开始代理类");
target.save();
System.out.println("提交事务。。。");
}
@Override
public void get() {
}
}
//动态代理
public class ProxyFactory {
private Object target;
public ProxyFactory(Object target){
this.target = target;
}
public Object getProxyInstance(){
//使用反射的知识
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始ProxyFactory");
Object value = method.invoke(target,args);
System.out.println("开始二");
return value;
}
});
}
}
优点：真实主题类只用关注实际的逻辑业务，而无需关注非本职工作。
装饰模式
定义：动态地给一个对象添加额外的职责，装饰模式比生成子类更加灵活。
public class Decoration {
public static void main(String[] args){
YangGuo yangGuo = new YangGuo();
HongQiGong hongQiGong = new HongQiGong(yangGuo);
hongQiGong.attackMagic();
}
}
//抽象组件
abstract class Swordsman{
abstract void attackMagic();
}
//组件具体的实现类
class YangGuo extends Swordsman{
@Override
void attackMagic() {
System.out.println("杨过使用全真剑法");
}
}
//抽象装饰者
abstract class Master extends Swordsman{
private Swordsman swordsman;
public Master(Swordsman swordsman){
this.swordsman = swordsman;
}
@Override
void attackMagic() {
swordsman.attackMagic();
}
}
//装饰者具体实现类
class HongQiGong extends Master{
@Override
void attackMagic() {
super.attackMagic();
teachAttackMagic();
}
public HongQiGong(Swordsman swordsman) {
super(swordsman);
}
public void teachAttackMagic(){
System.out.println("洪七公打狗棒");
System.out.println("杨过使用打狗棒");
}
}
优点：符合开放封闭原则，扩展灵活性。
缺点：易出错，装饰层次不能修饰层数过多，否则影响效率。
外观模式
定义：要求一个子系统的外部与内部通信必须通过一个统一的对象进行，此模式下提供一个高层接口，使得子系统便于使用。
简单实例：
//客户端调用
public class OutSee {
public static void main(String[] args){
Man man = new Man();
//这个人使用降魔掌和太极拳
man.TaiJiQuan();
man.XiangMoZhang();
}
}
//子系统
class ZhaoShi{
public void TaiJiQuan(){
System.out.println("使用招式太极拳");
}
public void QiShangQuan(){
System.out.println("使用七伤拳");
}
public void XiangMoZhang(){
System.out.println("使用降魔掌");
}
}
//子系统
class LeiGong{
public void JiuYing(){
System.out.println("使用九阴真经");
}
public void JiuYang(){
System.out.println("使用九阳神功");
}
}
//外观类
class Man{
private ZhaoShi zhaoShi;
private LeiGong leiGong;
public Man(){
zhaoShi = new ZhaoShi();
leiGong = new LeiGong();
}
//使用太极拳先使用九阳神功
public void TaiJiQuan(){
leiGong.JiuYang();
zhaoShi.TaiJiQuan();
}
//使用降魔掌必须先使用九阴神功
public void XiangMoZhang(){
leiGong.JiuYing();
zhaoShi.XiangMoZhang();
}
}
优点：减少相互依赖，降低耦合性，加强了安全性。
缺点：不符合开放原则。
享元模式
定义：使用共享对象有效地支持大量细粒度对象。
//客户端调用
public class ShareYuan {
public static void main(String[] args){
Goods goods1 = GoodsFactory.getGoods("oneplus7");
goods1.showGoodPrice("32g");
Goods goods2 = GoodsFactory.getGoods("oneplus7");
goods1.showGoodPrice("32g");
Goods goods3 = GoodsFactory.getGoods("oneplus7");
goods1.showGoodPrice("128g");
}
}
//抽象的享元角色
interface IGoods{
public void showGoodPrice(String version);
}
//具体的享元对象
class Goods implements IGoods{
private String name;
private String version;
Goods(String name){
this.name = name;
}
@Override
public void showGoodPrice(String version) {
if(version.equals("32g")){
System.out.println("价格为2365");
}else if(version.equals("128g")){
System.out.println("价格为5999");
}
}
}
//享元工厂
class GoodsFactory{
private static Map pool = new HashMap<>();
public static Goods getGoods(String name){
if(pool.containsKey(name)){
System.out.println("使用缓存，key为"+name);
return pool.get(name);
}else {
Goods goods = new Goods(name);
pool.put(name,goods);
System.out.println("创建商品，key为"+name);
return goods;
}
}
}
使用场景：
- 系统中有大量相似对象。
- 需要缓存池。
策略模式
定义：定义一系列的算法，把每一个算法封装起来，而且使它们可以相互转换。策略模式独立于使用它的用户。
简单实例：
public class Concrete {
public static void main(String args[]){
Context context;
context = new Context(new WeakRivalStrategy());
context.fighting();
context = new Context(new CommonRiverStrategy());
context.fighting();
}
}
//定义策略接口
interface FightingStrategy{
public void fighting();
}
//具体策略实现
class WeakRivalStrategy implements FightingStrategy{
@Override
public void fighting() {
System.out.println("遇到较弱的对手");
}
}
class CommonRiverStrategy implements FightingStrategy{
@Override
public void fighting() {
System.out.println("遇到普通对手");
}
}
//上下文对象
class Context{
private FightingStrategy fightingStrategy;
public Context(FightingStrategy fightingStrategy){
this.fightingStrategy = fightingStrategy;
}
public void fighting(){
fightingStrategy.fighting();
}
}
优点：可以避免使用多重条件语句，易于扩展。
缺点：每个策略类都是一个类，复用性小；和迪米特原则违背。
观察者模式
定义：定义对象间一种一对多的依赖关系，每当一个对象改变状态时，则所有依赖于它的对象都会得到通知并被自动更新。
public class ObserveDo {
public static void main(String args[]){
SubscriptionSubject subscriptionSubject = new SubscriptionSubject();
WeixinUser user1 = new WeixinUser("jake");
WeixinUser user2 = new WeixinUser("tom");
WeixinUser user3 = new WeixinUser("herry");
subscriptionSubject.attach(user1);
subscriptionSubject.attach(user2);
subscriptionSubject.attach(user3);
subscriptionSubject.notify("hahahahahaa");
}
}
//抽象观察者
interface Observer{
public void update(String message);
}
//具体的观察者
class WeixinUser implements Observer{
private String name;
public WeixinUser(String name){
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name+"-"+message);
}
}
//抽象被观察者
interface Subject{
public void attach(Observer observer);
public void detach(Observer observer);
public void notify(String message);
}
//具体被观察者
class SubscriptionSubject implements Subject{
private List observeDos = new ArrayList<>();
@Override
public void attach(Observer observer) {
observeDos.add(observer);
}
@Override
public void detach(Observer observer) {
observeDos.remove(observer);
}
@Override
public void notify(String message) {
for(Observer observer : observeDos){
observer.update(message);
}
}
}
优点：观察者和被观察者之间抽象耦合，容易拓展。
缺点：开发效率低下。