JAVA设计模式总结

傷城~ 2022-03-19 04:44 150阅读 0赞

单例设计模式：保证类在内存中只有一个对象。
    *
    * * 如何保证类在内存中只有一个对象呢？
    *  * (1)控制类的创建，不让其他类来创建本类的对象。private
    *  * (2)在本类中定义一个本类的对象。Singleton s;
    *  * (3)提供公共的访问方式。  public static Singleton getInstance(){return s}
    * * 单例写法两种：
    *  * (1)饿汉式 开发用这种方式。

public class testThread1 {
        public static void main(String []args){
            
            Single s1=Single.s;
            Single s2=Single.s;
            System.out.println(s1==s2);              //成员变量被私有
            /*
            Single s1=Single.getS();
            Single s2=Single.getS();
            System.out.println(s1==s2);*/
        }
    }
    
    //饿汉式
    
    class Single{
        private Single() {          //1.私有该类的构造方法，其他类不能访问该构造
        }
        private static Single s=new Single();            //2.在本类中创建本类对象
    
        public static Single getS() {                   //3.对外提供公共的访问方法来啊获取实例
            return s;
        }
    }

*  * (2)懒汉式 面试写这种方式。多线程的问题？

//懒汉式
    
    class Single{
        private Single() {          //1.私有该类的构造方法，其他类不能访问该构造
        }
        private static Single s;            //2.在本类中声明一个引用
    
        public static Single getS() {                   //3.对外提供公共的访问方法来啊获取实例
            if (s==null){
                s=new Single();
            }
            return s;
        }
    }

*    (3)第三种格式

class Single{
        private Single() {          //1.私有该类的构造方法，其他类不能访问该构造
        }
        private static final Single s=new Single();            //2.在本类中声明一个对象
    }

饿汉式与懒汉式区别
    * 1.饿汉式是空间换时间
    * 懒汉式是时间换空间
    *
    * 2.在多线程访问时，饿汉式不会创建多个对象，
    * 而懒汉式有可能会创建多个对象

A:简单工厂模式概述
    *  * 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
    * * B:优点
    *  * 客户端不需要在负责对象的创建，从而明确了各个类的职责
    * * C:缺点
    *  * 这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护
    * * D:案例演示
    *  * 动物抽象类：public abstract Animal { public abstract void eat(); }

package com.xy.bean;
    
    /**
     * @Classname Animal
     * @Description TODO
     * @Date 2019/2/14 0014 19:13
     * @Created by Administrator
     * @Version 1.0
     */
    public abstract class Animal {
        public abstract void eat();
    }

*  * 具体狗类：public class Dog extends Animal {}

package com.xy.bean;
    
    /**
     * @Classname Dog
     * @Description TODO
     * @Date 2019/2/14 0014 19:14
     * @Created by Administrator
     * @Version 1.0
     */
    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗吃肉");
        }
    }

*  * 具体猫类：public class Cat extends Animal {}

package com.xy.bean;
    
    /**
     * @Classname Cat
     * @Description TODO
     * @Date 2019/2/14 0014 19:13
     * @Created by Administrator
     * @Version 1.0
     */
    public class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }

*  * 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。

package com.xy.Model;
    
    import com.xy.bean.Animal;
    import com.xy.bean.Cat;
    import com.xy.bean.Dog;
    
    /**
     * @Classname AnimalFactory
     * @Description TODO
     * @Date 2019/2/14 0014 19:17
     * @Created by Administrator
     * @Version 1.0
     */
    public class AnimalFactory {
    //    public static Cat creatCat(){
    //        return new Cat();
    //    }
    //    public static Dog creatDog(){
    //        return new Dog();
    //    }
        //发现方法定义很多，复用性很差
        public static Animal creatAnimal(String name) {
            if (name.equals("cat")) {
                return new Cat();
            } else if (name.equals("dog")) {
                return new Dog();
            }
            else return null;
        }
    }

测试类

public class testModel1 {
        public static void main(String []args){
            /*
            Cat c=AnimalFactory.creatCat();
            Dog d=AnimalFactory.creatDog();
            System.out.println(c);
            System.out.println(d);
            */
            Cat c=(Cat) AnimalFactory.creatAnimal("cat");
            Dog d=(Dog) AnimalFactory.creatAnimal("dog");
            System.out.println(c);
            c.eat();
            System.out.println(d);
            d.eat();
        }
    }

A:工厂方法模式概述
    *  * 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
    * * B:优点
    *  * 客户端不需要在负责对象的创建，从而明确了各个类的职责，
    *  如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
    * * C:缺点
    *  * 需要额外的编写代码，增加了工作量
    * * D:案例演示

Factory接口:

package com.xy.Model;
    
    import com.xy.bean.Animal;
    
    public interface Factory {
        public Animal creatAnimal();
    }

CatFactory类:

package com.xy.Model;
    
    import com.xy.bean.Animal;
    import com.xy.bean.Cat;
    
    /**
     * @Classname CatFactory
     * @Description TODO
     * @Date 2019/2/14 0014 19:35
     * @Created by Administrator
     * @Version 1.0
     */
    public class CatFactory implements Factory{
        @Override
        public Animal creatAnimal() {
            return new Cat();
        }
    }

DogFactory类:

package com.xy.Model;
    
    import com.xy.bean.Animal;
    import com.xy.bean.Dog;
    
    /**
     * @Classname DogFactory
     * @Description TODO
     * @Date 2019/2/14 0014 19:35
     * @Created by Administrator
     * @Version 1.0
     */
    public class DogFactory implements Factory {
        @Override
        public Animal creatAnimal() {
            return new Dog();
        }
    }

**目录**

3.适配器设计模式

--------------------

a.什么是适配器
    *  * 在使用监听器的时候, 需要定义一个类事件监听器接口.
    *  * 通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
    *  * 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.
    * * b.适配器原理
    *  * 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
    *  * 适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的
    *  * 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.

public class testModel3 {
        public static void main(String []args){
            Student s=new Student();
            s.eat();
        }
    }
    interface student {
        public void eat();
        public void study();
        public void play();
        public void work();
    }
    class Root implements student{
        @Override
        public void eat() {
    
        }
    
        @Override
        public void study() {
    
        }
    
        @Override
        public void play() {
    
        }
    
        @Override
        public void work() {
    
        }
    }
    class Student extends Root{
        @Override
        public void eat() {
            System.out.println("吃饭");
        }
    }

模板设计模式

* * A:模版设计模式概述
    *  * 模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现
    * * B:优点和缺点
    *  * a:优点
    *     * 使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
    *  * b:缺点
    *     * 如果算法骨架有修改的话，则需要修改抽象类
    * 1,装饰
    * 2,单例
    * 3,简单工厂
    * 4,工厂方法
    * 5,适配器
    * 6,模版

public class testTemplate {
        public static void main(String []args){
            long start =System.currentTimeMillis();
            Demo d=new Demo();
            long end=System.currentTimeMillis();
            System.out.println(d.getTime());
        }
    }
    abstract class GetTime{
        public final long getTime(){
            long start =System.currentTimeMillis();
            test();
            long end=System.currentTimeMillis();
            return end-start;
        }
    
        public abstract void test();
    }class Demo extends GetTime{
        @Override
        public void test() {
            for (int i = 0; i <1000000 ; i++) {
                System.out.println("x");
            }
        }
    }