android开发

最新推荐文章于 2023-02-23 21:21:55 发布
最新推荐文章于 2023-02-23 21:21:55 发布
阅读量442 收藏
点赞数
分类专栏： Android 文章标签： android 数据库 java ui 多线程 application

Java™ 语言是 Android 开发人员所选的工具。Android 运行时使用自己的虚拟机Dalvik，这并不是多数程序开发人员使用的普通Java 虚拟机。Dalvik支持Java 编程语言的大部分功能——但并不是全部。在本文中，您将学习高级Java功能及其如何在Android中实现。这些功能包括并发性、联网和数据库访问。

准备开始

本文介绍几种处理复杂情况的 Android SDK 工具。开发 Android 应用程序，需要最新版 Android SDK，这需要一个 Java Development Kit (JDK)。我使用的是 Android 2.2 和 JDK 1.6.0_17（这些工具的链接见 参考资料）。物理设备不是必须的；本文中的所有代码在 SDK 附带的 Android 模拟器上可以很好的运行。本文假设您对 Android 编程比较熟悉，故不涉及 Android 基础开发，但是如果您有 Java 编程语言的知识，也是可以的。

并发性和联网

Android 应用程序一个最常见的任务就是检索数据或通过网络将数据发送到远程服务器。这一操作的结果通常是一些您想要展示给用户的新数据。这意味着您需要修改用户界面。大多数开发人员知道您将不会执行一个潜在的长期运行任务，例如，在主 UI 线程上通过网络访问数据（特别使用一个网络连接非常慢的手机）。冻结您的应用程序直至长期运行任务完成。事实上，如果这个任务超过 5 秒，Android 操作系统将出现臭名昭著的 Application Not Responding 对话框，如图1所示。

图 1. Android 臭名昭著的 Application Not Responding 对话框

您不可能知道用户网络连接能有多慢。为了避免冒险，您必须在不同的线程上执行任务，或者至少不在主 UI 线程上执行。许多 Android 应用程序，但不是全部，需要处理多线程，由此引起并发。应用程序经常需要本地保存数据，Android 数据库是一个很好的选择。这三个场景（不同线程，并发和本地保存数据）在 Java 环境中有许多标准 方法可以用来处理。然而，正如您将要看到的，Android 提供不同的选择。让我们逐个看看，看看其优点和缺点。

Android 网络

通过网络使用 Java 编程进行调用是简单的，我们熟悉的 java.net 包含几个执行此操作的类。这些类大多数在 Android 中都可用，事实上，您可以使用像 java.net.URL 和 java.net.URLConnection 这样的类，就像您在其他 Java 应用程序中那样。然而，Android 包括 pache HttpClient 库，这是在 Android 上连接网络的首选方法。即使您使用常用 Java 类，Android 实现仍然使用 HttpClient。清单 1 显示了一个使用这个必不可少的库的示例。（所有源代码见 下载。）

清单 1. 在 Android 上使用 Http Client 库

 
 
  1. private ArrayList<Stock> fetchStockData(Stock[] oldStocks)   
  2.     throws ClientProtocolException, IOException{  
  3.     StringBuilder sb = new StringBuilder();  
  4.     for (Stock stock : oldStocks){  
  5.         sb.append(stock.getSymbol());  
  6.         sb.append('+');  
  7.     }  
  8.     sb.deleteCharAt(sb.length() - 1);  
  9.     String urlStr =   
  10.         "http://finance.yahoo.com/d/quotes.csv?f=sb2n&s=" +   
  11.                 sb.toString();  
  12.     HttpClient client = new DefaultHttpClient();  
  13.     HttpGet request = new HttpGet(urlStr.toString());  
  14.     HttpResponse response = client.execute(request);  
  15.     BufferedReader reader = new BufferedReader(  
  16.             new InputStreamReader(response.getEntity().getContent()));  
  17.     String line = reader.readLine();  
  18.     int i = 0;  
  19.     ArrayList<Stock> newStocks = new ArrayList<Stock>(oldStocks.length);  
  20.     while (line != null){  
  21.         String[] values = line.split(",");  
  22.         Stock stock = new Stock(oldStocks[i], oldStocks[i].getId());  
  23.         stock.setCurrentPrice(Double.parseDouble(values[1]));  
  24.         stock.setName(values[2]);  
  25.         newStocks.add(stock);  
  26.         line = reader.readLine();  
  27.         i++;  
  28.     }  
  29.     return newStocks;  
  30. } 

