• 基础复习——项目：购物车

    (1)购物车存放着用户准备购买的商品，一开始是空的，随着商品被加入购物车，购物车中就会显示已添加的商品列表。

    (2)除了购物车页面，其它页面(如商场频道页面、商品详情页面)，都可能在右上角或者右下角找到购物车图标。购物车图标上会显示已添加的商品数量，且商品数量是实时更新的。

    (3)购物车页面、商场频道页面、商品详情页面多处都会显示商品的小图或者大图，如何迅速且高效地加载图片是个需要研究的课题。

    线性布局LinearLayout：购物车界面从上往下排列，用到了垂直方向的线性布局。

    网格布局GridLayout：商场页面的陈列橱柜，允许分行分列展示商品。

    相对布局RelativeLayout：页面右上角的购物车图标，图标右上角又有数字标记，按照指定方位排列控件正是相对布局的拿手好戏。

    其他常见控件尚有文本视图TextView、图像视图ImageView，按钮控件Button等。

    购物车用到的存储技术

    数据库SQLite：最直观的是数据库，购物车里的商品列表一定放在SQLite中，增删改查都少不了它。

    全局内存：购物车图标右上角的数字表示购物车中的商品数量，该数值建议保存在全局内存中，这样不必每次都到数据库中执行count操作。

    存储卡文件：App把下载的商品图片保存在存储卡中，这样下次就能直接从存储卡获取商品图片，加快浏览速度。

    共享参数SharedPreferences：是否首次访问网络图片，这个标志位推荐放在共享参数中，因为它需要持久化存储，并且只有一个参数信息。

    ===============================================================================================================

    ShoppingCartActivity  布局：

    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    2.     android:layout_width="match_parent"
    3.     android:layout_height="match_parent"
    4.     android:background="@color/orange"
    5.     android:orientation="vertical" >
    6.  
    7.     <include layout="@layout/title_shopping" />
    8.  
    9.     <ScrollView
    10.         android:layout_width="match_parent"
    11.         android:layout_height="wrap_content" >
    12.  
    13.         <RelativeLayout
    14.             android:layout_width="match_parent"
    15.             android:layout_height="wrap_content" >
    16.  
    17.             <LinearLayout
    18.                 android:id="@+id/ll_content"
    19.                 android:layout_width="match_parent"
    20.                 android:layout_height="wrap_content"
    21.                 android:orientation="vertical"
    22.                 android:visibility="visible" >
    23.  
    24.                 <LinearLayout
    25.                     android:layout_width="match_parent"
    26.                     android:layout_height="wrap_content"
    27.                     android:orientation="horizontal" >
    28.  
    29.                     <TextView
    30.                         android:layout_width="85dp"
    31.                         android:layout_height="wrap_content"
    32.                         android:gravity="center"
    33.                         android:text="图片"
    34.                         android:textColor="@color/black"
    35.                         android:textSize="15sp" />
    36.  
    37.                     <TextView
    38.                         android:layout_width="0dp"
    39.                         android:layout_height="wrap_content"
    40.                         android:layout_weight="3"
    41.                         android:gravity="center"
    42.                         android:text="名称"
    43.                         android:textColor="@color/black"
    44.                         android:textSize="15sp" />
    45.  
    46.                     <TextView
    47.                         android:layout_width="0dp"
    48.                         android:layout_height="wrap_content"
    49.                         android:layout_weight="1"
    50.                         android:gravity="center"
    51.                         android:text="数量"
    52.                         android:textColor="@color/black"
    53.                         android:textSize="15sp" />
    54.  
    55.                     <TextView
    56.                         android:layout_width="0dp"
    57.                         android:layout_height="wrap_content"
    58.                         android:layout_weight="1"
    59.                         android:gravity="center"
    60.                         android:text="单价"
    61.                         android:textColor="@color/black"
    62.                         android:textSize="15sp" />
    63.  
    64.                     <TextView
    65.                         android:layout_width="0dp"
    66.                         android:layout_height="wrap_content"
    67.                         android:layout_weight="1"
    68.                         android:gravity="center"
    69.                         android:text="总价"
    70.                         android:textColor="@color/black"
    71.                         android:textSize="15sp" />
    72.  
    73.                 </LinearLayout>
    74.  
    75.                 <LinearLayout
    76.                     android:id="@+id/ll_cart"
    77.                     android:layout_width="match_parent"
    78.                     android:layout_height="wrap_content"
    79.                     android:orientation="vertical" />
    80.  
    81.                 <LinearLayout
    82.                     android:layout_width="match_parent"
    83.                     android:layout_height="wrap_content"
    84.                     android:orientation="horizontal"
    85.                     android:padding="0dp" >
    86.  
    87.                     <Button
    88.                         android:id="@+id/btn_clear"
    89.                         android:layout_width="wrap_content"
    90.                         android:layout_height="wrap_content"
    91.                         android:gravity="center"
    92.                         android:text="清空"
    93.                         android:textColor="@color/black"
    94.                         android:textSize="17sp" />
    95.  
    96.                     <TextView
    97.                         android:layout_width="0dp"
    98.                         android:layout_height="wrap_content"
    99.                         android:layout_weight="1"
    100.                         android:gravity="center|right"
    101.                         android:text="总金额："
    102.                         android:textColor="@color/black"
    103.                         android:textSize="17sp" />
    104.  
    105.                     <TextView
    106.                         android:id="@+id/tv_total_price"
    107.                         android:layout_width="wrap_content"
    108.                         android:layout_height="wrap_content"
    109.                         android:layout_marginRight="10dp"
    110.                         android:gravity="center|left"
    111.                         android:textColor="@color/red"
    112.                         android:textSize="25sp" />
    113.  
    114.                     <Button
    115.                         android:id="@+id/btn_settle"
    116.                         android:layout_width="wrap_content"
    117.                         android:layout_height="wrap_content"
    118.                         android:gravity="center"
    119.                         android:text="结算"
    120.                         android:textColor="@color/black"
    121.                         android:textSize="17sp" />
    122.                 </LinearLayout>
    123.  
    124.             </LinearLayout>
    125.  
    126.             <LinearLayout
    127.                 android:id="@+id/ll_empty"
    128.                 android:layout_width="match_parent"
    129.                 android:layout_height="wrap_content"
    130.                 android:orientation="vertical"
    131.                 android:visibility="gone" >
    132.  
    133.                 <TextView
    134.                     android:layout_width="match_parent"
    135.                     android:layout_height="wrap_content"
    136.                     android:layout_marginBottom="100dp"
    137.                     android:layout_marginTop="100dp"
    138.                     android:gravity="center"
    139.                     android:text="哎呀，购物车空空如也，快去选购商品吧"
    140.                     android:textColor="@color/black"
    141.                     android:textSize="17sp" />
    142.  
    143.                 <Button
    144.                     android:id="@+id/btn_shopping_channel"
    145.                     android:layout_width="match_parent"
    146.                     android:layout_height="wrap_content"
    147.                     android:gravity="center"
    148.                     android:text="逛逛手机商场"
    149.                     android:textColor="@color/black"
    150.                     android:textSize="17sp" />
    151.             </LinearLayout>
    152.         </RelativeLayout>
    153.     </ScrollView>
    154.  
    155. </LinearLayout>
    


    title_shopping.xml

    1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    2.     android:layout_width="match_parent"
    3.     android:layout_height="50dp"
    4.     android:background="#aaaaff" >
    5.     
    6.     <ImageView
    7.         android:id="@+id/iv_back"
    8.         android:layout_width="50dp"
    9.         android:layout_height="match_parent"
    10.         android:layout_alignParentLeft="true"
    11.         android:padding="10dp"
    12.         android:scaleType="fitCenter"
    13.         android:src="@drawable/ic_back" />
    14.  
    15.     <TextView
    16.         android:id="@+id/tv_title"
    17.         android:layout_width="wrap_content"
    18.         android:layout_height="match_parent"
    19.         android:layout_centerInParent="true"
    20.         android:gravity="center"
    21.         android:textColor="@color/black"
    22.         android:textSize="20sp" />
    23.     
    24.     <ImageView
    25.         android:id="@+id/iv_cart"
    26.         android:layout_width="50dp"
    27.         android:layout_height="match_parent"
    28.         android:layout_alignParentRight="true"
    29.         android:scaleType="fitCenter"
    30.         android:src="@drawable/cart" />
    31.     
    32.     <TextView
    33.         android:id="@+id/tv_count"
    34.         android:layout_width="20dp"
    35.         android:layout_height="20dp"
    36.         android:layout_alignParentTop="true"
    37.         android:layout_toRightOf="@+id/iv_cart"
    38.         android:layout_marginLeft="-20dp"
    39.         android:gravity="center"
    40.         android:background="@drawable/shape_oval_red"
    41.         android:text="0"
    42.         android:textColor="@color/white"
    43.         android:textSize="15sp" />
    44.     
    45. </RelativeLayout>

     

    代码：

    1. package com.example.myapplication;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.app.AlertDialog;
    5. import android.content.DialogInterface;
    6. import android.content.Intent;
    7. import android.graphics.Bitmap;
    8. import android.graphics.BitmapFactory;
    9. import android.net.Uri;
    10. import android.os.Bundle;
    11. import android.os.Environment;
    12. import android.util.Log;
    13. import android.view.LayoutInflater;
    14. import android.view.View;
    15. import android.widget.ImageView;
    16. import android.widget.LinearLayout;
    17. import android.widget.TextView;
    18. import androidx.appcompat.app.AppCompatActivity;
    19. import com.example.myapplication.bean.CartInfo;
    20. import com.example.myapplication.bean.GoodsInfo;
    21. import com.example.myapplication.database.CartDBHelper;
    22. import com.example.myapplication.database.GoodsDBHelper;
    23. import com.example.myapplication.util.SharedUtil;
    24. import java.util.ArrayList;
    25. import java.util.HashMap;
    26. import java.util.List;
    27.  
    28. @SuppressLint("SetTextI18n")
    29. public class ShoppingCartActivity extends AppCompatActivity implements View.OnClickListener
    30. {
    31.     private final static String TAG = "ShoppingCartActivity";
    32.     private TextView tv_count;
    33.     private TextView tv_total_price;
    34.     private LinearLayout ll_content;
    35.     private LinearLayout ll_cart; // 声明一个购物车列表的线性布局对象
    36.     private LinearLayout ll_empty;
    37.     private GoodsDBHelper mGoodsHelper; // 声明一个商品数据库的帮助器对象
    38.     private CartDBHelper mCartHelper; // 声明一个购物车数据库的帮助器对象
    39.  
    40.     @Override
    41.     protected void onCreate(Bundle savedInstanceState)
    42.     {
    43.         super.onCreate(savedInstanceState);
    44.         setContentView(R.layout.activity_shopping_cart);
    45.         
    46.         
    47.         TextView tv_title = findViewById(R.id.tv_title);
    48.         tv_title.setText("购物车");
    49.         tv_count = findViewById(R.id.tv_count);
    50.         tv_total_price = findViewById(R.id.tv_total_price);
    51.         ll_content = findViewById(R.id.ll_content);
    52.         ll_cart = findViewById(R.id.ll_cart);
    53.         ll_empty = findViewById(R.id.ll_empty);
    54.         
    55.         
    56.         findViewById(R.id.iv_back).setOnClickListener(this);
    57.         findViewById(R.id.btn_shopping_channel).setOnClickListener(this);
    58.         findViewById(R.id.btn_clear).setOnClickListener(this);
    59.         findViewById(R.id.btn_settle).setOnClickListener(this);
    60.     }
    61.  
    62.     // 显示购物车图标中的商品数量
    63.     private void showCount()
    64.     {
    65.         tv_count.setText("" + MainApplication.goodsCount);
    66.         
    67.         if (MainApplication.goodsCount == 0) 
    68.         {
    69.             ll_content.setVisibility(View.GONE);
    70.             ll_cart.removeAllViews(); // 移除下面的所有子视图
    71.             mGoodsMap.clear();
    72.             ll_empty.setVisibility(View.VISIBLE);
    73.         } 
    74.         else
    75.         {
    76.             ll_content.setVisibility(View.VISIBLE);
    77.             ll_empty.setVisibility(View.GONE);
    78.         }
    79.     }
    80.  
    81.     @Override
    82.     public void onClick(View v)
    83.     {
    84.         if (v.getId() == R.id.iv_back) { // 点击了返回图标
    85.             finish(); // 关闭当前页面
    86.         }
    87.         else if (v.getId() == R.id.btn_shopping_channel) { // 点击了“商场”按钮
    88.             // 从购物车页面跳到商场页面
    89.             Intent intent = new Intent(this, ShoppingChannelActivity.class);
    90.             intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); // 设置启动标志
    91.             startActivity(intent); // 跳转到手机商场页面
    92.         }
    93.         else if (v.getId() == R.id.btn_clear) { // 点击了“清空”按钮
    94.             mCartHelper.deleteAll(); // 清空购物车数据库
    95.             MainApplication.goodsCount = 0;
    96.             showCount(); // 显示最新的商品数量
    97.             ToastUtil.show(this, "购物车已清空");
    98.         }
    99.         else if (v.getId() == R.id.btn_settle) { // 点击了“结算”按钮
    100.             AlertDialog.Builder builder = new AlertDialog.Builder(this);
    101.             builder.setTitle("结算商品");
    102.             builder.setMessage("客官抱歉，支付功能尚未开通，请下次再来");
    103.             builder.setPositiveButton("我知道了", null);
    104.             builder.create().show(); // 显示提醒对话框
    105.         }
    106.     }
    107.  
    108.     @Override
    109.     protected void onResume() 
    110.     {
    111.         super.onResume();
    112.         
    113.         
    114.         showCount(); // 显示购物车的商品数量
    115.         // 获取商品数据库的帮助器对象
    116.         mGoodsHelper = GoodsDBHelper.getInstance(this, 1);
    117.         mGoodsHelper.openWriteLink(); // 打开商品数据库的写连接
    118.         // 获取购物车数据库的帮助器对象
    119.         mCartHelper = CartDBHelper.getInstance(this, 1);
    120.         mCartHelper.openWriteLink(); // 打开购物车数据库的写连接
    121.         downloadGoods(); // 模拟从网络下载商品图片
    122.         showCart(); // 展示购物车中的商品列表
    123.     }
    124.  
    125.     @Override
    126.     protected void onPause() 
    127.     {
    128.         super.onPause();
    129.         
    130.         
    131.         mGoodsHelper.closeLink(); // 关闭商品数据库的数据库连接
    132.         mCartHelper.closeLink(); // 关闭购物车数据库的数据库连接
    133.     }
    134.  
    135.     // 声明一个购物车中的商品信息列表
    136.     private List<CartInfo> mCartArray = new ArrayList<CartInfo>();
    137.     // 声明一个根据商品编号查找商品信息的映射
    138.     private HashMap<Long, GoodsInfo> mGoodsMap = new HashMap<Long, GoodsInfo>();
    139.  
    140.     private void deleteGoods(CartInfo info) 
    141.     {
    142.         MainApplication.goodsCount -= info.count;
    143.         
    144.         // 从购物车的数据库中删除商品
    145.         mCartHelper.delete("goods_id=" + info.goods_id);
    146.         
    147.         // 从购物车的列表中删除商品
    148.         for (int i = 0; i < mCartArray.size(); i++)
    149.         {
    150.             if (info.goods_id == mCartArray.get(i).goods_id) {
    151.                 mCartArray.remove(i);
    152.                 break;
    153.             }
    154.         }
    155.         
    156.         showCount(); // 显示最新的商品数量
    157.         ToastUtil.show(this, "已从购物车删除" + mGoodsMap.get(info.goods_id).name);
    158.         mGoodsMap.remove(info.goods_id);
    159.         refreshTotalPrice(); // 刷新购物车中所有商品的总金额
    160.     }
    161.  
    162.     // 展示购物车中的商品列表
    163.     private void showCart()
    164.     {
    165.         ll_cart.removeAllViews(); // 移除下面的所有子视图
    166.         mCartArray = mCartHelper.query("1=1"); // 查询购物车数据库中所有的商品记录
    167.         Log.d(TAG, "mCartArray.size()=" + mCartArray.size());
    168.         
    169.         if (mCartArray == null || mCartArray.size() <= 0)
    170.         {
    171.             return;
    172.         }
    173.         
    174.         for (int i = 0; i < mCartArray.size(); i++)
    175.         {
    176.             final CartInfo info = mCartArray.get(i);
    177.             // 根据商品编号查询商品数据库中的商品记录
    178.             final GoodsInfo goods = mGoodsHelper.queryById(info.goods_id);
    179.             Log.d(TAG, "name=" + goods.name + ",price=" + goods.price + ",desc=" + goods.desc);
    180.             
    181.             mGoodsMap.put(info.goods_id, goods);
    182.             
    183.             // 获取布局文件item_goods.xml的根视图
    184.             View view = LayoutInflater.from(this).inflate(R.layout.item_cart, null);
    185.             ImageView iv_thumb = view.findViewById(R.id.iv_thumb);
    186.             TextView tv_name = view.findViewById(R.id.tv_name);
    187.             TextView tv_desc = view.findViewById(R.id.tv_desc);
    188.             TextView tv_count = view.findViewById(R.id.tv_count);
    189.             TextView tv_price = view.findViewById(R.id.tv_price);
    190.             TextView tv_sum = view.findViewById(R.id.tv_sum);
    191.             
    192.             
    193.             // 给商品行添加点击事件。点击商品行跳到商品的详情页
    194.             view.setOnClickListener(new View.OnClickListener() 
    195.             {
    196.                 @Override
    197.                 public void onClick(View v) 
    198.                 {
    199.                     Intent intent = new Intent(ShoppingCartActivity.this, ShoppingDetailActivity.class);
    200.                     intent.putExtra("goods_id", info.goods_id);
    201.                     startActivity(intent); // 跳到商品详情页面
    202.                 }
    203.             });
    204.             
    205.             
    206.             // 给商品行添加长按事件。长按商品行就删除该商品
    207.             view.setOnLongClickListener(new View.OnLongClickListener() 
    208.             {
    209.                 @Override
    210.                 public boolean onLongClick(final View v)
    211.                 {
    212.                     AlertDialog.Builder builder = new AlertDialog.Builder(ShoppingCartActivity.this);
    213.                     builder.setMessage("是否从购物车删除"+goods.name+"？");
    214.                     builder.setPositiveButton("是", new DialogInterface.OnClickListener() {
    215.                         @Override
    216.                         public void onClick(DialogInterface dialog, int which) {
    217.                             ll_cart.removeView(v); // 移除当前视图
    218.                             deleteGoods(info); // 删除该商品
    219.                         }
    220.                     });
    221.                     
    222.                     builder.setNegativeButton("否", null);
    223.                     builder.create().show(); // 显示提醒对话框
    224.                     return true;
    225.                 }
    226.             });
    227.             
    228.             
    229.             iv_thumb.setImageURI(Uri.parse(goods.pic_path)); // 设置商品图片
    230.             tv_name.setText(goods.name); // 设置商品名称
    231.             tv_desc.setText(goods.desc); // 设置商品描述
    232.             tv_count.setText("" + info.count); // 设置商品数量
    233.             tv_price.setText("" + (int)goods.price); // 设置商品单价
    234.             tv_sum.setText("" + (int)(info.count * goods.price)); // 设置商品总价
    235.             ll_cart.addView(view); // 往购物车列表添加该商品行
    236.         }
    237.         
    238.         refreshTotalPrice(); // 重新计算购物车中的商品总金额
    239.     }
    240.  
    241.     // 重新计算购物车中的商品总金额
    242.     private void refreshTotalPrice()
    243.     {
    244.         int total_price = 0;
    245.         
    246.         for (CartInfo info : mCartArray) 
    247.         {
    248.             GoodsInfo goods = mGoodsMap.get(info.goods_id);
    249.             total_price += goods.price * info.count;
    250.         }
    251.         
    252.         tv_total_price.setText("" + total_price);
    253.     }
    254.  
    255.     private String mFirst = "true"; // 是否首次打开
    256.     // 模拟网络数据，初始化数据库中的商品信息
    257.     private void downloadGoods()
    258.     {
    259.         // 获取共享参数保存的是否首次打开参数
    260.         mFirst = SharedUtil.getIntance(this).readString("first", "true");
    261.         
    262.         // 获取当前App的私有下载路径
    263.         String path = getExternalFilesDir(Environment.DIRECTORY_DOWNLOADS).toString() + "/";
    264.         
    265.         if (mFirst.equals("true"))       // 如果是首次打开
    266.         { 
    267.             ArrayList<GoodsInfo> goodsList = GoodsInfo.getDefaultList(); // 模拟网络图片下载
    268.             
    269.             for (int i = 0; i < goodsList.size(); i++) 
    270.             {
    271.                 GoodsInfo info = goodsList.get(i);
    272.                 long rowid = mGoodsHelper.insert(info); // 往商品数据库插入一条该商品的记录
    273.                 info.rowid = rowid;
    274.                 Bitmap pic = BitmapFactory.decodeResource(getResources(), info.pic);
    275.                 String pic_path = path + rowid + ".jpg";
    276.                 FileUtil.saveImage(pic_path, pic); // 往存储卡保存商品图片
    277.                 pic.recycle(); // 回收位图对象
    278.                 info.pic_path = pic_path;
    279.                 mGoodsHelper.update(info); // 更新商品数据库中该商品记录的图片路径
    280.             }
    281.         }
    282.         
    283.         // 把是否首次打开写入共享参数
    284.         SharedUtil.getIntance(this).writeString("first", "false");
    285.     }
    286.  
    287. }
    

    ShoppingChannelActivity布局：

    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    2.     android:layout_width="match_parent"
    3.     android:layout_height="match_parent"
    4.     android:background="@color/orange"
    5.     android:orientation="vertical" >
    6.  
    7.     <include layout="@layout/title_shopping" />
    8.  
    9.     <ScrollView
    10.         android:layout_width="match_parent"
    11.         android:layout_height="wrap_content" >
    12.  
    13.         <GridLayout
    14.             android:id="@+id/gl_channel"
    15.             android:layout_width="match_parent"
    16.             android:layout_height="wrap_content"
    17.             android:columnCount="2" />
    18.     </ScrollView>
    19.  
    20. </LinearLayout>
    


    ShoppingChannelActivity代码：

    1. package com.example.myapplication;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.content.Intent;
    5. import android.net.Uri;
    6. import android.os.Bundle;
    7. import android.view.LayoutInflater;
    8. import android.view.View;
    9. import android.widget.Button;
    10. import android.widget.GridLayout;
    11. import android.widget.ImageView;
    12. import android.widget.LinearLayout;
    13. import android.widget.TextView;
    14. import androidx.appcompat.app.AppCompatActivity;
    15. import com.example.myapplication.bean.GoodsInfo;
    16. import com.example.myapplication.database.CartDBHelper;
    17. import com.example.myapplication.database.GoodsDBHelper;
    18. import com.example.myapplication.util.Utils;
    19. import java.util.List;
    20.  
    21. @SuppressLint("SetTextI18n")
    22. public class ShoppingChannelActivity extends AppCompatActivity implements View.OnClickListener 
    23. {
    24.     private TextView tv_count;
    25.     private GridLayout gl_channel; // 声明一个商品频道的网格布局对象
    26.     private GoodsDBHelper mGoodsHelper; // 声明一个商品数据库的帮助器对象
    27.     private CartDBHelper mCartHelper; // 声明一个购物车数据库的帮助器对象
    28.  
    29.     @Override
    30.     protected void onCreate(Bundle savedInstanceState)
    31.     {
    32.         super.onCreate(savedInstanceState);
    33.         setContentView(R.layout.activity_shopping_channel);
    34.         
    35.         
    36.         TextView tv_title = findViewById(R.id.tv_title);
    37.         tv_title.setText("手机商场");
    38.         
    39.         tv_count = findViewById(R.id.tv_count);
    40.         gl_channel = findViewById(R.id.gl_channel);
    41.         
    42.         findViewById(R.id.iv_back).setOnClickListener(this);
    43.         findViewById(R.id.iv_cart).setOnClickListener(this);
    44.     }
    45.  
    46.     @Override
    47.     public void onClick(View v) 
    48.     {
    49.         if (v.getId() == R.id.iv_back)      // 点击了返回图标
    50.         { 
    51.             finish(); // 关闭当前页面
    52.         }
    53.         else if (v.getId() == R.id.iv_cart)      // 点击了购物车图标
    54.         { 
    55.             // 从商场页面跳到购物车页面
    56.             Intent intent = new Intent(this, ShoppingCartActivity.class);
    57.             intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); // 设置启动标志
    58.             startActivity(intent); // 跳转到购物车页面
    59.         }
    60.     }
    61.  
    62.     // 把指定编号的商品添加到购物车
    63.     private void addToCart(long goods_id, String goods_name) 
    64.     {
    65.         MainApplication.goodsCount++;
    66.         
    67.         tv_count.setText("" + MainApplication.goodsCount);
    68.         mCartHelper.save(goods_id); // 把该商品填入购物车数据库
    69.         
    70.         ToastUtil.show(this, "已添加一部" + goods_name + "到购物车");
    71.     }
    72.  
    73.     @Override
    74.     protected void onResume() 
    75.     {
    76.         super.onResume();
    77.         tv_count.setText("" + MainApplication.goodsCount);
    78.         
    79.         // 获取商品数据库的帮助器对象
    80.         mGoodsHelper = GoodsDBHelper.getInstance(this, 1);
    81.         
    82.         mGoodsHelper.openReadLink(); // 打开商品数据库的读连接
    83.         
    84.         // 获取购物车数据库的帮助器对象
    85.         mCartHelper = CartDBHelper.getInstance(this, 1);
    86.         
    87.         mCartHelper.openWriteLink(); // 打开购物车数据库的写连接
    88.         
    89.         showGoods(); // 展示商品列表
    90.     }
    91.  
    92.     @Override
    93.     protected void onPause() 
    94.     {
    95.         super.onPause();
    96.         mGoodsHelper.closeLink(); // 关闭商品数据库的数据库连接
    97.         mCartHelper.closeLink(); // 关闭购物车数据库的数据库连接
    98.     }
    99.  
    100.     private void showGoods() 
    101.     {
    102.         int screenWidth = Utils.getScreenWidth(this);
    103.         LinearLayout.LayoutParams params = new LinearLayout.LayoutParams(screenWidth/2, LinearLayout.LayoutParams.WRAP_CONTENT);
    104.         
    105.         gl_channel.removeAllViews(); // 移除下面的所有子视图
    106.         
    107.         // 查询商品数据库中的所有商品记录
    108.         List<GoodsInfo> goodsArray = mGoodsHelper.query("1=1");
    109.         
    110.         for (final GoodsInfo info : goodsArray) 
    111.         {
    112.             // 获取布局文件item_goods.xml的根视图
    113.             View view = LayoutInflater.from(this).inflate(R.layout.item_goods, null);
    114.             ImageView iv_thumb = view.findViewById(R.id.iv_thumb);
    115.             TextView tv_name = view.findViewById(R.id.tv_name);
    116.             TextView tv_price = view.findViewById(R.id.tv_price);
    117.             Button btn_add = view.findViewById(R.id.btn_add);
    118.             tv_name.setText(info.name); // 设置商品名称
    119.             iv_thumb.setImageURI(Uri.parse(info.pic_path)); // 设置商品图片
    120.             iv_thumb.setOnClickListener(new View.OnClickListener() {
    121.                 @Override
    122.                 public void onClick(View v) {
    123.                     Intent intent = new Intent(ShoppingChannelActivity.this, ShoppingDetailActivity.class);
    124.                     intent.putExtra("goods_id", info.rowid);
    125.                     startActivity(intent); // 跳到商品详情页面
    126.                 }
    127.             });
    128.             
    129.             
    130.             tv_price.setText("" + (int)info.price); // 设置商品价格
    131.             
    132.             btn_add.setOnClickListener(new View.OnClickListener() 
    133.             {
    134.                 @Override
    135.                 public void onClick(View v) {
    136.                     addToCart(info.rowid, info.name); // 添加到购物车
    137.                 }
    138.             });
    139.             
    140.             gl_channel.addView(view, params); // 把商品视图添加到网格布局
    141.         }
    142.     }
    143.  
    144. }
    

    ShoppingDetailActivity布局：

    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    2.     android:layout_width="match_parent"
    3.     android:layout_height="match_parent"
    4.     android:background="@color/orange"
    5.     android:orientation="vertical" >
    6.  
    7.     <include layout="@layout/title_shopping" />
    8.  
    9.     <ScrollView
    10.         android:layout_width="match_parent"
    11.         android:layout_height="wrap_content" >
    12.  
    13.         <LinearLayout
    14.             android:layout_width="match_parent"
    15.             android:layout_height="wrap_content"
    16.             android:orientation="vertical" >
    17.  
    18.             <ImageView
    19.                 android:id="@+id/iv_goods_pic"
    20.                 android:layout_width="match_parent"
    21.                 android:layout_height="350dp"
    22.                 android:scaleType="fitCenter" />
    23.  
    24.             <TextView
    25.                 android:id="@+id/tv_goods_price"
    26.                 android:layout_width="match_parent"
    27.                 android:layout_height="wrap_content"
    28.                 android:paddingLeft="5dp"
    29.                 android:textColor="@color/red"
    30.                 android:textSize="22sp" />
    31.  
    32.             <TextView
    33.                 android:id="@+id/tv_goods_desc"
    34.                 android:layout_width="match_parent"
    35.                 android:layout_height="wrap_content"
    36.                 android:paddingLeft="5dp"
    37.                 android:textColor="@color/black"
    38.                 android:textSize="15sp" />
    39.  
    40.             <Button
    41.                 android:id="@+id/btn_add_cart"
    42.                 android:layout_width="match_parent"
    43.                 android:layout_height="wrap_content"
    44.                 android:text="加入购物车"
    45.                 android:textColor="@color/black"
    46.                 android:textSize="17sp" />
    47.         </LinearLayout>
    48.     </ScrollView>
    49.  
    50. </LinearLayout>
    


    代码：

    1. package com.example.myapplication;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.content.Intent;
    5. import android.net.Uri;
    6. import android.os.Bundle;
    7. import android.view.View;
    8. import android.view.View.OnClickListener;
    9. import android.widget.ImageView;
    10. import android.widget.TextView;
    11. import android.widget.Toast;
    12. import androidx.appcompat.app.AppCompatActivity;
    13. import com.example.myapplication.bean.GoodsInfo;
    14. import com.example.myapplication.database.CartDBHelper;
    15. import com.example.myapplication.database.GoodsDBHelper;
    16.  
    17. @SuppressLint("SetTextI18n")
    18. public class ShoppingDetailActivity extends AppCompatActivity implements View.OnClickListener
    19. {
    20.     private TextView tv_title;
    21.     private TextView tv_count;
    22.     private TextView tv_goods_price;
    23.     private TextView tv_goods_desc;
    24.     private ImageView iv_goods_pic;
    25.     private long mGoodsId; // 当前商品的商品编号
    26.     private GoodsDBHelper mGoodsHelper; // 声明一个商品数据库的帮助器对象
    27.     private CartDBHelper mCartHelper; // 声明一个购物车数据库的帮助器对象
    28.  
    29.     @Override
    30.     protected void onCreate(Bundle savedInstanceState)
    31.     {
    32.         super.onCreate(savedInstanceState);
    33.         setContentView(R.layout.activity_shopping_detail);
    34.  
    35.  
    36.         tv_title = findViewById(R.id.tv_title);
    37.         tv_count = findViewById(R.id.tv_count);
    38.         tv_goods_price = findViewById(R.id.tv_goods_price);
    39.         tv_goods_desc = findViewById(R.id.tv_goods_desc);
    40.         iv_goods_pic = findViewById(R.id.iv_goods_pic);
    41.  
    42.  
    43.         findViewById(R.id.iv_back).setOnClickListener(this);
    44.         findViewById(R.id.iv_cart).setOnClickListener(this);
    45.         findViewById(R.id.btn_add_cart).setOnClickListener(this);
    46.         tv_count.setText("" + MainApplication.goodsCount);
    47.     }
    48.  
    49.     @Override
    50.     public void onClick(View v)
    51.     {
    52.         if (v.getId() == R.id.iv_back)  // 点击了返回图标
    53.         {
    54.             finish(); // 关闭当前页面
    55.         }
    56.         else if (v.getId() == R.id.iv_cart)  // 点击了购物车图标
    57.         {
    58.             Intent intent = new Intent(this, ShoppingCartActivity.class);
    59.             startActivity(intent); // 跳转到购物车页面
    60.         }
    61.         else if (v.getId() == R.id.btn_add_cart)   // 点击了“添加”按钮
    62.         {
    63.             addToCart(mGoodsId); // 把该商品添加到购物车
    64.         }
    65.     }
    66.  
    67.     // 把指定编号的商品添加到购物车
    68.     private void addToCart(long goods_id)
    69.     {
    70.         MainApplication.goodsCount++;
    71.         tv_count.setText("" + MainApplication.goodsCount);
    72.         mCartHelper.save(goods_id); // 把该商品填入购物车数据库
    73.         ToastUtil.show(this, "成功添加至购物车");
    74.     }
    75.  
    76.     @Override
    77.     protected void onResume()
    78.     {
    79.  
    80.         super.onResume();
    81.  
    82.  
    83.         // 获取商品数据库的帮助器对象
    84.         mGoodsHelper = GoodsDBHelper.getInstance(this, 1);
    85.         mGoodsHelper.openReadLink(); // 打开商品数据库的读连接
    86.         // 获取购物车数据库的帮助器对象
    87.         mCartHelper = CartDBHelper.getInstance(this, 1);
    88.         mCartHelper.openWriteLink(); // 打开购物车数据库的写连接
    89.         showDetail(); // 展示商品详情
    90.     }
    91.  
    92.     @Override
    93.     protected void onPause()
    94.     {
    95.         super.onPause();
    96.  
    97.  
    98.         mGoodsHelper.closeLink(); // 关闭商品数据库的数据库连接
    99.         mCartHelper.closeLink(); // 关闭购物车数据库的数据库连接
    100.     }
    101.  
    102.     private void showDetail()
    103.     {
    104.         // 获取上一个页面传来的商品编号
    105.         mGoodsId = getIntent().getLongExtra("goods_id", 0L);
    106.  
    107.         if (mGoodsId > 0)
    108.         {
    109.             // 根据商品编号查询商品数据库中的商品记录
    110.             GoodsInfo info = mGoodsHelper.queryById(mGoodsId);
    111.             tv_title.setText(info.name); // 设置商品名称
    112.             tv_goods_desc.setText(info.desc); // 设置商品描述
    113.             tv_goods_price.setText("" + (int)info.price); // 设置商品价格
    114.             iv_goods_pic.setImageURI(Uri.parse(info.pic_path)); // 设置商品图片
    115.         }
    116.     }
    117.  
    118. }
    

    

    CartInfo

    

    1. package com.example.myapplication.bean;
    2.  
    3. //购物车信息
    4. public class CartInfo {
    5.     public long rowid; // 行号
    6.     public int xuhao; // 序号
    7.     public long goods_id; // 商品编号
    8.     public int count; // 商品数量
    9.     public String update_time; // 更新时间
    10.  
    11.     public CartInfo() {
    12.         rowid = 0L;
    13.         xuhao = 0;
    14.         goods_id = 0L;
    15.         count = 0;
    16.         update_time = "";
    17.     }
    18. }
    

    

    

    GoodsInfo

    

    1. package com.example.myapplication.bean;
    2.  
    3. import com.example.myapplication.R;
    4.  
    5. import java.util.ArrayList;
    6.  
    7. public class GoodsInfo
    8. {
    9.     public long rowid; // 行号
    10.     public int xuhao; // 序号
    11.     public String name; // 名称
    12.     public String desc; // 描述
    13.     public float price; // 价格
    14.     public String pic_path; // 大图的保存路径
    15.     public int pic; // 大图的资源编号
    16.  
    17.     public GoodsInfo()
    18.     {
    19.         rowid = 0L;
    20.         xuhao = 0;
    21.         name = "";
    22.         desc = "";
    23.         price = 0;
    24.         pic_path = "";
    25.         pic = 0;
    26.     }
    27.  
    28.     // 声明一个手机商品的名称数组
    29.     private static String[] mNameArray =
    30.             {
    31.             "iPhone11", "Mate30", "小米10", "OPPO Reno3", "vivo X30", "荣耀30S"
    32.     };
    33.     // 声明一个手机商品的描述数组
    34.     private static String[] mDescArray =
    35.             {
    36.             "Apple iPhone11 256GB 绿色 4G全网通手机",
    37.             "华为 HUAWEI Mate30 8GB+256GB 丹霞橙 5G全网通 全面屏手机",
    38.             "小米 MI10 8GB+128GB 钛银黑 5G手机 游戏拍照手机",
    39.             "OPPO Reno3 8GB+128GB 蓝色星夜 双模5G 拍照游戏智能手机",
    40.             "vivo X30 8GB+128GB 绯云 5G全网通 美颜拍照手机",
    41.             "荣耀30S 8GB+128GB 蝶羽红 5G芯片 自拍全面屏手机"
    42.     };
    43.     // 声明一个手机商品的价格数组
    44.     private static float[] mPriceArray = {6299, 4999, 3999, 2999, 2998, 2399};
    45.     // 声明一个手机商品的大图数组
    46.     private static int[] mPicArray = {
    47.             R.drawable.iphone, R.drawable.huawei, R.drawable.xiaomi,
    48.             R.drawable.oppo, R.drawable.vivo, R.drawable.rongyao
    49.     };
    50.  
    51.     // 获取默认的手机信息列表
    52.     public static ArrayList<GoodsInfo> getDefaultList()
    53.     {
    54.         ArrayList<GoodsInfo> goodsList = new ArrayList<GoodsInfo>();
    55.  
    56.         for (int i = 0; i < mNameArray.length; i++)
    57.         {
    58.             GoodsInfo info = new GoodsInfo();
    59.             info.name = mNameArray[i];
    60.             info.desc = mDescArray[i];
    61.             info.price = mPriceArray[i];
    62.             info.pic = mPicArray[i];
    63.             goodsList.add(info);
    64.         }
    65.  
    66.         return goodsList;
    67.     }
    68.  
    69. }
    


    

    CartDBHelper

    

    1. package com.example.myapplication.database;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.content.ContentValues;
    5. import android.content.Context;
    6. import android.database.Cursor;
    7. import android.database.sqlite.SQLiteDatabase;
    8. import android.database.sqlite.SQLiteOpenHelper;
    9. import android.util.Log;
    10. import com.example.myapplication.DateUtil;
    11. import com.example.myapplication.bean.CartInfo;
    12. import java.util.ArrayList;
    13. import java.util.List;
    14.  
    15. @SuppressLint("DefaultLocale")
    16. public class CartDBHelper extends SQLiteOpenHelper
    17. {
    18.     private static final String TAG = "CartDBHelper";
    19.     private static final String DB_NAME = "cart.db"; // 数据库的名称
    20.     private static final int DB_VERSION = 1; // 数据库的版本号
    21.     private static CartDBHelper mHelper = null; // 数据库帮助器的实例
    22.     private SQLiteDatabase mDB = null; // 数据库的实例
    23.     private static final String TABLE_NAME = "cart_info"; // 表的名称
    24.  
    25.     private CartDBHelper(Context context) {
    26.         super(context, DB_NAME, null, DB_VERSION);
    27.     }
    28.  
    29.     private CartDBHelper(Context context, int version) {
    30.         super(context, DB_NAME, null, version);
    31.     }
    32.  
    33.     // 利用单例模式获取数据库帮助器的唯一实例
    34.     public static CartDBHelper getInstance(Context context, int version) {
    35.         if (version > 0 && mHelper == null) {
    36.             mHelper = new CartDBHelper(context, version);
    37.         } else if (mHelper == null) {
    38.             mHelper = new CartDBHelper(context);
    39.         }
    40.         return mHelper;
    41.     }
    42.  
    43.     // 打开数据库的读连接
    44.     public SQLiteDatabase openReadLink() {
    45.         if (mDB == null || !mDB.isOpen()) {
    46.             mDB = mHelper.getReadableDatabase();
    47.         }
    48.         return mDB;
    49.     }
    50.  
    51.     // 打开数据库的写连接
    52.     public SQLiteDatabase openWriteLink() {
    53.         if (mDB == null || !mDB.isOpen()) {
    54.             mDB = mHelper.getWritableDatabase();
    55.         }
    56.         return mDB;
    57.     }
    58.  
    59.     // 关闭数据库连接
    60.     public void closeLink() {
    61.         if (mDB != null && mDB.isOpen()) {
    62.             mDB.close();
    63.             mDB = null;
    64.         }
    65.     }
    66.  
    67.     // 创建数据库，执行建表语句
    68.     @Override
    69.     public void onCreate(SQLiteDatabase db) {
    70.         Log.d(TAG, "onCreate");
    71.         String drop_sql = "DROP TABLE IF EXISTS " + TABLE_NAME + ";";
    72.         Log.d(TAG, "drop_sql:" + drop_sql);
    73.         db.execSQL(drop_sql);
    74.         String create_sql = "CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " ("
    75.                 + "_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
    76.                 + "goods_id INTEGER NOT NULL," + "count INTEGER NOT NULL,"
    77.                 + "update_time VARCHAR NOT NULL" + ");";
    78.         Log.d(TAG, "create_sql:" + create_sql);
    79.         db.execSQL(create_sql); // 执行完整的SQL语句
    80.     }
    81.  
    82.     // 修改数据库，执行表结构变更语句
    83.     @Override
    84.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    85.     }
    86.  
    87.     // 根据指定条件删除表记录
    88.     public int delete(String condition) {
    89.         // 执行删除记录动作，该语句返回删除记录的数目
    90.         return mDB.delete(TABLE_NAME, condition, null);
    91.     }
    92.  
    93.     // 删除该表的所有记录
    94.     public int deleteAll() {
    95.         // 执行删除记录动作，该语句返回删除记录的数目
    96.         return mDB.delete(TABLE_NAME, "1=1", null);
    97.     }
    98.  
    99.     // 往该表添加一条记录
    100.     public long insert(CartInfo info) {
    101.         List<CartInfo> infoList = new ArrayList<CartInfo>();
    102.         infoList.add(info);
    103.         return insert(infoList);
    104.     }
    105.  
    106.     // 往该表添加多条记录
    107.     public long insert(List<CartInfo> infoList) {
    108.         long result = -1;
    109.         for (CartInfo info : infoList) {
    110.             Log.d(TAG, "goods_id=" + info.goods_id + ", count=" + info.count);
    111.             // 如果存在相同rowid的记录，则更新记录
    112.             if (info.rowid > 0) {
    113.                 String condition = String.format("rowid='%d'", info.rowid);
    114.                 update(info, condition);
    115.                 result = info.rowid;
    116.                 continue;
    117.             }
    118.             // 不存在唯一性重复的记录，则插入新记录
    119.             ContentValues cv = new ContentValues();
    120.             cv.put("goods_id", info.goods_id);
    121.             cv.put("count", info.count);
    122.             cv.put("update_time", info.update_time);
    123.             // 执行插入记录动作，该语句返回插入记录的行号
    124.             result = mDB.insert(TABLE_NAME, "", cv);
    125.             if (result == -1) { // 添加成功则返回行号，添加失败则返回-1
    126.                 return result;
    127.             }
    128.         }
    129.         return result;
    130.     }
    131.  
    132.     // 根据条件更新指定的表记录
    133.     public int update(CartInfo info, String condition) {
    134.         ContentValues cv = new ContentValues();
    135.         cv.put("goods_id", info.goods_id);
    136.         cv.put("count", info.count);
    137.         cv.put("update_time", info.update_time);
    138.         // 执行更新记录动作，该语句返回更新的记录数量
    139.         return mDB.update(TABLE_NAME, cv, condition, null);
    140.     }
    141.  
    142.     public int update(CartInfo info) {
    143.         // 执行更新记录动作，该语句返回更新的记录数量
    144.         return update(info, "rowid=" + info.rowid);
    145.     }
    146.  
    147.     public void save(long goods_id) {
    148.         CartInfo info = queryByGoodsId(goods_id);
    149.         if (info == null) { // 不存在该商品，则插入一条记录
    150.             info = new CartInfo();
    151.             info.goods_id = goods_id;
    152.             info.count = 1;
    153.             info.update_time = DateUtil.getNowDateTime("");
    154.             insert(info); // 往购物车数据库中添加一条新的商品记录
    155.         } else { // 已存在该商品，则更新原记录
    156.             info.count++; // 该商品的数量加一
    157.             info.update_time = DateUtil.getNowDateTime("");
    158.             update(info); // 更新购物车数据库中的商品记录信息
    159.         }
    160.     }
    161.  
    162.     // 根据指定条件查询记录，并返回结果数据列表
    163.     public List<CartInfo> query(String condition) {
    164.         String sql = String.format("select rowid,_id,goods_id,count,update_time" +
    165.                 " from %s where %s;", TABLE_NAME, condition);
    166.         Log.d(TAG, "query sql: " + sql);
    167.         List<CartInfo> infoList = new ArrayList<CartInfo>();
    168.         // 执行记录查询动作，该语句返回结果集的游标
    169.         Cursor cursor = mDB.rawQuery(sql, null);
    170.         // 循环取出游标指向的每条记录
    171.         while (cursor.moveToNext()) {
    172.             CartInfo info = new CartInfo();
    173.             info.rowid = cursor.getLong(0);
    174.             info.xuhao = cursor.getInt(1);
    175.             info.goods_id = cursor.getLong(2);
    176.             info.count = cursor.getInt(3);
    177.             info.update_time = cursor.getString(4);
    178.             infoList.add(info);
    179.         }
    180.         cursor.close(); // 查询完毕，关闭数据库游标
    181.         return infoList;
    182.     }
    183.  
    184.     // 根据行号查询指定记录
    185.     public CartInfo queryById(long rowid) {
    186.         CartInfo info = null;
    187.         List<CartInfo> infoList = query(String.format("rowid='%d'", rowid));
    188.         if (infoList.size() > 0) {
    189.             info = infoList.get(0);
    190.         }
    191.         return info;
    192.     }
    193.  
    194.     // 根据商品编号查询指定记录
    195.     public CartInfo queryByGoodsId(long goods_id) {
    196.         CartInfo info = null;
    197.         List<CartInfo> infoList = query(String.format("goods_id='%d'", goods_id));
    198.         if (infoList.size() > 0) {
    199.             info = infoList.get(0);
    200.         }
    201.         return info;
    202.     }
    203.  
    204.     public int queryCount() {
    205.         int count = 0;
    206.         String sql = String.format("select sum(count) from %s;", TABLE_NAME);
    207.         // 执行记录查询动作，该语句返回结果集的游标
    208.         Cursor cursor = mDB.rawQuery(sql, null);
    209.         // 循环取出游标指向的每条记录
    210.         while (cursor.moveToNext()) {
    211.             count = cursor.getInt(0);
    212.         }
    213.         Log.d(TAG, "count="+count);
    214.         return count;
    215.     }
    216.  
    217. }
    

    

    GoodsDBHelper

    

    1. package com.example.myapplication.database;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.content.ContentValues;
    5. import android.content.Context;
    6. import android.database.Cursor;
    7. import android.database.sqlite.SQLiteDatabase;
    8. import android.database.sqlite.SQLiteOpenHelper;
    9. import android.util.Log;
    10. import com.example.myapplication.bean.GoodsInfo;
    11. import java.util.ArrayList;
    12. import java.util.List;
    13.  
    14. @SuppressLint("DefaultLocale")
    15. public class GoodsDBHelper extends SQLiteOpenHelper {
    16.     private static final String TAG = "GoodsDBHelper";
    17.     private static final String DB_NAME = "goods.db"; // 数据库的名称
    18.     private static final int DB_VERSION = 1; // 数据库的版本号
    19.     private static GoodsDBHelper mHelper = null; // 数据库帮助器的实例
    20.     private SQLiteDatabase mDB = null; // 数据库的实例
    21.     private static final String TABLE_NAME = "goods_info"; // 表的名称
    22.  
    23.     private GoodsDBHelper(Context context) {
    24.         super(context, DB_NAME, null, DB_VERSION);
    25.     }
    26.  
    27.     private GoodsDBHelper(Context context, int version) {
    28.         super(context, DB_NAME, null, version);
    29.     }
    30.  
    31.     // 利用单例模式获取数据库帮助器的唯一实例
    32.     public static GoodsDBHelper getInstance(Context context, int version) {
    33.         if (version > 0 && mHelper == null) {
    34.             mHelper = new GoodsDBHelper(context, version);
    35.         } else if (mHelper == null) {
    36.             mHelper = new GoodsDBHelper(context);
    37.         }
    38.         return mHelper;
    39.     }
    40.  
    41.     // 打开数据库的读连接
    42.     public SQLiteDatabase openReadLink() {
    43.         if (mDB == null || !mDB.isOpen()) {
    44.             mDB = mHelper.getReadableDatabase();
    45.         }
    46.         return mDB;
    47.     }
    48.  
    49.     // 打开数据库的写连接
    50.     public SQLiteDatabase openWriteLink() {
    51.         if (mDB == null || !mDB.isOpen()) {
    52.             mDB = mHelper.getWritableDatabase();
    53.         }
    54.         return mDB;
    55.     }
    56.  
    57.     // 关闭数据库连接
    58.     public void closeLink() {
    59.         if (mDB != null && mDB.isOpen()) {
    60.             mDB.close();
    61.             mDB = null;
    62.         }
    63.     }
    64.  
    65.     // 创建数据库，执行建表语句
    66.     @Override
    67.     public void onCreate(SQLiteDatabase db) {
    68.         Log.d(TAG, "onCreate");
    69.         String drop_sql = "DROP TABLE IF EXISTS " + TABLE_NAME + ";";
    70.         Log.d(TAG, "drop_sql:" + drop_sql);
    71.         db.execSQL(drop_sql);
    72.         String create_sql = "CREATE TABLE IF NOT EXISTS " + TABLE_NAME + " ("
    73.                 + "_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,"
    74.                 + "name VARCHAR NOT NULL," + "desc VARCHAR NOT NULL,"
    75.                 + "price FLOAT NOT NULL," + "pic_path VARCHAR NOT NULL" + ");";
    76.         Log.d(TAG, "create_sql:" + create_sql);
    77.         db.execSQL(create_sql); // 执行完整的SQL语句
    78.     }
    79.  
    80.     // 修改数据库，执行表结构变更语句
    81.     @Override
    82.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    83.     }
    84.  
    85.     // 根据指定条件删除表记录
    86.     public int delete(String condition) {
    87.         // 执行删除记录动作，该语句返回删除记录的数目
    88.         return mDB.delete(TABLE_NAME, condition, null);
    89.     }
    90.  
    91.     // 删除该表的所有记录
    92.     public int deleteAll() {
    93.         // 执行删除记录动作，该语句返回删除记录的数目
    94.         return mDB.delete(TABLE_NAME, "1=1", null);
    95.     }
    96.  
    97.     // 往该表添加一条记录
    98.     public long insert(GoodsInfo info) {
    99.         List<GoodsInfo> infoList = new ArrayList<GoodsInfo>();
    100.         infoList.add(info);
    101.         return insert(infoList);
    102.     }
    103.  
    104.     // 往该表添加多条记录
    105.     public long insert(List<GoodsInfo> infoList) {
    106.         long result = -1;
    107.         for (GoodsInfo info : infoList) {
    108.             // 如果存在相同rowid的记录，则更新记录
    109.             if (info.rowid > 0) {
    110.                 String condition = String.format("rowid='%d'", info.rowid);
    111.                 update(info, condition);
    112.                 result = info.rowid;
    113.                 continue;
    114.             }
    115.             // 不存在唯一性重复的记录，则插入新记录
    116.             ContentValues cv = new ContentValues();
    117.             cv.put("name", info.name);
    118.             cv.put("desc", info.desc);
    119.             cv.put("price", info.price);
    120.             cv.put("pic_path", info.pic_path);
    121.             // 执行插入记录动作，该语句返回插入记录的行号
    122.             result = mDB.insert(TABLE_NAME, "", cv);
    123.             if (result == -1) { // 添加成功则返回行号，添加失败则返回-1
    124.                 return result;
    125.             }
    126.         }
    127.         return result;
    128.     }
    129.  
    130.     // 根据条件更新指定的表记录
    131.     public int update(GoodsInfo info, String condition) {
    132.         ContentValues cv = new ContentValues();
    133.         cv.put("name", info.name);
    134.         cv.put("desc", info.desc);
    135.         cv.put("price", info.price);
    136.         cv.put("pic_path", info.pic_path);
    137.         // 执行更新记录动作，该语句返回更新的记录数量
    138.         return mDB.update(TABLE_NAME, cv, condition, null);
    139.     }
    140.  
    141.     public int update(GoodsInfo info) {
    142.         // 执行更新记录动作，该语句返回更新的记录数量
    143.         return update(info, "rowid=" + info.rowid);
    144.     }
    145.  
    146.     // 根据指定条件查询记录，并返回结果数据列表
    147.     public List<GoodsInfo> query(String condition) {
    148.         String sql = String.format("select rowid,_id,name,desc,price,pic_path" +
    149.                 " from %s where %s;", TABLE_NAME, condition);
    150.         Log.d(TAG, "query sql: " + sql);
    151.         List<GoodsInfo> infoList = new ArrayList<GoodsInfo>();
    152.         // 执行记录查询动作，该语句返回结果集的游标
    153.         Cursor cursor = mDB.rawQuery(sql, null);
    154.         // 循环取出游标指向的每条记录
    155.         while (cursor.moveToNext()) {
    156.             GoodsInfo info = new GoodsInfo();
    157.             info.rowid = cursor.getLong(0);
    158.             info.xuhao = cursor.getInt(1);
    159.             info.name = cursor.getString(2);
    160.             info.desc = cursor.getString(3);
    161.             info.price = cursor.getFloat(4);
    162.             info.pic_path = cursor.getString(5);
    163.             infoList.add(info);
    164.         }
    165.         cursor.close(); // 查询完毕，关闭数据库游标
    166.         return infoList;
    167.     }
    168.  
    169.     // 根据行号查询指定记录
    170.     public GoodsInfo queryById(long rowid) {
    171.         GoodsInfo info = null;
    172.         List<GoodsInfo> infoList = query(String.format("rowid='%d'", rowid));
    173.         if (infoList.size() > 0) {
    174.             info = infoList.get(0);
    175.         }
    176.         return info;
    177.     }
    178.  
    179. }
    

    

    MainApplication

    

    1. package com.example.myapplication;
    2.  
    3. import android.app.Application;
    4. import android.util.Log;
    5. import androidx.room.Room;
    6. import com.example.myapplication.database.BookDatabase;
    7. import com.example.myapplication.database.CartDBHelper;
    8. import java.util.HashMap;
    9.  
    10. public class MainApplication extends Application
    11. {
    12.     private final static String TAG = "MainApplication";
    13.  
    14.     private static MainApplication mApp; // 声明一个当前应用的静态实例
    15.  
    16.     // 声明一个公共的信息映射对象，可当作全局变量使用
    17.     public HashMap<String, String> infoMap = new HashMap<String, String>();
    18.     public static int goodsCount = 0;
    19.  
    20.     private BookDatabase bookDatabase; // 声明一个书籍数据库对象
    21.  
    22.     // 利用单例模式获取当前应用的唯一实例
    23.     public static MainApplication getInstance()
    24.     {
    25.         return mApp;
    26.     }
    27.  
    28.     @Override
    29.     public void onCreate()
    30.     {
    31.         super.onCreate();
    32.         Log.d(TAG, "onCreate");
    33.  
    34.         mApp = this; // 在打开应用时对静态的应用实例赋值
    35.  
    36.         // 获取购物车数据库的帮助器对象
    37.         CartDBHelper cartHelper = CartDBHelper.getInstance(this, 1);
    38.         cartHelper.openReadLink(); // 打开购物车数据库的读连接
    39.         goodsCount = cartHelper.queryCount(); // 查询购物车里面的商品数量
    40.         cartHelper.closeLink(); // 关闭购物车数据库的读连接
    41.  
    42.  
    43.         // 构建书籍数据库的实例
    44.         bookDatabase = Room.databaseBuilder(mApp, BookDatabase.class,"BookInfo")
    45.                 .addMigrations() // 允许迁移数据库(发生数据库变更时，Room默认删除原数据库再创建新数据库。如此一来原来的记录会丢失，故而要改为迁移方式以便保存原有记录)
    46.                 .allowMainThreadQueries() // 允许在主线程中操作数据库(Room默认不能在主线程中操作数据库)
    47.                 .build();
    48.     }
    49.  
    50.  
    51.     // 获取书籍数据库的实例
    52.     public BookDatabase getBookDB()
    53.     {
    54.         return bookDatabase;
    55.     }
    56. }
    

    

    DateUtil

    1. package com.example.myapplication.util;
    2.  
    3. import android.annotation.SuppressLint;
    4. import android.text.TextUtils;
    5. import java.text.SimpleDateFormat;
    6. import java.util.Calendar;
    7. import java.util.Date;
    8.  
    9. @SuppressLint("SimpleDateFormat")
    10. public class DateUtil {
    11.     // 获取当前的日期时间
    12.     public static String getNowDateTime(String formatStr) {
    13.         String format = formatStr;
    14.         if (TextUtils.isEmpty(format)) {
    15.             format = "yyyyMMddHHmmss";
    16.         }
    17.         SimpleDateFormat sdf = new SimpleDateFormat(format);
    18.         return sdf.format(new Date());
    19.     }
    20.  
    21.     // 获取当前的时间
    22.     public static String getNowTime() {
    23.         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
    24.         return sdf.format(new Date());
    25.     }
    26.  
    27.     // 获取当前的时间(精确到毫秒)
    28.     public static String getNowTimeDetail() {
    29.         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
    30.         return sdf.format(new Date());
    31.     }
    32.  
    33. }
    

    

    FileUtil

    1. package com.example.myapplication.util;
    2.  
    3. import android.graphics.Bitmap;
    4. import android.graphics.BitmapFactory;
    5. import java.io.File;
    6. import java.io.FileInputStream;
    7. import java.io.FileOutputStream;
    8. import java.io.FilenameFilter;
    9. import java.util.ArrayList;
    10. import java.util.Collections;
    11. import java.util.Comparator;
    12. import java.util.List;
    13. import java.util.Locale;
    14.  
    15. public class FileUtil
    16. {
    17.  
    18.     // 把字符串保存到指定路径的文本文件
    19.     public static void saveText(String path, String txt) {
    20.         // 根据指定的文件路径构建文件输出流对象
    21.         try (FileOutputStream fos = new FileOutputStream(path)) {
    22.             fos.write(txt.getBytes()); // 把字符串写入文件输出流
    23.         } catch (Exception e) {
    24.             e.printStackTrace();
    25.         }
    26.     }
    27.  
    28.     // 从指定路径的文本文件中读取内容字符串
    29.     public static String openText(String path) {
    30.         String readStr = "";
    31.         // 根据指定的文件路径构建文件输入流对象
    32.         try (FileInputStream fis = new FileInputStream(path)) {
    33.             byte[] b = new byte[fis.available()];
    34.             fis.read(b); // 从文件输入流读取字节数组
    35.             readStr = new String(b); // 把字节数组转换为字符串
    36.         } catch (Exception e) {
    37.             e.printStackTrace();
    38.         }
    39.         return readStr; // 返回文本文件中的文本字符串
    40.     }
    41.  
    42.     // 把位图数据保存到指定路径的图片文件
    43.     public static void saveImage(String path, Bitmap bitmap) {
    44.         // 根据指定的文件路径构建文件输出流对象
    45.         try (FileOutputStream fos = new FileOutputStream(path)) {
    46.             // 把位图数据压缩到文件输出流中
    47.             bitmap.compress(Bitmap.CompressFormat.JPEG, 80, fos);
    48.         } catch (Exception e) {
    49.             e.printStackTrace();
    50.         }
    51.     }
    52.  
    53.     // 从指定路径的图片文件中读取位图数据
    54.     public static Bitmap openImage(String path) {
    55.         Bitmap bitmap = null; // 声明一个位图对象
    56.         // 根据指定的文件路径构建文件输入流对象
    57.         try (FileInputStream fis = new FileInputStream(path)) {
    58.             bitmap = BitmapFactory.decodeStream(fis); // 从文件输入流中解码位图数据
    59.         } catch (Exception e) {
    60.             e.printStackTrace();
    61.         }
    62.         return bitmap; // 返回图片文件中的位图数据
    63.     }
    64.  
    65.     public static List<File> getFileList(String path, String[] extendArray) {
    66.         List<File> displayedContent = new ArrayList<File>();
    67.         File[] files = null;
    68.         File directory = new File(path);
    69.         if (extendArray != null && extendArray.length > 0) {
    70.             FilenameFilter fileFilter = getTypeFilter(extendArray);
    71.             files = directory.listFiles(fileFilter);
    72.         } else {
    73.             files = directory.listFiles();
    74.         }
    75.  
    76.         if (files != null) {
    77.             for (File f : files) {
    78.                 if (!f.isDirectory() && !f.isHidden()) {
    79.                     displayedContent.add(f);
    80.                 }
    81.             }
    82.         }
    83.         // 按照最后修改时间排序
    84.         Collections.sort(displayedContent, new Comparator<File>() {
    85.             @Override
    86.             public int compare(File o1, File o2) {
    87.                 return (o1.lastModified() > o2.lastModified()) ? -1 : 1;
    88.             }
    89.         });
    90.         return displayedContent;
    91.     }
    92.  
    93.     public static FilenameFilter getTypeFilter(String[] extendArray) {
    94.         final ArrayList<String> fileExtensions = new ArrayList<String>();
    95.         for (int i = 0; i < extendArray.length; i++) {
    96.             fileExtensions.add(extendArray[i]);
    97.         }
    98.         FilenameFilter fileNameFilter = new FilenameFilter() {
    99.             @Override
    100.             public boolean accept(File directory, String fileName) {
    101.                 boolean matched = false;
    102.                 File f = new File(String.format("%s/%s",
    103.                         directory.getAbsolutePath(), fileName));
    104.                 matched = f.isDirectory();
    105.                 if (!matched) {
    106.                     for (String s : fileExtensions) {
    107.                         s = String.format(".{0,}\\%s$", s);
    108.                         s = s.toUpperCase(Locale.getDefault());
    109.                         fileName = fileName.toUpperCase(Locale.getDefault());
    110.                         matched = fileName.matches(s);
    111.                         if (matched) {
    112.                             break;
    113.                         }
    114.                     }
    115.                 }
    116.                 return matched;
    117.             }
    118.         };
    119.         return fileNameFilter;
    120.     }
    121.  
    122. }
    

    SharedUtil

    1. package com.example.myapplication.util;
    2.  
    3. import android.content.Context;
    4. import android.content.SharedPreferences;
    5.  
    6. // 这是共享参数的工具类，统一对共享参数的读写操作
    7. public class SharedUtil {
    8.     private static SharedUtil mUtil; // 声明一个共享参数工具类的实例
    9.     private static SharedPreferences mShared; // 声明一个共享参数的实例
    10.  
    11.     // 通过单例模式获取共享参数工具类的唯一实例
    12.     public static SharedUtil getIntance(Context ctx) {
    13.         if (mUtil == null) {
    14.             mUtil = new SharedUtil();
    15.         }
    16.         // 从cart.xml中获取共享参数对象
    17.         mShared = ctx.getSharedPreferences("cart", Context.MODE_PRIVATE);
    18.         return mUtil;
    19.     }
    20.  
    21.     // 把键名与字符串的配对信息写入共享参数
    22.     public void writeString(String key, String value) {
    23.         SharedPreferences.Editor editor = mShared.edit(); // 获得编辑器的对象
    24.         editor.putString(key, value); // 添加一个指定键名的字符串参数
    25.         editor.commit(); // 提交编辑器中的修改
    26.     }
    27.  
    28.     // 根据键名到共享参数中查找对应的字符串对象
    29.     public String readString(String key, String defaultValue) {
    30.         return mShared.getString(key, defaultValue);
    31.     }
    32.  
    33.     // 把键名与整型数的配对信息写入共享参数
    34.     public void writeInt(String key, int value) {
    35.         SharedPreferences.Editor editor = mShared.edit(); // 获得编辑器的对象
    36.         editor.putInt(key, value); // 添加一个指定键名的整型数参数
    37.         editor.commit(); // 提交编辑器中的修改
    38.     }
    39.  
    40.     // 根据键名到共享参数中查找对应的整型数对象
    41.     public int readInt(String key, int defaultValue) {
    42.         return mShared.getInt(key, defaultValue);
    43.     }
    44.  
    45.  
    46. }
    

    ToastUtil

    1. package com.example.myapplication.util;
    2.  
    3. import android.content.Context;
    4. import android.widget.Toast;
    5.  
    6. public class ToastUtil {
    7.  
    8.     public static void show(Context ctx, String desc) {
    9.         Toast.makeText(ctx, desc, Toast.LENGTH_SHORT).show();
    10.     }
    11. }
    

    Utils

    1. package com.example.myapplication.util;
    2.  
    3. import android.content.Context;
    4.  
    5. public class Utils {
    6.     // 根据手机的分辨率从 dp 的单位 转成为 px(像素)
    7.     public static int dip2px(Context context, float dpValue) {
    8.         // 获取当前手机的像素密度(1个dp对应几个px)
    9.         float scale = context.getResources().getDisplayMetrics().density;
    10.         return (int) (dpValue * scale + 0.5f); // 四舍五入取整
    11.     }
    12.  
    13.     // 根据手机的分辨率从 px(像素) 的单位 转成为 dp
    14.     public static int px2dip(Context context, float pxValue) {
    15.         // 获取当前手机的像素密度(1个dp对应几个px)
    16.         float scale = context.getResources().getDisplayMetrics().density;
    17.         return (int) (pxValue / scale + 0.5f); // 四舍五入取整
    18.     }
    19.  
    20.     // 获得屏幕的宽度
    21.     public static int getScreenWidth(Context ctx) {
    22.         return ctx.getResources().getDisplayMetrics().widthPixels;
    23. //        int screenWidth;
    24. //        // 从系统服务中获取窗口管理器
    25. //        WindowManager wm = (WindowManager) ctx.getSystemService(Context.WINDOW_SERVICE);
    26. //        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
    27. //            // 获取当前屏幕的四周边界
    28. //            Rect rect = wm.getCurrentWindowMetrics().getBounds();
    29. //            screenWidth = rect.width();
    30. //        } else {
    31. //            DisplayMetrics dm = new DisplayMetrics();
    32. //            // 从默认显示器中获取显示参数保存到dm对象中
    33. //            wm.getDefaultDisplay().getMetrics(dm);
    34. //            screenWidth = dm.widthPixels;
    35. //        }
    36. //        return screenWidth; // 返回屏幕的宽度数值
    37.     }
    38.  
    39.     // 获得屏幕的高度
    40.     public static int getScreenHeight(Context ctx) {
    41.         return ctx.getResources().getDisplayMetrics().heightPixels;
    42. //        int screenHeight;
    43. //        // 从系统服务中获取窗口管理器
    44. //        WindowManager wm = (WindowManager) ctx.getSystemService(Context.WINDOW_SERVICE);
    45. //        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
    46. //            // 获取当前屏幕的四周边界
    47. //            Rect rect = wm.getCurrentWindowMetrics().getBounds();
    48. //            screenHeight = rect.height();
    49. //        } else {
    50. //            DisplayMetrics dm = new DisplayMetrics();
    51. //            // 从默认显示器中获取显示参数保存到dm对象中
    52. //            wm.getDefaultDisplay().getMetrics(dm);
    53. //            screenHeight = dm.heightPixels;
    54. //        }
    55. //        return screenHeight; // 返回屏幕的高度数值
    56.     }
    57. }
    

    ViewUtil

    1. package com.example.myapplication.util;
    2.  
    3. import android.app.Activity;
    4. import android.content.Context;
    5. import android.view.View;
    6. import android.view.inputmethod.InputMethodManager;
    7.  
    8. public class ViewUtil {
    9.  
    10.     public static void hideAllInputMethod(Activity act) {
    11.         // 从系统服务中获取输入法管理器
    12.         InputMethodManager imm = (InputMethodManager) act.getSystemService(Context.INPUT_METHOD_SERVICE);
    13.         if (imm.isActive()) { // 软键盘如果已经打开则关闭之
    14.             imm.toggleSoftInput(0, InputMethodManager.HIDE_NOT_ALWAYS);
    15.         }
    16.     }
    17.  
    18.     public static void hideOneInputMethod(Activity act, View v) {
    19.         // 从系统服务中获取输入法管理器
    20.         InputMethodManager imm = (InputMethodManager) act.getSystemService(Context.INPUT_METHOD_SERVICE);
    21.         // 关闭屏幕上的输入法软键盘
    22.         imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
    23.     }
    24.  
    25. }

    第一个页面：   ShoppingCartActivity

    点击：逛逛手机商场

     

    点击清空：

    =======================================================================================================================

     

     

     

     

     

     

     

     

     

     

     

     

     

     

  • 相关阅读:
    Java ElasticSearch-Linux面试题
    复盘：什么是秋招提前批？什么是普通秋招？都是招聘，为啥要设置这两个招聘时间段
    ps2024滤镜插件Portraiture
    海藻酸钠-聚乙二醇-反式环辛烯|TCO-PEG-alginate|海藻酸钠-聚乙二醇-PEG-TCO
    CSS和JavaScript的引用方式
    Python文件操作：操作文件的1个函数3个方法使用、readline按行读取文件、文件指针（详细图文）
    Hadoop面试题（HDFS篇）
    Oracle Error FRM-40203: Field must be entered completely
    SpringBoot过滤器和拦截器
    notepad++配置python2环境
  • 原文地址：https://blog.csdn.net/m0_61442607/article/details/126446815