andriod observer模式

最新推荐文章于 2024-03-23 17:25:48 发布
原创 最新推荐文章于 2024-03-23 17:25:48 发布 · 450 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

在Java中通过Observable类和Observer接口实现了观察者模式。一个Observer对象监视着一个Observable对象的变化，当Observable对象发生变化时，Observer得到通知，就可以进行相应的工作。例如在文档/视图结构中，文档被修改了，视图就会得到通知。 

      java.util.Observable中有两个方法对Observer特别重要，一个是setChange()方法用来设置一个内部标志位注明数据发生了变化；一个是notifyObservers()方法会去调用一个列表中所有的Observer的update()方法，通知它们数据发生了变化。 


      Observer通过Observable的addObserver()方法把自己添加到这个列表中。这个列表虽然由Observable拥有，但Observable并不知道到底有哪些Observer正在观察等待通知。Observable只提供一个方法让Observer能把自己添加进列表，并保证会去通知Observer发生了变化。通过这种机制，可以有任意多个Observer对Observable进行观察，而不影响Observable的实现。


一个简单例子（页面切换时 修改 头尾部分）

1.TitleManager.java

package com.example.view.manager;

 

import java.util.Observable;
import java.util.Observer;
import org.apache.commons.lang3.StringUtils;
import com.example.myandriod3.ConstantValue;
import com.example.myandriod3.R;
import com.example.views.SecondUi;
import android.app.Activity;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;

public class TitleManager implements Observer 
{
 
	private RelativeLayout commonContainer;
	private RelativeLayout loginContainer;
	private RelativeLayout unLoginContainer;
	
	private ImageView goback;//  
	private ImageView help;//  
	private ImageView login;//  

	private TextView titleContent;// 
	private TextView userInfo;//
	
	
	/**
	 * 单例模式 
	 */
	private static TitleManager instance = new TitleManager();

	private TitleManager() {
	}

	public static TitleManager getInstance() {
		return instance;
	}
	
	/**
	 * 初始化
	 * @param activity
	 */
	public void init(Activity activity){
		
		commonContainer = (RelativeLayout) activity
				.findViewById(R.id.ii_common_container);
		unLoginContainer = (RelativeLayout) activity
				.findViewById(R.id.ii_unlogin_title);
		loginContainer = (RelativeLayout) activity
				.findViewById(R.id.ii_login_title);

		goback = (ImageView) activity.findViewById(R.id.ii_title_goback);
		help = (ImageView) activity.findViewById(R.id.ii_title_help);
		login = (ImageView) activity.findViewById(R.id.ii_title_login);

		titleContent = (TextView) activity.findViewById(R.id.ii_title_content);
		userInfo = (TextView) activity.findViewById(R.id.ii_top_user_info);
		
		setListener();
		
	}
	
	private void setListener() {
		goback.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				System.out.println("goback");
 
			}
		});
		help.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				System.out.println("help");

			}
		});
		/**
		 * 登陆页面
		 */
		login.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				//MiddleManager.getInstance().ChangeUi(new SecondUi(MiddleManager.getInstance().getContext()));
				MiddleManager.getInstance().ChangeUi2(SecondUi.class);
				
				//System.out.println("login");
 
			}
		});

	}
	
	public void initTitle(){
		commonContainer.setVisibility(View.GONE);
		loginContainer.setVisibility(View.GONE);
		unLoginContainer.setVisibility(View.GONE);
	}
	
	public void showCommonTitle() {
		initTitle();
		commonContainer.setVisibility(View.VISIBLE);
	}

	public void showUnLoginTitle() {
		initTitle();
		unLoginContainer.setVisibility(View.VISIBLE);
	}

	public void showLoginTitle() {
		initTitle();
		loginContainer.setVisibility(View.VISIBLE);
	}
	
	public void changeTitle(String title) {
		titleContent.setText(title);
	}

	
	//观察者模式 中  update 操作 修改 头部操作
	@Override
	public void update(Observable observable, Object data)
	{
		// TODO Auto-generated method stub
		if (data != null && StringUtils.isNumeric(data.toString())) {
			int id = Integer.parseInt(data.toString());
			switch (id) {
			case ConstantValue.VIEW_FIRST:
				showUnLoginTitle();
				
				break;
			case ConstantValue.VIEW_SECOND:
				showCommonTitle();
				break; 
			}
		}
	}
	
	
 
}

2.BottomManager.java 

package com.example.view.manager;
 

import java.util.Observable;
import java.util.Observer;

import org.apache.commons.lang3.StringUtils;

import com.example.myandriod3.ConstantValue;
import com.example.myandriod3.R;
 
import android.app.Activity;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.ImageButton;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;