在这段代码中有一组 Stock 对象。这是基本的数据结构对象，保存用户拥有股票信息（比如，代号、价格等）以及更多的个人信息（比如，用户付了多少钱）。您可以使用 HttpClient 类从 Yahoo Finance 检索动态数据（例如，这支股票目前的价格）。HttpClient 包含一个 HttpUriRequest ，在本例中，您可以使用 HttpGet，这是 HttpUriRequest 的一个子类。类似地，当您需要向远程服务器发送数据时，可以使用 HttpPost 类，当您从客户端得到 HttpResponse 时，您能接触到响应的潜在 InputStream、对其进行缓冲、解析来获取股票信息。

现在，您看到了如何通过网络检索数据、如何用这个数据来通过使用多线程智能地更新 Android UI。

Android 并发性实践

如果您在应用程序的主 UI 线程上运行 清单 1 中的代码，可能会出现 Application Not Responding 对话框，具体视用户网络速度而定。因此必须确定生成一个线程来获取数据。清单 2 显示了一种解决方法。

清单 2. Naïve 多线程（别这样，这行不通！）

 
 
  1. private void refreshStockData(){  
  2.     Runnable task = new Runnable(){  
  3.         public void run() {  
  4.             try {  
  5.                 ArrayList<Stock> newStocks =   
  6.                     fetchStockData(stocks.toArray(  
  7.                                   new Stock[stocks.size()]));  
  8.                 for (int i=0;i<stocks.size();i++){  
  9.                     Stock s = stocks.get(i);  
  10.                     s.setCurrentPrice(  
  11.                                   newStocks.get(i).getCurrentPrice());  
  12.                     s.setName(newStocks.get(i).getName());  
  13.                     refresh();  
  14.                 }  
  15.             } catch (Exception e) {  
  16.                 Log.e("StockPortfolioViewStocks",   
  17.                             "Exception getting stock data", e);  
  18.             }  
  19.         }  
  20.     };  
  21.     Thread t = new Thread(task);  
  22.     t.start();  
  23. } 

清单 2 的标题声明这是 naïve 代码，确实是。在这个例子中，您将调用 清单 1 中的 fetchStockData 方法，将其封装在 Runnable 对象中，并在一个新线程中执行。在这个新线程中，您可以访问 stocks，一个封装 Activity（此类创建了 UI）的成员变量。顾名思义，这是 Stock 对象的一个数据结构（本例中是 java.util.ArrayList）。换句话说，您在两个线程之间共享数据，主 UI 线程和衍生（spawned）线程（在 清单 2 中调用）。当您修改了衍生线程中的共享数据时，通过在 Activity 对象上调用 refresh 方法来更新 UI。

如果您编写了 Java Swing 应用程序，您可能需要遵循一个像这样的模式。然而，这在 Android 中将不能正常工作。衍生线程根本不能修改 UI。因此在不冻结 UI ，但另一方面，在数据收到之后又允许您修改 UI 的情况下，您怎样检索数据？android.os.Handler 类允许您在线程之间协调和通信。清单 3 显示了一个使用 Handler 的已更新 refreshStockData 方法。

清单 3. 实际工作的多线程 — 通过使用 Handler

 
 
  1. private void refreshStockData(){  
  2.     final ArrayList<Stock> localStocks =   
  3.           new ArrayList<Stock>(stocks.size());  
  4.     for (Stock stock : stocks){  
  5.         localStocks.add(new Stock(stock, stock.getId()));  
  6.     }  
  7.     final Handler handler = new Handler(){  
  8.         @Override 
  9.         public void handleMessage(Message msg) {  
  10.             for (int i=0;i<stocks.size();i++){  
  11.                 stocks.set(i, localStocks.get(i));  
  12.             }  
  13.             refresh();  
  14.         }  
  15.     };  
  16.     Runnable task = new Runnable(){  
  17.         public void run() {  
  18.             try {  
  19.                 ArrayList<Stock> newStocks =   
  20.                     fetchStockData(localStocks.toArray(  
  21.                                   new Stock[localStocks.size()]));  
  22.                 for (int i=0;i<localStocks.size();i++){  
  23.                     Stock ns = newStocks.get(i);  
  24.                     Stock ls = localStocks.get(i);  
  25.                     ls.setName(ns.getName());  
  26.                     ls.setCurrentPrice(ns.getCurrentPrice());  
  27.                 }  
  28.                 handler.sendEmptyMessage(RESULT_OK);  
  29.             } catch (Exception e) {  
  30.                 Log.e("StockPortfolioViewStocks",   
  31.                             "Exception getting stock data", e);  
  32.             }   
  33.         }  
  34.     };  
  35.     Thread dataThread = new Thread(task);  
  36.     dataThread.start();  
  37. } 

