Android-设计模式

Android 设计模式 2019/03/02

1.单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例

  • 优点：比较耗内存的类，如果只实例化一次，可大大提高性能保存运行内存中只有一个实例存在的内存中

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test {
    private static volatile  Test instance=null;
//volatile告诉寄存器值是不确定的,要到内存中取,读取都是在内存中进行
    public static Test getInstance() {
        if (instance==null){
            synchronized (Test.class){
                if (instance==null){
                    instance=new Test();
                }
            }
        }
        return instance;
    }
}

2.建造者（Builder）模式

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

  • 优点：增加可读性
  • Android中的应用：可以看到Android中有很多都是用了Builder模式，例如：AlertDialog等等，第三方库okHttp，Glide

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//use
Person person=new Person.Builder()
			.address("广州")
			.age(24)
			.name("rhyme")
			.build();

//Person.java
public class Person {
    private String name;
    private int age;
    private String address;
    private Person(Builder builder){
        this.name=builder.name;
        this.age=builder.age;
        this.address=builder.address;
    }
    public static class Builder{
        private String name;
        private int age;
        private String address;
        public Builder name(String name){
            this.name=name;
            return this;
        }
        Builder age(int age){
            this.age=age;
            return this;
        }
         Builder address(String address){
            this.address=address;
            return this;
        }
         Person build(){
            return new Person(this);
        }
    }
}

3.观察者模式

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变，所依赖它的对象都能接收到通知并自动更新

  • Android中的应用：类似add监听和register监听本质上是一对多，使用了观察者的有：广播，recyclerview滚动监听，eventBuns，RxJava，ContentResoler

示例：

  • 1.新建一个被观察者，这里可以被多个观察者观察

    1
    2
    3
    4
    5
    class Person extends Observable
    下面的跟新建一个实体类差不多,只不过
    在set/get方法中的set方法添加方法setChanged()
    	setChanged()方法设置改变了
    	notifyObservers()方法通知观察者我改变了,并且会调用update()方法

  • 2.新建一个观察者，用于观察一个被观察者

    1
    2
    3
    4
    5
    class PersonObserver implements Observer
    //重写它update的方法,重构里传入的参数都为update做铺垫
     @Override
     public void update(Observable observable, Object o)
    //上面有两个参数第一个为被观察者,可以强转为Person,第二个参数未知

  • 3.被观察者添加观察者

    1
    Person.addObserver(PersonObserver);

  • 4.当被观察者发生改变时，会通知观察者

    1
    Person.setName("hello");//观察者的update方法会触发

4.原型模式

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象

  • 在Android中的应用：bundle，intent，okhttp中的okHttpClient

示例:

  • 实例浅拷贝

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    public class Person implements Cloneable{
        private String name;
        private String age;
        private String address;
        public Person(){
        }
        public Person(String name, String age, String address) {
            this.name = name;
            this.age = age;
            this.address = address;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }

        public String getAge() {
            return age;
        }
        public void setAge(String age) {
            this.age = age;
        }
        public String getAddress() {
            return address;
        }
        public void setAddress(String address) {
            this.address = address;
        }
    //浅拷贝关键代码
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Person person=null;
            person=(Person) super.clone();
            person.name=this.name;
            person.address=this.address;
            person.age=this.age;
            return person;
        }
    //浅拷贝关键代码
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age='" + age + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }

  • 深拷贝

    当实体类中有一个成员变量的值是数组，我们需要在clone中赋予该值的时候使用

    1
    this.数组.clone();

5.策略模式

定义了一些列的算法，并且每个算法封装起来，而且使他们还可以相互替换，让算法独立于使用它的客户而独立变换，定义一个策略接口，当需要新添加时，只需要实现这个接口，而完全不用修改源码

  • Android中的应用：动画的差值器

示例：

  • 定义一个接口

    1
    2
    3
    public interface Strategy {
        void Speek();
    }

  • 新增功能实现这个方法

    1
    2
    3
    4
    5
    6
    public class China implements Strategy {
        @Override
        public void Speek() {
            System.out.println("我的名字叫中国");
        }
    }

  • 添加包装类，包装类里的成员变量为这个接口，还有方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    public class StrategyContext {
        Strategy strategy;
        public Strategy getStrategy() {
            return strategy;
        }
        public void setStrategy(Strategy strategy) {
            this.strategy = strategy;
        }
        public void speek(){
            if (strategy!=null){
                strategy.Speek();
            }
        }
    }

  • 调用

    1
    2
    3
    StrategyContext strategyContext=newStrategyContext();
    strategyContext.setStrategy(new China());
    strategyContext.speek();

6.工厂模式

定义一个用于创建对象的接口，让子类实例化那个类，工厂方法使用一个类的实例化延迟到其子类，对同一个接口的实现类进行管理和实例化创建

  • Android中的应用：AsyncTask.BitmapFactory

示例：

  • 1.通过传入的参数，生成实例（简单工厂）但违背了封闭原则

    • 新建一个工厂类 

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      public class Factory {
      	public static BasePerson creator(int which){
      		switch (which) {
      		case 1:
      			return new Teacher();
      		case 2:
      			return new Student();
      		default:
      			return null;
      		}
      	}
      }

    • 新建一个接口，接口里面只有一个方法

      1
      2
      3
      public interface BasePerson {
      	void Speek();
      }

    • 新建两个实现了该接口的类

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      public class Teacher implements BasePerson{
      	@Override
      	public void Speek() {
      		// TODO Auto-generated method stub
      		System.out.println("我是教师");
      	}
      }
      public class Student implements BasePerson {
      	@Override
      	public void Speek() {
      		// TODO Auto-generated method stub
      		System.out.println("我是学生");
      	}
      }

    • 调用时：

      1
      2
      3
      4
      BasePerson basePerson = Factory.creator(1);
      basePerson.Speek();
      basePerson=Factory.creator(2);
      basePerson.Speek();

  • 2.如果比较复杂，有多个不同的子类（抽象工厂）

    • 将上面的工厂变成抽象类，将共同部分进行封装

      1
      2
      3
      4
      5
      public abstract class Factory2 {
      	//必须实现的方法,这两个方法里面所创建的对象有一定的联系
      	public abstract BasePerson creatorPerson();
      	public abstract BaseAnimator creatorAnimator();
      }

    • 创建一个family的工厂类，有一个人和动物

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      /**
       * 学生和狗有一定的联系,一个家庭对应一个工厂
       */
      public class StudentFamilyFactory extends Factory2{
      	private Student student=new Student();
      	private Dog dog=new Dog();
      	@Override
      	public BasePerson creatorPerson() {
      		// TODO Auto-generated method stub
      		return student;
      	}
      	@Override
      	public BaseAnimator creatorAnimator() {
      		// TODO Auto-generated method stub
      		return dog;
      	}
      }
转载声明：商业转载请联系作者获得授权,非商业转载请注明出处 © rhyme_lph

评论系统未开启，无法评论！

访问量:   |   访客数:
Copyright © 2019