版权声明:本文为博主原创文章,转载请注明出处,谢谢! https://blog.csdn.net/u010094934/article/details/88545081
设计模式遵循的原则
1、开闭原则(Open Close Principle)对扩展开放,对修改关闭。
2、里氏代换原则(Liskov Substitution Principle)只有当衍生类可以替换掉基类,软件单位的功能不受到影响时,基类才能真正被复用,而衍生类也能够在基类的基础上增加新的行为。
3、依赖倒转原则(Dependence Inversion Principle)这个是开闭原则的基础,对接口编程,依赖于抽象而不依赖于具体。
4、接口隔离原则(Interface Segregation Principle)使用多个隔离的借口来降低耦合度。
5、迪米特法则(最少知道原则)(Demeter Principle)一个实体应当尽量少的与其他实体之间发生相互作用,使得系统功能模块相对独立。
6、合成复用原则(Composite Reuse Principle)尽量使用合成/聚合的方式,而不是使用继承。继承实际上破坏了类的封装性,超类的方法可能会被子类修改。
单例模式
//not thread safe
class Singleton1 {
private static Singleton1 instance = null;
private Singleton1() {
}
public static Singleton1 getInstance() {
if (instance == null) {
instance = new Singleton1();
}
return instance;
}
}
// thread safe
class Singleton2 {
private static Singleton2 instance = null;
private Singleton2() {
}
public static synchronized Singleton2 getInstance() {
if (instance == null) {
instance = new Singleton2();
}
return instance;
}
}
// thread safe
class Singleton3 {
private static Singleton3 instance = null;
private Singleton3() {
}
public static Singleton3 getInstance() {
if (instance == null) {
synchronized (Singleton3.class) {
if (instance == null) {
instance = new Singleton3();
}
}
}
return instance;
}
}
// thread safe use memory
class Singleton4 {
private static Singleton4 instance = new Singleton4();
private Singleton4(){
}
public static Singleton4 getInstance() {
return instance;
}
}
//thread safe inner class
class Singleton5{
private Singleton5(){
}
private static class SingletonHolder{
private final static Singleton5 instance=new Singleton5();
}
public static Singleton5 getInstance(){
return SingletonHolder.instance;
}
}
//enum is singleton object
enum Singleton6{
Instance;
}
代理模式
// use proxy mode Expansion class
public interface Proxy{
void doit();
}
class A implements Proxy {
@Override
public void doit() {
System.out.println("A do it");
}
}
class B implements Proxy{
A a = new A();
@Override
public void doit() {
a.doit();
}
}
工厂模式
public class Factory {
interface Shape{
void draw();
}
class Rectangle implements Shape{
@Override
public void draw() {
System.out.println("rectangle");
}
}
class Square implements Shape{
@Override
public void draw() {
System.out.println("square");
}
}
class Circle implements Shape{
@Override
public void draw() {
System.out.println("circle");
}
}
class ShapeFactory{
public Shape getShape(String shapeType) {
if(shapeType==null) {
return null;
}else if(shapeType.equals("circle")) {
return new Circle();
}else if(shapeType.equals("rectangle")) {
return new Rectangle();
}else if(shapeType.equals("square")) {
return new Square();
}
return null;
}
}
}
策略模式
public class Strategy {
public static void main(String[] args) {
Context context = new Context(new OperationAdd());
System.out.println(context.executeStrategy(1, 2));
context = new Context(new OperationSubstract());
System.out.println(context.executeStrategy(1, 2));
context = new Context(new OperationMultiply());
System.out.println(context.executeStrategy(1, 2));
}
}
interface C{
public int doOperation(int num1,int num2);
}
class OperationAdd implements C{
@Override
public int doOperation(int num1,int num2) {
return num1+num2;
}
}
class OperationSubstract implements C{
@Override
public int doOperation(int num1, int num2) {
return num1-num2;
}
}
class OperationMultiply implements C{
@Override
public int doOperation(int num1, int num2) {
return num1 * num2;
}
}
class Context{
private C c;
public Context(C c) {
this.c = c;
}
public int executeStrategy(int num1,int num2) {
return c.doOperation(num1, num2);
}
}