public class BottomManager implements Observer 
{
 
	private static BottomManager instrance;
 
	private BottomManager() {
	}
 
	public static BottomManager getInstrance() {
		if (instrance == null) {
			instrance = new BottomManager();
		}
		return instrance;
	}
	
	protected static final String TAG = "BottomManager";

	private RelativeLayout bottomMenuContainer;
	 
	private LinearLayout commonBottom; 
	private LinearLayout playBottom; 

 
	private ImageButton cleanButton;
	private ImageButton addButton;

	private TextView playBottomNotice;
 
	private ImageButton homeButton;
	private ImageButton hallButton;
	private ImageButton rechargeButton;
	private ImageButton myselfButton;
	
	
	public void init(Activity activity) {
		bottomMenuContainer = (RelativeLayout) activity.findViewById(R.id.ii_bottom);
		commonBottom = (LinearLayout) activity.findViewById(R.id.ii_bottom_common);
		playBottom = (LinearLayout) activity.findViewById(R.id.ii_bottom_game);

		playBottomNotice = (TextView) activity.findViewById(R.id.ii_bottom_game_choose_notice);
		cleanButton = (ImageButton) activity.findViewById(R.id.ii_bottom_game_choose_clean);
		addButton = (ImageButton) activity.findViewById(R.id.ii_bottom_game_choose_ok);

	 
		setListener();
	}
	
	
	private void setListener() {
		 
		cleanButton.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				Log.i(TAG, "1");

			}
		});
	 
		addButton.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				Log.i(TAG, "2");

			}
		});
	}
 
	public void showCommonBottom() {
		if (bottomMenuContainer.getVisibility() == View.GONE || bottomMenuContainer.getVisibility() == View.INVISIBLE) {
			bottomMenuContainer.setVisibility(View.VISIBLE);
		}
		commonBottom.setVisibility(View.VISIBLE);
		playBottom.setVisibility(View.INVISIBLE);
	}
	
	
	public void showGameBottom() {
		if (bottomMenuContainer.getVisibility() == View.GONE || bottomMenuContainer.getVisibility() == View.INVISIBLE) {
			bottomMenuContainer.setVisibility(View.VISIBLE);
		}
		commonBottom.setVisibility(View.INVISIBLE);
		playBottom.setVisibility(View.VISIBLE);
	}
	
	
	public void changeBottomVisiblity(int type) {
		if (bottomMenuContainer.getVisibility() != type)
			bottomMenuContainer.setVisibility(type);
	}
	
	
	public void changeGameBottomNotice(String notice) {
		playBottomNotice.setText(notice);
	}

	@Override
	public void update(Observable observable, Object data)
	{
		// TODO Auto-generated method stub
		if (data != null && StringUtils.isNumeric(data.toString())) {
			int id = Integer.parseInt(data.toString());
			switch (id) {
			case ConstantValue.VIEW_FIRST:
				showCommonBottom();
				break;
			case ConstantValue.VIEW_SECOND:
				showGameBottom();
				break;
		 
			}
		}
	}
	
}

3.MiddleManager.java  

package com.example.view.manager;

import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Observable;

import android.content.Context;
import android.util.Log;
import android.view.View;
import android.view.animation.AnimationUtils;
import android.widget.RelativeLayout;

import com.example.myandriod3.ConstantValue;
import com.example.myandriod3.R;
 
//Observable 成为观察者
public class MiddleManager extends Observable
{
 
	private RelativeLayout middle;
	
	private BaicUi curridBaicUi;
	//存放实例化的对象
	private Map<String, BaicUi> VIEWCACHE = new HashMap<String, BaicUi>();
	//历史记录
	public LinkedList<String> HISTORY = new LinkedList<String>();
 
	public void setMiddle(RelativeLayout middle) {
		this.middle = middle;
	}
 
	/**
	 * 单例模式 
	 */
	private static MiddleManager instance = new MiddleManager();

	private MiddleManager() {
	}

	public static MiddleManager getInstance() {
		return instance;
	}
	
	/**
	 * 初始化 如果存在 就不存放
	 * @param activity
	 */
	
   public void ChangeUi2(Class<? extends BaicUi> targetClazz){
 
	   if(curridBaicUi!=null && curridBaicUi.getClass() == targetClazz){
		   return;
	   }

	    BaicUi targetui =null;
		String key=targetClazz.getSimpleName();
		if(VIEWCACHE.containsValue(key)){
			targetui=VIEWCACHE.get(key);
		}else{

			try
			{
				Constructor<? extends BaicUi> constructor = targetClazz.getConstructor(Context.class);
				targetui = constructor.newInstance(getContext());
				VIEWCACHE.put(key, targetui);
			} catch (Exception e)
			{
				throw new RuntimeException("constructor new instance error");
			}
		}
		
		middle.removeAllViews();
		View child=targetui.getChild();
		middle.addView(child);
		child.startAnimation(AnimationUtils.loadAnimation(getContext(),R.anim.ia_view_change));
		curridBaicUi = targetui; 
		
		//System.out.println(key);
	 
		HISTORY.addFirst(key);
		changeTitleAndBottom();
   }
	
