http://www.runoob.com/design-pattern/observer-pattern.html
1，工厂模式
工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。
public interface Sender {
public void Send();
}
其次，创建实现类：
public class MailSender implements Sender {
@Override
public void Send() {
System.out.println("this is mailsender!");
}
}
public class SmsSender implements Sender {
@Override
public void Send() {
System.out.println("this is sms sender!");
}
}
public class SendFactory {
public static Sender produceMail(){
return new MailSender();
}
public static Sender produceSms(){
return new SmsSender();
}
}
public class FactoryTest {
public static void main(String[] args) {
Sender sender = SendFactory.produceMail();
sender.Send();
}
}
2，单例模式
单例对象（Singleton）是一种常用的设计模式。在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：
1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。
2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。
3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。
饿汉式-程序加载class文件的时候对象就会被创建，线程不安全
private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance; }
懒汉式-使用的时候才会被创建，线程安全双重锁
public static Singleton getInstance() {
if (instance == null) {
synchronized (instance) {
if (instance == null) {
instance = new Singleton(); } } }
return instance; }
3，Bulider模式
public class PersonThree {
//固定不变的对象，一般变量需要声明为 final
private final String mName; //必选，final 类型需要在 构造器中初始化，不允许不初始化它的构造器存在
private String mLocation; //可选
private String mJob; //可选
private String mHabit; //可选
/**
* 构造方法的参数是它的 静态内部类，使用静态内部类的变量一一赋值
* @param builder
*/
public PersonThree(Builder builder) {
this.mName = builder.mName;
this.mLocation = builder.mLocation;
this.mJob = builder.mJob;
this.mHabit = builder.mHabit;
}
/**
* PersonTree 的静态内部类，成员变量和 PersonTree 的一致
*/
public static class Builder{
private final String mName; //必选，final 类型需要在 构造器中初始化，不允许不初始化它的构造器存在
private String mLocation; //可选
private String mJob; //可选
private String mHabit; //可选
/**
* 含必选参数的构造方法
* @param name
*/
public Builder(String name) {
mName = name;
}
public Builder setLocation(String location) {
mLocation = location;
return this;
}
public Builder setJob(String job) {
mJob = job;
return this;
}
public Builder setHabit(String habit) {
mHabit = habit;
return this;
}
/**
* 最终构建方法，返回一个 PersonTree 对象，参数是当前 Builder 对象
* @return
*/
public PersonThree build(){
return new PersonThree(this);
}
}
}
调用：
new PersonThree.Builder("shixinzhang")
.setLocation("Shanghai")
.setJob("Android Develop")
.setHabit("LOL")
.build();
4,适配器模式
即列表传入不同的数据显示不同的列表展示
5，代理模式
代理模式就是多一个代理类出来，替原对象进行一些操作，比如处理按钮的多次点击
public class ClickProxy implements View.OnClickListener {
private View.OnClickListenerorigin;
private long last_click =0;
private long time_ms =1000; //ms
private IAgainmIAgain;
public ClickProxy(View.OnClickListener origin, long time_ms, IAgain again) {
this.origin = origin;
this.mIAgain = again;
this.time_ms = time_ms;
}
public ClickProxy(View.OnClickListener origin) {
this.origin = origin;
}
@Override
public void onClick(View v) {
if (System.currentTimeMillis() -last_click >=time_ms) {
origin.onClick(v);
last_click = System.currentTimeMillis();
}else {//重复点击
if (mIAgain !=null)mIAgain.onAgain();
}
}
public interface IAgain {
void onAgain();//重复点击
}
}
btn_notification.setOnClickListener(new ClickProxy(new View.OnClickListener() {
@Override
public void onClick(View v) {
}}));
6，观察者模式
按钮点击
刚学安卓的时候 ，按钮点击是必不可少的 ，我们先来回顾一下其中的套路
相信大家对此都不陌生了
如果你连这个都没有写的很熟练 ，那此篇文章可能不适合你了
//寻找控件 Button bt = (Button) findViewById(R.id.bt);//实例化一个监听 View.OnClickListener clickListener =newView.OnClickListener() {@OverridepublicvoidonClick(View view){//点击事件 //your code } };//为按钮控件设置点击监听 bt.setOnClickListener(clickListener );
当然这样做的目的是为了更好的理解观察者模式
在这里 我们称 Button 为 被观察者 ( Observable )
这个单词还是很重要的 RxJava 里面还会用到
当然可想而知 OnClickListener 就是观察者 ( Observer ) 了
被观察者可以有多个观察者 这个叫做订阅机制 (Subscribe)
当被观察者的状态发生改变 观察者就做出相应的动作
这个就叫做 观察者模式
7，生产者消费者
package producerConsumer;
//wait 和 notify
public class ProducerConsumerWithWaitNofity {
public static void main(String[] args) {
Resource resource = new Resource();
//生产者线程
ProducerThread p1 = new ProducerThread(resource);
ProducerThread p2 = new ProducerThread(resource);
ProducerThread p3 = new ProducerThread(resource);
//消费者线程
ConsumerThread c1 = new ConsumerThread(resource);
//ConsumerThread c2 = new ConsumerThread(resource);
//ConsumerThread c3 = new ConsumerThread(resource);
p1.start();
p2.start();
p3.start();
c1.start();
//c2.start();
//c3.start();
}
}
/**
* 公共资源类
* @author
*
*/
class Resource{//重要
//当前资源数量
private int num = 0;
//资源池中允许存放的资源数目
private int size = 10;
/**
* 从资源池中取走资源
*/
public synchronized void remove(){
if(num > 0){
num--;
System.out.println("消费者" + Thread.currentThread().getName() +
"消耗一件资源，" + "当前线程池有" + num + "个");
notifyAll();//通知生产者生产资源
}else{
try {
//如果没有资源，则消费者进入等待状态
wait();
System.out.println("消费者" + Thread.currentThread().getName() + "线程进入等待状态");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 向资源池中添加资源
*/
public synchronized void add(){
if(num < size){
num++;
System.out.println(Thread.currentThread().getName() + "生产一件资源，当前资源池有"
+ num + "个");
//通知等待的消费者
notifyAll();
}else{
//如果当前资源池中有10件资源
try{
wait();//生产者进入等待状态，并释放锁
System.out.println(Thread.currentThread().getName()+"线程进入等待");
}catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
/**
* 消费者线程
*/
class ConsumerThread extends Thread{
private Resource resource;
public ConsumerThread(Resource resource){
this.resource = resource;
}
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
resource.remove();
}
}
}
/**
* 生产者线程
*/
class ProducerThread extends Thread{
private Resource resource;
public ProducerThread(Resource resource){
this.resource = resource;
}
@Override
public void run() {
//不断地生产资源
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
resource.add();
}
}
}
网友评论