我觉得设计模式不是这么学习的,需要有一定的代码量之后才能真切明白其中的奥妙,但不得不走这个快捷径,所以只能掌握其中的一部分
厚颜无耻的只会复制黏贴!
https://www.cnblogs.com/malihe/p/6891920.html
java的设计模式大体上分为三大类:
创建型模式(5种):工厂方法模式,抽象工厂模式,单例模式,建造者模式,原型模式。
结构型模式(7种):适配器模式,装饰器模式,代理模式,外观模式,桥接模式,组合模式,享元模式。
行为型模式(11种):策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
创建型
抽象工厂模式 http://www.cnblogs.com/java-my-life/archive/2012/03/28/2418836.html
工厂方法 http://www.cnblogs.com/java-my-life/archive/2012/03/25/2416227.html
建造者模式 http://www.cnblogs.com/java-my-life/archive/2012/04/07/2433939.html
原型模式 http://www.cnblogs.com/java-my-life/archive/2012/04/11/2439387.html
单态模式 http://www.cnblogs.com/java-my-life/archive/2012/03/31/2425631.html
结构型
适配器模式 http://www.cnblogs.com/java-my-life/archive/2012/04/13/2442795.html
桥接模式 http://blog.csdn.net/jason0539/article/details/22568865
组合模式 http://blog.csdn.net/jason0539/article/details/22642281
外观模式 http://blog.csdn.net/jason0539/article/details/22775311
装饰者模式 http://www.cnblogs.com/java-my-life/archive/2012/04/20/2455726.html
享元模式 http://www.cnblogs.com/java-my-life/archive/2012/04/26/2468499.html
代理模式 http://www.cnblogs.com/java-my-life/archive/2012/04/23/2466712.html
行为型
责任链模式 http://blog.csdn.net/zhouyong0/article/details/7909456
命令模式 http://www.cnblogs.com/java-my-life/archive/2012/06/01/2526972.html
解释器模式 http://www.cnblogs.com/java-my-life/archive/2012/06/19/2552617.html
迭代模式 http://www.cnblogs.com/java-my-life/archive/2012/05/22/2511506.html
中介者模式 http://blog.csdn.net/chenhuade85/article/details/8141831
备忘录模式 http://www.cnblogs.com/java-my-life/archive/2012/06/06/2534942.html
观察者模式 http://www.cnblogs.com/java-my-life/archive/2012/05/16/2502279.html
状态模式 http://www.cnblogs.com/java-my-life/archive/2012/06/08/2538146.html
策略模式 http://www.cnblogs.com/java-my-life/archive/2012/05/10/2491891.html
模板方法模式 http://www.cnblogs.com/java-my-life/archive/2012/05/14/2495235.html
访问者模式 http://www.cnblogs.com/java-my-life/archive/2012/06/14/2545381.html生产者消费者模式https://monkeysayhi.github.io/2017/10/08/Java%E5%AE%9E%E7%8E%B0%E7%94%9F%E4%BA%A7%E8%80%85-%E6%B6%88%E8%B4%B9%E8%80%85%E6%A8%A1%E5%9E%8B/
设计模式遵循的原则有6个:
1、开闭原则(Open Close Principle)
对扩展开放,对修改关闭。
2、里氏代换原则(Liskov Substitution Principle)
只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。
3、依赖倒转原则(Dependence Inversion Principle)
这个是开闭原则的基础,对接口编程,依赖于抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)
使用多个隔离的借口来降低耦合度。
5、迪米特法则(最少知道原则)(Demeter Principle)
一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
6、合成复用原则(Composite Reuse Principle)
原则是尽量使用合成/聚合的方式,而不是使用继承。继承实际上破坏了类的封装性,超类的方法可能会被子类修改。
空谈设计模式很枯燥,能结合自己熟悉的实际实现才能更深入的理解个设计模式的好处,设计模式也是为了解决某些问题而产生的
责任链模式:java种异常处理,当发生异常时不断地向上层抛出;
适配器模式:listview 和recyclerview 中 aapter, Adapter并不是经典的适配器模式,但是却是对象适配器模式的优秀示例,也很好的体现了面向对象的一些基本原则。这里的Target角色和Adapter角色融合在一起,Adapter中的方法就是目标方法;而Adaptee角色就是ListView的数据集与Item View,Adapter代理数据集,从而获取到数据集的个数、元素。
1.简单工厂模式和抽象工厂模式
通过一个方法 可以返回不通的类对象,比如有n个food类 那么如何通过一个方法返回不同的food呢? 那我们造个factory来生产food,我们只需要跟工厂提交订单(传递参数),工厂给我们返回想要的food不就ok了吗?
简单工厂模式 code如下:
interface food{}
class A implements food{}
class B implements food{}
class C implements food{}
public class StaticFactory {
private StaticFactory(){}
public static food getA(){ return new A(); }
public static food getB(){ return new B(); }
public static food getC(){ return new C(); }
}
class Client{
//客户端代码只需要将相应的参数传入即可得到对象
//用户不需要了解工厂类内部的逻辑。
public void get(String name){
food x = null ;
if ( name.equals("A")) {
x = StaticFactory.getA();
}else if ( name.equals("B")){
x = StaticFactory.getB();
}else {
x = StaticFactory.getC();
}
}
}
抽象工厂模式code
一个基础接口定义了功能,每个实现接口的子类就是产品,然后定义一个工厂接口,实现了工厂接口的就是工厂,这时候,接口编程的优点就出现了,我们可以新增产品类(只需要实现产品接口),只需要同时新增一个工厂类,客户端就可以轻松调用新产品的代码。
抽象工厂的灵活性就体现在这里,无需改动原有的代码,毕竟对于客户端来说,静态工厂模式在不改动StaticFactory类的代码时无法新增产品,如果采用了抽象工厂模式,就可以轻松的新增拓展类。
interface food{}
class A implements food{}
class B implements food{}
interface produce{ food get();}
class FactoryForA implements produce{
@Override
public food get() {
return new A();
}
}
class FactoryForB implements produce{
@Override
public food get() {
return new B();
}
}
public class AbstractFactory {
public void ClientCode(String name){
food x= new FactoryForA().get();
x = new FactoryForB().get();
}
}
2.单例模式
为什么要有单例模式?
code:
懒汉和饿汉两种方式,其中饿汉式当需要类对象时才创建类对象,会出现线程安全问题;而饿汉式在类加载时会创建对象,不会有线程安全问题但是占用内存。
实现单例要考虑线程安全和内存占用问题: 下面是通过 静态内部类的实现的,使用静态内部类实现既考虑了线程安全有考虑内存占用问题,只有再使用静态内部类时才会加载静态内部类,所以才会创建静态内部类的类对象,正因为是加载的时候就创建了此对象,所以就线程安全了呗!
除此还有使用枚举类实现单例模式!按照《高效Java 第二版》中的说法:单元素的枚举类型已经成为实现Singleton的最佳方法。
public class Singleton {
private Singleton(){}
private static class SingletonBuild{
private static Singleton value = new Singleton();
}
public Singleton getInstance(){ return SingletonBuild.value ;}
}