在 清单 2 和 清单 3 中的代码有两个主要的不同。明显的差异是 Handler 的存在。第二个不同是，在衍生线程中，您不能修改 UI。相反的，当您将消息发送到 Handler，然后由 Handler 来修改 UI。也要注意，在线程中您不能修改 stocks 成员变量，正如您之前所做的。相反地您可以修改数据的本地副本。严格地来说，这是不是必须的，但这更为安全。

清单 3 说明了在并发编程中一些非常普遍的模式：复制数据、将数据解析到执行长期任务的线程中、将结果数据传递回主 UI 线程、以及根据所属数据更新主 UI 线程。Handlers 是 Android 中的主要通信机制，它们使这个模式易于实现。然而，清单 3 中仍然有一些样本代码。幸好，Android 提供方法来封装和消除大多数样本代码。清单 4 演示了这一过程。

清单 4. 用一个 AsyncTask 使多线程更容易

 
 
  1. private void refreshStockData() {  
  2.     new AsyncTask<Stock, Void, ArrayList<Stock>>(){  
  3.         @Override 
  4.         protected void onPostExecute(ArrayList<Stock> result) {  
  5.             ViewStocks.this.stocks = result;  
  6.             refresh();  
  7.         }  
  8.  
  9.         @Override 
  10.         protected ArrayList<Stock> doInBackground(Stock... stocks){  
  11.             try {  
  12.                 return fetchStockData(stocks);  
  13.             } catch (Exception e) {  
  14.                 Log.e("StockPortfolioViewStocks", "Exception getting stock data", e);  
  15.             }  
  16.             return null;  
  17.         }  
  18.     }.execute(stocks.toArray(new Stock[stocks.size()]));  
  19. } 

如您所见，清单 4 比起 清单 3 样本代码明显减少。您不能创建任何线程或 Handlers。使用 AsyncTask 来封装所有样本代码。要创建 AsyncTask，您必须实现 doInBackground 方法。该方法总是在独立的线程中执行，因此您可以自由调用长期运行任务。它的输入类型来自您所创建的 AsyncTask 的类型参数。在本例中，第一个类型参数是 Stock，因此 doInBackground 获得传递给它的一组 Stock 对象。类似地，它返回一个 ArrayList<Stock>，因为这是 AsyncTask 的第三个类型参数。在此例中，我也选择重写 onPostExecute 方法。这是一个可选方法，如果您需要使用从 doInBackground 返回的数据来进行一些操作，您可以选用这种方法来实现。这个方法总是在主 UI 线程上被执行，因此对于修改 UI 这是一个很好的选择。

有了 AsyncTask，您就完全可以简化多线程代码。它可以将许多并发陷阱从您的开发路径删除，您仍然可以使用 AsyncTask 寻找一些潜在问题，例如，在 doInBackground 方法对象执行的同时设备上的方向发生改变时可能发生什么。更多关于如何处理这类案例的技术，见 参考资料 的链接。

现在我们开始讨论另一个常见任务，其中 Android 明显背离常用的 Java 方法 — 使用数据库进行处理。

Android 数据库连通性

Android 中一个非常有用的特征就是存在本地关系数据库。保证您能在本地文件中存储您的数据，但通常更有用的是使用一个关系型数据库管理系统（Relational Database Management System，RDBMS）来存储。Android 提供给您常用的 SQLite 数据库来进行处理，因为对于像 Android 这类嵌入式系统它是高度优化的。它被 Android 上的核心应用程序所用。例如，用户地址簿是存储在一个 SQLite 数据库中。现在，对于给定的 Android 的 Java 实现，您可以使用 JDBC 来访问这些数据库。出人意料的是，Android 甚至包括构成主要部分 JDBC API 的 java.sql 和 javax.sql 包。然而，当涉及使用本地 Android 数据库进行处理时，这毫无用处。相反地，您想要使用 android.database 和 android.database.sqlite 包。清单 5 是一个使用这些类存储和检索数据的示例。

