Java设计开发模式

java开发设计模式
java开发设计模式2

1. 单例模式

   是一种常用的软件设计模式，在它的核心结构中值包含一个被称为单例的特殊类。一个类只有一个实例，即一个类只有一个对象实例。

    package design.pattern;

    public class Singleton {

        private static Singleton singleton;

        private Singleton() {}

        public static Singleton getInstance() {

            if (singleton == null) {

                synchronized (Singleton.class) {

                    singleton = new Singleton();

                }

            }

            return singleton;

        }

    }

java开发中常用的几种设计模式及代码例子

2. 工厂模式

   根据需要返回我们的对象。应用比较熟悉的场景就是spring配置文件了。

    package design.pattern;

    public class MyFactory {

    public static final int TYPE_MI = 1;// 大米

    public static final int TYPE_YU = 2;// 油

    public static final int TYPE_SC = 3;// 蔬菜

    public static Food getFoods(int foodType) {

    switch (foodType) {

    case TYPE_MI:

    return new DaMi();

    case TYPE_YU:

    return new You();

    case TYPE_SC:

    default:

    return new ShuCai();

    }

    }

    }

    abstract class Food {

    }

    class DaMi extends Food {

    }

    class You extends Food {

    }

    class ShuCai extends Food {

    }

java开发中常用的几种设计模式及代码例子

3. 适配器模式

   将一个类的接口转换成客户希望的另外一个接口。通俗地讲，就是在2个类之间做了一个衔接。比如你在调用A类的doSomething方法，实际上内部实现调用了B类的doSomething方法。

    package design.pattern;

    public class MyAdapter {

    private MyAdapterImpl adapterImpl;

    public MyAdapter(MyAdapterImpl myAdapterImpl) {

    this.adapterImpl = myAdapterImpl;

    }

    public void doSomething() {

    adapterImpl.doSomething();

    }

    public static void main(String args[]) {

    new MyAdapter(new MyAdapterImpl()).doSomething();

    }

    }

    class MyAdapterImpl {

    public void doSomething() {

    }

    }

java开发中常用的几种设计模式及代码例子

4. 代理模式

   它的定义是：代理模式给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。Java的反射机制，很多地方就用了代理模式来实现。

    package design.pattern;

    import java.lang.reflect.InvocationHandler;

    import java.lang.reflect.Method;

    import java.lang.reflect.Proxy;

    public class DynamicProxyMain {

    public static void main(String[] args) {

    Person smallPerson = new Child();

    Person proxyBuyHouse = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(),

    new Class[] { Person.class }, new DynamicProxyHandler(smallPerson));

    proxyBuyHouse.eat();

    }

    }

    interface Person {

    void eat();

    }

    class Child implements Person {

    @Override

    public void eat() {

    // 小孩吃什么

    System.out.println("eating");

    }

    }

    class DynamicProxyHandler implements InvocationHandler {

    private Object object;

    public DynamicProxyHandler(final Object object) {

    this.object = object;

    }

    @Override

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

    System.out.println("调用前日志监控");

    Object result = method.invoke(object, args);

    System.out.println("调用后日志监控");

    return result;

    }

    }

java开发中常用的几种设计模式及代码例子

5. 监听模式

   当事件源触发某种行为，会自动执行事件监听器里面相应的方法。

   Java监听模式右三个部分组成：事件源、事件对象、事件监听器。

    package design.pattern;

    public class ListenerTest {

    public static void main(String[] args) {

    MyListener myListener = new MyListener();

    MyPerson person = new MyPerson();

    person.addEatListener(myListener);

    person.eat();

    }

    }

    //事件源

    class MyPerson{

    private Listener listener;//监听器引用

    //给事件源添加监听器

    public void addEatListener(Listener listener) {

    this.listener = listener;

    }

    public void eat() {

    //吃了很多

    if(listener != null) {

    Event event=new Event() ;

    event.setPerson(this);

    listener.isThinking(event);//监听吃饭时，想了什么

    }

    }

    }

    //事件

    class Event {

    private MyPerson person;// 事件源的引用

    public MyPerson getPerson() {

    return person;

    }

    public void setPerson(MyPerson person) {

    this.person = person;

    }

    }

    interface Listener {

    public void isThinking(Event event);

    }

    class MyListener implements Listener {

    @Override

    public void isThinking(Event event) {

    System.out.println(" is isThinking many things !");

    }

    }

java开发中常用的几种设计模式及代码例子

6. 装饰器模式

   简单说就是不改变现有类的结构前提下，扩展它的功能。用别的类来增加原有类的功能。

    package design.pattern;

    public class MyDecorator {

    public static void main(String[] args) {

    Animal animal= new SmallDog(new Pet());

    animal.eat();

    }

    }

    interface Animal {

    public void eat();

    }

    class Pet implements Animal {

    @Override

    public void eat() {

    System.out.println("eat food");

    }

    }

    class Dog implements Animal{

    protected Animal animal;

    public Dog(Animal animal) {

    this.animal = animal;

    }

    @Override

    public void eat() {

    this.animal.eat();

    }

    }

    class SmallDog extends Dog{

    public SmallDog(Animal animal) {

    super(animal);

    }

    public void eat() {

    System.out.println("eat other food ");

    this.animal.eat();

    }

    }

java开发中常用的几种设计模式及代码例子

java开发中常用的几种设计模式及代码例子

设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则就是对功能扩展开放，对修改代码关闭。系统扩展功能是，不需要修改原来的代码，只需新增代码便可。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，能使用父类的地方一定可以使用子类替代。 LSP是继承复用的基石，里氏代换原则是对“开-闭”原则的补充。

3、依赖倒转原则（Dependence Inversion Principle）

是开闭原则的基础，具体内容：实现接口编程，依赖于抽象类或接口而不依赖于具体类，系统功能扩展时可以使用具体类扩展。

4、接口隔离原则（Interface Segregation Principle）

使用多个隔离的接口，比使用单个接口要好，原则是：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。