	public void ChangeUi(BaicUi ui){
		middle.removeAllViews();
		View child=ui.getChild();
		middle.addView(child);
		child.startAnimation(AnimationUtils.loadAnimation(getContext(),R.anim.ia_view_change));
 
	}
	
	
	private void changeTitleAndBottom() {

//		  switch (curridBaicUi.getID()) { 
//		  case ConstantValue.VIEW_FIRST:
//			  TitleManager.getInstance().showUnLoginTitle();
//			  BottomManager.getInstrance().showCommonBottom(); 
//			 break;
//			 case ConstantValue.VIEW_SECOND:
//				 TitleManager.getInstance().showCommonTitle();
//				 BottomManager.getInstrance().showGameBottom(); 
//				 break;
//			 }
		
			setChanged();
			notifyObservers(curridBaicUi.getID());
		 
	}
	
	
	/**
	 *获取上下文
	 * @return
	 */
	public Context getContext() {
		return middle.getContext();
	}
	
	/**
	 * 返回键操作
	 * 
	 */
	
	public boolean goBack() {
 
		if (HISTORY.size() > 0) {
			// Throws:NoSuchElementException - if this LinkedList is empty.
			HISTORY.removeFirst();

			if (HISTORY.size() > 0) {
				// Throws:NoSuchElementException - if this LinkedList is empty.
				String key = HISTORY.getFirst();
				BaicUi targetUI = VIEWCACHE.get(key);

				middle.removeAllViews();
				middle.addView(targetUI.getChild());
				curridBaicUi = targetUI;
				changeTitleAndBottom();
				
				return true;
				
			}
		}

		return false;
	}
	
}

4.MainActivity.java 

//建立观察者 和被观察者之间的关系
		MiddleManager.getInstance().addObserver(TitleManager.getInstance());
		MiddleManager.getInstance().addObserver(BottomManager.getInstrance());