清单 5. 使用 Android 进行数据库访问

 
 
  1. public class StocksDb {  
  2.     private static final String DB_NAME = "stocks.db";  
  3.     private static final int DB_VERSION = 1;  
  4.     private static final String TABLE_NAME = "stock";  
  5.     private static final String CREATE_TABLE = "CREATE TABLE " +   
  6.         TABLE_NAME + " (id INTEGER PRIMARY KEY, symbol TEXT, max_price DECIMAL(8,2), " +  
  7.             "min_price DECIMAL(8,2), price_paid DECIMAL(8,2), " +  
  8.             "quantity INTEGER)";  
  9.     private static final String INSERT_SQL = "INSERT INTO " + TABLE_NAME +  
  10.             " (symbol, max_price, min_price, price_paid, quantity) " +  
  11.             "VALUES (?,?,?,?,?)";  
  12.     private static final String READ_SQL = "SELECT id, symbol, max_price, " +  
  13.             "min_price, price_paid, quantity FROM " + TABLE_NAME;  
  14.     private final Context context;  
  15.     private final SQLiteOpenHelper helper;  
  16.     private final SQLiteStatement stmt;  
  17.     private final SQLiteDatabase db;  
  18.     public StocksDb(Context context){  
  19.         this.context = context;  
  20.         helper = new SQLiteOpenHelper(context, DB_NAME, null,   
  21.                 DB_VERSION){  
  22.             @Override 
  23.             public void onCreate(SQLiteDatabase db) {  
  24.                 db.execSQL(CREATE_TABLE);  
  25.             }  
  26.  
  27.             @Override 
  28.             public void onUpgrade(SQLiteDatabase db, int oldVersion,   
  29.                     int newVersion) {  
  30.                 throw new UnsupportedOperationException();  
  31.             }  
  32.         };  
  33.         db = helper.getWritableDatabase();  
  34.         stmt = db.compileStatement(INSERT_SQL);  
  35.     }  
  36.     public Stock addStock(Stock stock){  
  37.         stmt.bindString(1, stock.getSymbol());  
  38.         stmt.bindDouble(2, stock.getMaxPrice());  
  39.         stmt.bindDouble(3, stock.getMinPrice());  
  40.         stmt.bindDouble(4, stock.getPricePaid());  
  41.         stmt.bindLong(5, stock.getQuantity());  
  42.         int id = (int) stmt.executeInsert();  
  43.         return new Stock (stock, id);  
  44.     }  
  45.     public ArrayList<Stock> getStocks() {  
  46.         Cursor results = db.rawQuery(READ_SQL, null);  
  47.         ArrayList<Stock> stocks =   
  48.                  new ArrayList<Stock>(results.getCount());  
  49.         if (results.moveToFirst()){  
  50.             int idCol = results.getColumnIndex("id");  
  51.             int symbolCol = results.getColumnIndex("symbol");  
  52.             int maxCol = results.getColumnIndex("max_price");  
  53.             int minCol = results.getColumnIndex("min_price");  
  54.             int priceCol = results.getColumnIndex("price_paid");  
  55.             int quanitytCol = results.getColumnIndex("quantity");  
  56.             do {  
  57.                 Stock stock = new Stock(results.getString(symbolCol),   
  58.                         results.getDouble(priceCol),   
  59.                         results.getInt(quanitytCol),   
  60.                                     results.getInt(idCol));  
  61.                 stock.setMaxPrice(results.getDouble(maxCol));  
  62.                 stock.setMinPrice(results.getDouble(minCol));  
  63.                 stocks.add(stock);  
  64.             } while (results.moveToNext());  
  65.         }  
  66.         if (!results.isClosed()){  
  67.             results.close();  
  68.         }  
  69.         return stocks;  
  70.     }  
  71.     public void close(){  
  72.         helper.close();  
  73.     }      
  74. } 

清单 5 中的类完全封装了一个用于存储股票信息的 SQLite 数据库。因为您将要使用一个嵌入式数据库，不仅是您的应用程序要使用它，而且也要通过应用程序来创建它。您需要提供代码来创建该数据库。Android 提供一个有用的抽象帮助类 SQLiteOpenHelper。要完成这一操作，您需要扩展这个抽象类并提供代码通过使用 onCreate 方法创建您的数据库。当您有一个帮助程序实例时，就可以获取一个 SQLiteDatabase 实例，您可以用来执行任意 SQL 语句。

您的数据库类有两个较为方便的方法。第一个是 addStock，用于将新股票保存到数据库中。注意，您使用了一个 SQLiteStatement 实例，这类似于一个 java.sql.PreparedStatement。需要注意的是，在您的类构造器中如何对其进行编译，使其在每次调用 addStock 时都能重复利用。在每个 addStock 调用中，SQLiteStatement 的变量（INSERT_SQL 字符串中的问号）必然要将数据传递给 addStock。再一次强调，这类似于 PreparedStatement ，您可以从 JDBC 了解它。

另一个方法是 getStocks。顾名思义，它从数据库中检索所有股票。注意，您再次使用一个 SQL 字符串，正如您在 JDBC 中所用的那样。您可以在 SQLiteDatabase 类上通过使用 rawQuery 方法来进行处理。这个类也有几个查询方法，让您可以不使用 SQL 直接查询数据库。所有这些方法都返回一个 Cursor 对象，和 java.sql.ResultSet 非常相似。您可以将 Cursor 移动到从数据库中返回的数据所在行，在每一行，您可以使用 getInt、getString 和其他的方法来检索您要查询的数据库中各列相关的值。再一次强调，这和 ResultSet 十分相似。也和 ResultSet 比较相似，当您完成操作之后，关闭 Cursor 也十分重要的。如果您没有关闭 Cursors，那么可能会迅速地耗尽内存并导致您的应用程序崩溃。

查询本地数据库是一个比较慢的过程，特别是，如果您有多行数据或者您需要在多个表之间运行复杂的查询语句。然而，数据库查询或插入超过 5 秒且出现一个 Application Not Responding 对话框，这种情况不太可能发生，但是当您的数据库忙于读取和写入数据时，冻结您的 UI 是不明智的。当然，避免这种情况最好的办法是使用 AsyncTask。清单 6 展示了这个示例。

清单 6. 在一个单独的线程上插入数据库

 
 
  1. Button button = (Button) findViewById(R.id.btn);  
  2. button.setOnClickListener(new OnClickListener(){  
  3.     public void onClick(View v) {  
  4.         String symbol = symbolIn.getText().toString();  
  5.         symbolIn.setText("");  
  6.         double max = Double.parseDouble(maxIn.getText().toString());  
  7.         maxIn.setText("");  
  8.         double min = Double.parseDouble(minIn.getText().toString());  
  9.         minIn.setText("");  
  10.         double pricePaid =   
  11.                 Double.parseDouble(priceIn.getText().toString());  
  12.         priceIn.setText("");  
  13.         int quantity = Integer.parseInt(quantIn.getText().toString());  
  14.         quantIn.setText("");  
  15.         Stock stock = new Stock(symbol, pricePaid, quantity);  
  16.         stock.setMaxPrice(max);  
  17.         stock.setMinPrice(min);  
  18.         new AsyncTask<Stock,Void,Stock>(){  
  19.             @Override 
  20.             protected Stock doInBackground(Stock... newStocks) {  
  21.                 // There can be only one!  
  22.                 return db.addStock(newStocks[0]);  
  23.             }  
  24.             @Override 
  25.             protected void onPostExecute(Stock s){  
  26.                 addStockAndRefresh(s);  
  27.             }  
  28.         }.execute(stock);  
  29.     }  
  30. }); 

您可以先为按钮创建一个实践监听器。当用户点击按钮时，您可以从各个小部件（确切地说是 EditText 小部件）读取股票数据并填入一个新的 Stock 对象。您可以创建一个 AsyncTask，并通过 doInBackground 方法从 清单 5 中调用 addStock 方法。如此，addStock 将在一个背景线程上执行，而不是在主 UI 线程上。完成之后，将新 Stock 对象从数据库传递到在主 UI 线程上执行的 addStockAndRefresh 方法。

结束语

本文显示了，即使 Android 在 Java 环境下仅支持众多 API 的一个子集，但是其功能却一点都不逊色。在某些示例中，比如网络，它完全实现了熟悉的 API，也提供了一些更为便捷的方法。在其他的示例中，比如并发性，Android 添加了额外 API 以及一些必须遵循的惯例。最后，在数据库访问案例中，Android 提供了完全不同的方法来访问数据库，但使用的是熟悉的概念。这不仅仅是标准 Java 和 Android Java 技术之间主观上的差异：它们形成了Android 开发的基础构建元件。