Android observer 使用demo
07-23
在Android开发中，Observer模式是一种常见的设计模式，用于实现对象之间的通信和状态更新。Observer模式的核心思想是"一对多"的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。...
精选资源
Android使用观察者模式Observer实现网络状态监听
01-05
在Android开发过程中，很多时候都会用到当前网络的状态判断以及网络状况发生变化的时候做出相应的反应，要想监听网络状态，用观察者模式再合适不过了，废话不多说，直接上代码。 观察者模式属于面向对象的23中设计...
Android中BroadCast与Activity之间的通信（一） 使用观察者模式Observer
JUN_LLLL的博客
07-17 898
观察者模式是定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变的时候，所有依赖于它的对象都将得到通知，并自动更新”，可以理解成多个观察者向一个被观察者订阅消息，当被观察者发生改变时通知相应的观察者去作自己的事情。 Android 中的观察者 实现Observer接口，被观察者继承Observable类。 1、被观察者类（ObservableObject） public ...
Android设计模式---观察者模式
Panda_Program的博客
01-13 580
观察者模式(Observer)是解决、解耦的钥匙。最常用的地方是GUI系统、订阅—发布系统。定义观察者模式是一种行为类模式，它定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。使用场景（1）关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。（2）事件多级触发场景。（3）跨系统的消息交换场景，如消息队列、事件总线的处理机制。角色介
安卓APP采用观察者模式实现检测版本更新
momocsdn
09-04 8932
第一步：定义观察者 public interface CheckVersionObserver { /** * 在MainActivity里面检测版本更新成功 * @param mainEntity */ public void onCheckNewVerSuccInMain(MainEntity mainEntity); /** * 检测新版本失败 * @pa
Android 观察者模式
最新发布
zzz386021090的博客
03-23 1038
例如，你可以创建一个Subject类，其中包含一个ArrayList来保存观察者对象，并提供registerObserver、unregisterObserver和notifyObservers等方法。在Android中，观察者模式（Observer Pattern）是一种常用的设计模式，用于在对象之间建立一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。这个方法会遍历观察者列表，并调用每个观察者的onChange方法（或你定义的类似方法）。
Observer - 即观察者模式在android的正确食用方式
08-26 565
观察者模式的介绍首先我们要弄明白，什么是观测者模式 当有一个对象，需要拥有一对多的依赖关系，当这个对象的状态或者信息出现了变动的时候，所以与之有依赖的所有对象都会获得通知并且更新。 那么这个对象就被称为被观察者，与之有依赖关系的人都被称为观察者。 那么，转化为代码语言就是//被观察者 public class BeWatcher extends Observable{ ...
Android Observer模式详解：实战案例与应用
"Android Observer模式案例详解文档深入解析了这一经典设计模式在Android开发中的应用。观察者模式（Observer Pattern）是一种行为设计模式，它允许对象之间建立一种一对多依赖关系，当一个对象的状态发生改变时，...
android Observer(观察者模式)_案例祥解.pdf
11-23
观察者模式详解 观察者模式是23种设计模式中的一种，尤其是在软件设计过程中体现的更是立足无穷。本文将详细讲解观察者模式的概念和实现，通过代码注释来解释各个组件的作用。 一、观察者模式的定义 观察者模式是...
Android学习 ContentProvider数据更新与Observer模式.doc
07-06
在Android开发中，ContentProvider和Observer模式是两个关键的概念，它们在数据管理和更新中起着重要作用。ContentProvider作为Android系统中数据共享的桥梁，允许不同的应用程序之间交换数据，而Observer模式则是一...
Android 最常用的设计模式二 安卓Rxjava源码分析—观察者模式Observer(有实例)
深南大盗的博客
09-13 851
Android 最常用的设计模式一 安卓源码MediaManager分析—单例模式singleInstance https://blog.youkuaiyun.com/WHB20081815/article/details/77970206 Android 最常用的设计模式二 安卓Rxjava源码分析—观察者模式Observer(有实例) https://blog.youkuaiyun.com/WHB2008181...
Android 中的观察者模式Observer
热门推荐
废墟的树的专栏
12-26 1万+
Android 中的观察者模式 实现的简单框架。
android里fragment或者activity如何“监听“viewmodel里数据
u014694850的博客
01-30 2041
我尝试了一下，有两种方法 方法一，定义类的时候，将类继承livedata,并在set里实现postValue package com.taeren.taerenpartner.model; import androidx.lifecycle.LiveData; public class Pandian extends LiveData { private int _rollId; private int _shelfId; public int get_rollId() {
Android Observe
li6472的博客
11-30 2173
代码解释很全面，复制到IDE中，可以更方便查看如何使用的 祝君早日掌握 package observe; import java.util.Observable; import java.util.Observer; //TODO 总体流程：先执行具体类中的——————引用自observer的抽象change方法， // 在执行observer中的update方法， // 最后执行Observable中的具体设计接口， //
Android LiveData Observer 多次调用
epitomizelu的专栏
02-29 1万+
使用 Android Architecture Components，出现一个问题，LiveData的观察者Obsever会被多次调用。 我的写法是 private void loadData(FragmentActivity activity) { RfLoader.showLoading(activity); multiseriateDialogVi...
ConcurrentHashMap
weixin_34413357的博客
09-07 575
ConcurrentHashMap是Java5中新增加的一个线程安全的Map集合，可以用来替代HashTable。对于ConcurrentHashMap是如何提高其效率的，可能大多人只是知道它使用了多个锁代替HashTable中的单个锁，也就是锁分离技术（Lock Stripping）。实际上，ConcurrentHashMap对提高并发方面的优化，还有一些其它的技巧在里面（比如你是否知道在get...
Android使用Observer/Observable实现简易版的EventBus
u010237863的博客
04-12 2269
一、Observable简介    Observer/Observable是Java提供的一种观察者模式，使用它可以方便地实现各个类之间的通讯。    我们简单地谈一下观察者模式。举一个例子：我们的App中有Main1Activity和Main2Activity两个Activity，从App启动就有一个定时任务，每隔5s两个Activity都需要刷新数据。这个时候只要Main1Activity、M...
Android学习 ContentProvider数据更新与Observer模式
weixin_34365635的博客
06-02 287
　　　　Android学习 ContentProvider数据更新与Observer模式 一 Observer模式 意图： 　　定义对象之间一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被更新。 　　依赖（Dependents）、发布-订阅（Publish-Subscribe）。处理一对多情况下对象之间的依赖关系。 对象之间必然会存在依赖关系或者依赖关系...
Android调用JNI出错 java.lang.UnsatisfiedLinkError: No implementation found for的解决方法
rorntuck7的专栏
03-08 7070
今天使用第三方的so库时候，调用JNI方法时出现了错误。报错如下所示：03-08 10:29:36.989 27896-27896/? E/art: No implementation found for void com.lee.testso.jni.MCHKeyTools.natInit() (tried Java_com_lee_testso_jni_MCHKeyTools_natInit ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值