作者简介：

Michael Galpin

Michael Galpin 是eBay 的一名架构师。他经常为 developerWorks 撰写文章，同时在 TheServerSide.com 和 Java Developer 期刊上发表文章，他还有自己的博客。他从 1998 年开始做职业程序员，并拥有加州理工学院数学专业的学士学位。

更多内容请见：http://www.ibm.com/developerworks/cn/xml/x-gourmetandroid/index.html

 

honeyleo
关注
专栏目录
Android UDP通信之Handler、Activity、UI更新
要想到做到
12-15 8791
碰到了一些问题，列出几个说说     1.ERROR/JavaBinder(1726): android.util.AndroidRuntimeException: { what=102 when=330076886 obj=android.os.BinderProxy@325fb830 } This message is already in use.     2.ERROR/global(
Android异步回调中的UI同步性问题分析
01-05
Android程序编码过程中，回调无处不在。从最常见的Activity生命周期回调开始，到BroadcastReceiver、Service以及Sqlite等。Activity、BroadcastReceiver和Service这些基本组件的回调路径和过程也就是通常意义上所谓的“生命周期”。同时，在处理具体的业务逻辑时，常常设计到不同线程之间的通信，如下载图片完成后通知 UI线程更新UI，凡此类场景，无论使用哪一种具体的线程间通信方式（Handler/Message、Handler/post、基于接口的回调、基于多对多的观察者模式如EventBus等），其本质上都是基于“回调”。在实际编码过程
享受Android应用程序的Java技术盛宴
weixin_30484739的博客
09-10 103
Java™ 语言是 Android 开发人员所选的工具。Android 运行时使用自己的虚拟机Dalvik，这并不是多数程序开发人员使用的普通Java 虚拟机。Dalvik支持Java 编程语言的大部分功能——但并不是全部。在本文中，您将学习高级Java功能及其如何在Android中实现。这些功能包...
android java开发 第四天 之(后台服务处理完业务数据后，传送给ui Activity并刷新界面)
gaoxuefeng的专栏
09-17 4263
1、之前我们实现了activity 和services的绑定，我们就可以在activity里通过service的对象来执行service中的各种函数。 2、当然也可以将activity.this传给services中保存起来。待service中处理完业务数据如（网络读写后）将数据发送给activity。 3、重点：在service中保存了activity.this，当然可以调用activi
Android 模仿C# WPF的Dispatcher的UI同步调用
热门推荐
Nhsoft的专栏
07-16 1万+
PS: 我是个Android土鳖，学Android才不到两个月，有槽点就尽情吐吧。--------------我是分割线--------------------------------------------------------------我们知道WPF (WinForm)的UI操作是不能在UI主线程以外进行的。但是WPF和Winform都有比较方便的代码写法来支持这个调用。比如this.Di
Android 当数据库变动时更新UI数据 注册观察者监听
12-09 475
[code="java"] /** * Register an observer for provider status changes - we will need to * reflect them in the UI. */ private void registerObserver() { getContentResolver().registerConten...
Android开发入门60个小案例+源代码
08-24
在Android开发领域，初学者经常会面临许多挑战，如理解Android应用程序的基本架构、学习XML布局、掌握Java或Kotlin编程语言，以及如何与设备硬件交互等。"Android开发入门60个小案例+源代码"这个资源提供了丰富的...
Android开发教程笔记完全版 pdf
11-01
Android开发是全球最受欢迎的移动应用开发平台之一，广泛应用于智能手机、平板电脑以及各种智能设备上。这份"Android开发教程笔记完全版"涵盖了Android开发的基础到高级主题，旨在帮助开发者全面理解并掌握Android...
android开发期末大作业.zip
07-01
android开发期末大作业（项目源码，任务书，实验大报告，apk文件） 大作业的要求和内容：（包括题目选择范围、技术要求、递交时间、考核方法等） 一、实验项目名称 Android手机应用开发课程大作业 二、实验目的 1．...
老罗android开发视频教程全集百度网盘下载
05-11
Android 是Google开发的基于Linux平台的开源手机操作系统。它包括操作系统、用户界面和应用程序—— 移动电话工作所需的全部软件，而且不存在任何...【第一版第十五章】老罗Android开发视频--百度地图实战开发（10集）
android开发艺术探索书中源码
11-24
《Android开发艺术探索》是一本深受Android开发者喜爱的技术书籍，由任玉刚撰写。这本书深入浅出地讲解了Android开发中的各种技术难点和最佳实践，旨在帮助开发者提升技能，提高开发效率。书中涵盖了许多关键知识点...
android数据库与ui同步,android实现数据库和UI同步更新
weixin_39732027的博客
05-27 458
实现类似电话本显示的功能，情景如下：一部新手机电话本为空，打开电话本，空显示，此时用91助手从PC导入电话号码，此时电话本的UI同步显示出来。实现如上方法，要用到2个方面的知识，cursorAdapter和Observerpackage listview;import android.content.Context;import android.database.ContentObserver;i...
Android DataBinding——利用数据改变UI，分离你的数据业务逻辑
罗春娥的技术园
05-30 795
第一部分：DataBinding是什么? 我来答: 是google官方指导架构篇Architecture Components的一个支持库，借用它可以将UI界面组件绑定到应用的数据源中。 第二部分: 作为Android 开发者我如何接入使用呢? 只需一步，在app module的build.gradle下加入如下配置: android { ... ...
Android：同步屏障的简单理解和使用
最新发布
JMW1407的博客
02-23 2977
这样发送的消息都是普通消息也就是同步消息，发出去的消息就会在MessageQueue中排队。这里我们假设一个场景：我们向主线程发送了一个UI绘制操作Message，而此时消息队列中的消息非常多，那么这个Message的处理可能会得到延迟，绘制不及时造成界面卡顿。同步屏障机制的作用，是让这个绘制消息得以越过其他的消息，优先被执行。在请求监听Vsync信号时，阻塞Handler消息队列中的同步消息，优先保证接收Vsync信号的异步消息，及时生成新的屏幕数据，供屏幕显示。，会将即将处理的消息移除队列并返回；
android 简单同步与异步
xuyitao的博客
08-02 293
android 只有UI线程可以刷新界面，其他副线程不行，这样就需要副线程通过通信消息修改刷新和修改界面。 有2种方式可以实现： AsyncTask，Handle  AsyncTask android提供的简单用于异步通讯的线程,有句话，越完善的东西使用越麻烦。 主要四个实现接口：     onPreExecute(), 该方法将在执行实际的后台操作前被UI 线程调用。可以在该方法中做...
Android DataBinding原理分析
isJoker的博客
12-08 1822
一、DataBinding使用 本文着重讲解DataBinding原理，使用的例子比较简单，若读者想要了解更多的DataBinding的使用方法介绍，可以自寻相关资料，本文纯属个人理解，若有错误，还望指出（抱拳） 在app模块的build.gradle中加入如下配置 android { ... dataBinding { enabled = true } }...
Android——UI事件的处理机制（基于监听器）
weixin_34402408的博客
03-27 92
1.普通内部类（常用） xml &lt;Button android:hint="reset" android:layout_columnWeight="1" android:id="@+id/reset"/&gt; java public class MainActivity extends AppCompatActivi...
Android开发中数据变化监听的5种方式
kuanxu的专栏
10-09 9133
一、Broadcast之BroadcastReciever 二、SharedPreferences 之 OnSharedPreferenceChangeListener() 三、ContentProvider 之 ContentObserver 四、Flutter 数据监听之 EventBus 五、Flutter 数据监听之 ChangeNotifier 日常Android开发中总会遇到数据变化监听的需求，譬如一个数据变化需要多个页面或者activity内容同时更新。 而Android中通..
Android - 数据库自动更新，横竖屏切换，系统控件样式，Fragment添加到Activity，Fragment生命周期，缓存，获取/清除缓存
mythmayor的博客
06-07 727
Android - 数据库自动更新，横竖屏切换，系统控件样式，Fragment添加到Activity，Fragment生命周期，缓存，获取/清除缓存
Android开发基础知识入门教程
Android 开发教程概述 Android 开发教程是 Android 应用程序开发的入门指南，旨在帮助开发者快速掌握 Android 开发的基础知识。本教程涵盖了 Android 开发的基础知识，包括 Android 平台的介绍、Android 应用程序的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值