利用PorterDuff.Mode做橡皮擦效果

最新推荐文章于 2021-11-25 10:34:32 发布
最新推荐文章于 2021-11-25 10:34:32 发布
阅读量1k 收藏 1
点赞数

http://stackoverflow.com/questions/3467334/erase-bitmap-parts-using-porterduff-mode 
假如我有一张背景图片， 
在背景图片上覆盖绘制了一层半透明的绿色 
当我们用手指涂抹屏幕的时候，手指涂抹过的地方绿色就被擦除，露出下面原先被遮挡住的背景图片 
1.利用canvas的drawPath做擦除效果。 
效果如下： 

 

实现代码: 
Java代码   收藏代码
  1. import android.app.Activity;  
  2. import android.content.Context;  
  3. import android.graphics.Bitmap;  
  4. import android.graphics.BitmapFactory;  
  5. import android.graphics.Canvas;  
  6. import android.graphics.Paint;  
  7. import android.graphics.Path;  
  8. import android.graphics.PorterDuff;  
  9. import android.graphics.PorterDuffXfermode;  
  10. import android.graphics.Bitmap.Config;  
  11. import android.os.Bundle;  
  12. import android.util.DisplayMetrics;  
  13. import android.view.MotionEvent;  
  14. import android.view.View;  
  15.   
  16. public class Eraser_Use_drawPath extends Activity {  
  17.   
  18.     private int SCREEN_W;  
  19.   
  20.     private int SCREEN_H;  
  21.   
  22.     @Override  
  23.     protected void onCreate(Bundle savedInstanceState) {  
  24.         super.onCreate(savedInstanceState);  
  25.         setContentView(new MyView(this));  
  26.   
  27.     }  
  28.   
  29.     class MyView extends View {  
  30.         private Bitmap mBitmap;  
  31.         private Canvas mCanvas;  
  32.         private Paint mPaint;  
  33.         private Path  mPath;  
  34.         private float mX, mY;  
  35.         private static final float TOUCH_TOLERANCE = 4;  
  36.           
  37.         public MyView(Context context) {  
  38.             super(context);  
  39.             setFocusable(true);  
  40.             setScreenWH();  
  41.             setBackGround();  
  42.               
  43.             // 1.if cover is a image,you can open MENU_ITEM_COMMENT bellow  
  44.             //Bitmap bm = createBitmapFromSRC();  
  45.             // if you want to set cover image's alpha,you can open MENU_ITEM_COMMENT bellow  
  46.             //bm = setBitmapAlpha(bm, 100);  
  47.             // if you want to scale cover image,you can open MENU_ITEM_COMMENT bellow  
  48.             //bm = scaleBitmapFillScreen(bm);  
  49.   
  50.             // 2.if cover is color  
  51.             Bitmap bm = createBitmapFromARGB(0x8800ff00, SCREEN_W, SCREEN_H);  
  52.             setCoverBitmap(bm);  
  53.   
  54.         }  
  55.   
  56.         private void setScreenWH() {  
  57.             // get screen info  
  58.             DisplayMetrics dm = new DisplayMetrics();  
  59.             dm = this.getResources().getDisplayMetrics();  
  60.             // get screen width  
  61.             int screenWidth = dm.widthPixels;  
  62.             // get screen height  
  63.             int screenHeight = dm.heightPixels;  
  64.   
  65.             SCREEN_W = screenWidth;  
  66.             SCREEN_H = screenHeight;  
  67.         }  
  68.   
  69.         private Bitmap createBitmapFromSRC() {  
  70.             return BitmapFactory.decodeResource(getResources(),  
  71.                                                 R.drawable.cover);  
  72.         }  
  73.   
  74.         /** 
  75.          *  
  76.          * @param colorARGB should like 0x8800ff00 
  77.          * @param width 
  78.          * @param height 
  79.          * @return 
  80.          */  
  81.         private Bitmap createBitmapFromARGB(int colorARGB, int width, int height) {  
  82.             int[] argb = new int[width * height];  
  83.   
  84.             for (int i = 0; i < argb.length; i++) {  
  85.   
  86.                 argb[i] = colorARGB;  
  87.   
  88.             }  
  89.             return Bitmap.createBitmap(argb, width, height, Config.ARGB_8888);  
  90.         }  
  91.   
  92.         /** 
  93.          *  
  94.          * @param bm 
  95.          * @param alpha ,and alpha should be like ox00000000-oxff000000 
  96.          * @note set bitmap's alpha 
  97.          * @return 
  98.          */  
  99.        /* private Bitmap setBitmapAlpha(Bitmap bm, int alpha) { 
  100.             int[] argb = new int[bm.getWidth() * bm.getHeight()]; 
  101.             bm.getPixels(argb, 0, bm.getWidth(), 0, 0, bm.getWidth(), bm 
  102.                     .getHeight()); 
  103.  
  104.  
  105.             for (int i = 0; i < argb.length; i++) { 
  106.  
  107.                 argb[i] = ((alpha) | (argb[i] & 0x00FFFFFF)); 
  108.             } 
  109.             return Bitmap.createBitmap(argb, bm.getWidth(), bm.getHeight(), 
  110.                                        Config.ARGB_8888); 
  111.         }*/  
  112.           
  113.         /** 
  114.          *  
  115.          * @param bm 
  116.          * @param alpha ,alpha should be between 0 and 255 
  117.          * @note set bitmap's alpha 
  118.          * @return 
  119.          */  
  120.         private Bitmap setBitmapAlpha(Bitmap bm, int alpha) {  
  121.             int[] argb = new int[bm.getWidth() * bm.getHeight()];  
  122.             bm.getPixels(argb, 0, bm.getWidth(), 0, 0, bm.getWidth(), bm  
  123.                     .getHeight());  
  124.   
  125.             for (int i = 0; i < argb.length; i++) {  
  126.   
  127.                 argb[i] = ((alpha << 24) | (argb[i] & 0x00FFFFFF));  
  128.             }  
  129.             return Bitmap.createBitmap(argb, bm.getWidth(), bm.getHeight(),  
  130.                                        Config.ARGB_8888);  
  131.         }  
  132.           
  133.         /** 
  134.          *  
  135.          * @param bm 
  136.          * @note if bitmap is smaller than screen, you can scale it fill the screen. 
  137.          * @return  
  138.          */  
  139.         private Bitmap scaleBitmapFillScreen(Bitmap bm) {  
  140.             return Bitmap.createScaledBitmap(bm, SCREEN_W, SCREEN_H, true);  
  141.         }  
  142.   
  143.           
  144.         private void setBackGround() {  
  145.             setBackgroundResource(R.drawable.background);  
  146.         }  
  147.   
  148.         /** 
  149.          *  
  150.          * @param bm 
  151.          * @note set cover bitmap , which  overlay on background.  
  152.          */  
  153.         private void setCoverBitmap(Bitmap bm) {  
  154.             // setting paint  
  155.             mPaint = new Paint();  
  156.             mPaint.setAlpha(0);  
  157.             mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));  
  158.             mPaint.setAntiAlias(true);  
  159.               
  160.             mPaint.setDither(true);  
  161.             mPaint.setStyle(Paint.Style.STROKE);  
  162.             mPaint.setStrokeJoin(Paint.Join.ROUND);  
  163.             mPaint.setStrokeCap(Paint.Cap.ROUND);  
  164.             mPaint.setStrokeWidth(20);  
  165.               
  166.             //set path  
  167.             mPath =  new Path();;  
  168.   
  169.             // converting bitmap into mutable bitmap  
  170.             mBitmap = Bitmap.createBitmap(SCREEN_W, SCREEN_H, Config.ARGB_8888);  
  171.             mCanvas = new Canvas();  
  172.             mCanvas.setBitmap(mBitmap);  
  173.             // drawXY will result on that Bitmap  
  174.             // be sure parameter is bm, not mBitmap  
  175.             mCanvas.drawBitmap(bm, 0, 0, null);  
  176.         }  
  177.   
  178.          
  179.   
  180.         @Override  
  181.         protected void onDraw(Canvas canvas) {  
  182.             canvas.drawBitmap(mBitmap, 0, 0, null);  
  183.             mCanvas.drawPath(mPath, mPaint);  
  184.             super.onDraw(canvas);  
  185.         }  
  186.           
  187.         private void touch_start(float x, float y) {  
  188.             mPath.reset();  
  189.             mPath.moveTo(x, y);  
  190.             mX = x;  
  191.             mY = y;  
  192.         }  
  193.         private void touch_move(float x, float y) {  
  194.             float dx = Math.abs(x - mX);  
  195.             float dy = Math.abs(y - mY);  
  196.             if (dx >= TOUCH_TOLERANCE || dy >= TOUCH_TOLERANCE) {  
  197.                 mPath.quadTo(mX, mY, (x + mX)/2, (y + mY)/2);  
  198.                 mX = x;  
  199.                 mY = y;  
  200.             }  
  201.         }  
  202.         private void touch_up() {  
  203.             mPath.lineTo(mX, mY);  
  204.             // commit the path to our offscreen  
  205.             mCanvas.drawPath(mPath, mPaint);  
  206.             // kill this so we don't double draw  
  207.             mPath.reset();  
  208.         }  
  209.           
  210.         @Override  
  211.         public boolean onTouchEvent(MotionEvent event) {  
  212.             float x = event.getX();  
  213.             float y = event.getY();  
  214.               
  215.             switch (event.getAction()) {  
  216.                 case MotionEvent.ACTION_DOWN:  
  217.                     touch_start(x, y);  
  218.                     invalidate();  
  219.                     break;  
  220.                 case MotionEvent.ACTION_MOVE:  
  221.                     touch_move(x, y);  
  222.                     invalidate();  
  223.                     break;  
  224.                 case MotionEvent.ACTION_UP:  
  225.                     touch_up();  
  226.                     invalidate();  
  227.                     break;  
  228.             }  
  229.             return true;  
  230.         }  
  231.     }  
  232. }  


2.利用canvas的drawCircle做擦除效果 
效果如下： 

 

实现代码： 
Java代码   收藏代码
  1. package aliusa.cn;  
  2.   
  3. import android.app.Activity;  
  4. import android.content.Context;  
  5. import android.graphics.Bitmap;  
  6. import android.graphics.BitmapFactory;  
  7. import android.graphics.Canvas;  
  8. import android.graphics.Paint;  
  9. import android.graphics.PorterDuff;  
  10. import android.graphics.PorterDuffXfermode;  
  11. import android.graphics.Bitmap.Config;  
  12. import android.os.Bundle;  
  13. import android.util.DisplayMetrics;  
  14. import android.view.MotionEvent;  
  15. import android.view.View;  
  16.   
  17. public class Eraser_Use_drawCircle extends Activity {  
  18.   
  19.     private int SCREEN_W;  
  20.   
  21.     private int SCREEN_H;  
  22.   
  23.     @Override  
  24.     protected void onCreate(Bundle savedInstanceState) {  
  25.         super.onCreate(savedInstanceState);  
  26.         setContentView(new MyView(this));  
  27.   
  28.     }  
  29.   
  30.     class MyView extends View {  
  31.         private Bitmap mBitmap;  
  32.         private Canvas mCanvas;  
  33.         private Paint mPaint;  
  34.         int x = 0;  
  35.   
  36.         int y = 0;  
  37.   
  38.         int r = 0;  
  39.           
  40.         public MyView(Context context) {  
  41.             super(context);  
  42.             setFocusable(true);  
  43.             setScreenWH();  
  44.             setBackGround();  
  45.               
  46.             // 1.if cover is a image,you can open MENU_ITEM_COMMENT bellow  
  47.             Bitmap bm = createBitmapFromSRC();  
  48.             // if you want to set cover image's alpha,you can open MENU_ITEM_COMMENT bellow  
  49.             bm = setBitmapAlpha(bm, 100);  
  50.             // if you want to scale cover image,you can open MENU_ITEM_COMMENT bellow  
  51.             bm = scaleBitmapFillScreen(bm);  
  52.   
  53.             // 2.if cover is color  
  54.             //Bitmap bm = createBitmapFromARGB(0x8800ff00, SCREEN_W, SCREEN_H);  
  55.             setCoverBitmap(bm);  
  56.   
  57.         }  
  58.   
  59.         private void setScreenWH() {  
  60.             // get screen info  
  61.             DisplayMetrics dm = new DisplayMetrics();  
  62.             dm = this.getResources().getDisplayMetrics();  
  63.             // get screen width  
  64.             int screenWidth = dm.widthPixels;  
  65.             // get screen height  
  66.             int screenHeight = dm.heightPixels;  
  67.   
  68.             SCREEN_W = screenWidth;  
  69.             SCREEN_H = screenHeight;  
  70.         }  
  71.   
  72.         private Bitmap createBitmapFromSRC() {  
  73.             return BitmapFactory.decodeResource(getResources(),  
  74.                                                 R.drawable.cover);  
  75.         }  
  76.   
  77.         /** 
  78.          *  
  79.          * @param colorARGB should like 0x8800ff00 
  80.          * @param width 
  81.          * @param height 
  82.          * @return 
  83.          */  
  84.         private Bitmap createBitmapFromARGB(int colorARGB, int width, int height) {  
  85.             int[] argb = new int[width * height];  
  86.   
  87.             for (int i = 0; i < argb.length; i++) {  
  88.   
  89.                 argb[i] = colorARGB;  
  90.   
  91.             }  
  92.             return Bitmap.createBitmap(argb, width, height, Config.ARGB_8888);  
  93.         }  
  94.   
  95.         /** 
  96.          *  
  97.          * @param bm 
  98.          * @param alpha ,and alpha should be like ox00000000-oxff000000 
  99.          * @note set bitmap's alpha 
  100.          * @return 
  101.          */  
  102.        /* private Bitmap setBitmapAlpha(Bitmap bm, int alpha) { 
  103.             int[] argb = new int[bm.getWidth() * bm.getHeight()]; 
  104.             bm.getPixels(argb, 0, bm.getWidth(), 0, 0, bm.getWidth(), bm 
  105.                     .getHeight()); 
  106.  
  107.  
  108.             for (int i = 0; i < argb.length; i++) { 
  109.  
  110.                 argb[i] = ((alpha) | (argb[i] & 0x00FFFFFF)); 
  111.             } 
  112.             return Bitmap.createBitmap(argb, bm.getWidth(), bm.getHeight(), 
  113.                                        Config.ARGB_8888); 
  114.         }*/  
  115.           
  116.         /** 
  117.          *  
  118.          * @param bm 
  119.          * @param alpha ,alpha should be between 0 and 255 
  120.          * @note set bitmap's alpha 
  121.          * @return 
  122.          */  
  123.         private Bitmap setBitmapAlpha(Bitmap bm, int alpha) {  
  124.             int[] argb = new int[bm.getWidth() * bm.getHeight()];  
  125.             bm.getPixels(argb, 0, bm.getWidth(), 0, 0, bm.getWidth(), bm  
  126.                     .getHeight());  
  127.   
  128.             for (int i = 0; i < argb.length; i++) {  
  129.   
  130.                 argb[i] = ((alpha << 24) | (argb[i] & 0x00FFFFFF));  
  131.             }  
  132.             return Bitmap.createBitmap(argb, bm.getWidth(), bm.getHeight(),  
  133.                                        Config.ARGB_8888);  
  134.         }  
  135.           
  136.         /** 
  137.          *  
  138.          * @param bm 
  139.          * @note if bitmap is smaller than screen, you can scale it fill the screen. 
  140.          * @return  
  141.          */  
  142.         private Bitmap scaleBitmapFillScreen(Bitmap bm) {  
  143.             return Bitmap.createScaledBitmap(bm, SCREEN_W, SCREEN_H, true);  
  144.         }  
  145.   
  146.           
  147.         private void setBackGround() {  
  148.             setBackgroundResource(R.drawable.background);  
  149.         }  
  150.   
  151.         /** 
  152.          *  
  153.          * @param bm 
  154.          * @note set cover bitmap , which  overlay on background.  
  155.          */  
  156.         private void setCoverBitmap(Bitmap bm) {  
  157.             // setting paint  
  158.             mPaint = new Paint();  
  159.             mPaint.setAlpha(0);  
  160.             mPaint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN));  
  161.             mPaint.setAntiAlias(true);  
  162.   
  163.             // converting bitmap into mutable bitmap  
  164.             mBitmap = Bitmap.createBitmap(SCREEN_W, SCREEN_H, Config.ARGB_8888);  
  165.             mCanvas = new Canvas();  
  166.             mCanvas.setBitmap(mBitmap);  
  167.             // drawXY will result on that Bitmap  
  168.             // be sure parameter is bm, not mBitmap  
  169.             mCanvas.drawBitmap(bm, 0, 0, null);  
  170.         }  
  171.   
  172.          
  173.   
  174.         @Override  
  175.         protected void onDraw(Canvas canvas) {  
  176.          // draw a circle that is erasing bitmap  
  177.             mCanvas.drawCircle(x, y, r, mPaint);  
  178.             canvas.drawBitmap(mBitmap, 0, 0, null);  
  179.             super.onDraw(canvas);  
  180.         }  
  181.           
  182.         @Override  
  183.         public boolean onTouchEvent(MotionEvent event) {  
  184.             // set parameter to draw circle on touch event  
  185.             x = (int) event.getX();  
  186.             y = (int) event.getY();  
  187.             r = 20;  
  188.             // Atlast invalidate canvas  
  189.             invalidate();  
  190.             return true;  
  191.         }  
  192.     }  

vasal
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android 使用 PorterDuff.Mode.XOR 自定义遮罩
05-30
遮罩视图
自定义控件（6）---PorterDuffXfermode图形过滤器之橡皮擦应用
全干工程师
11-09 800
activity_main.xml <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
Android画板开发(二) 橡皮擦实现
KeepStudy
10-31 8913
在上一篇实现了简单的画板功能， 这篇实现橡皮擦功能，首先分析一下应该如何实现，在Andriod有个图像混合（Xfermode）概念，利用这个概念我们就可以实现橡皮擦功能。一、XfermodePaint有一个方法setXfermode(Xfermode)，这个方法设置图像的混合模式。参数有三个子类： AvoidXfermode PixelXorXfermode PorterDuffXfermode 前
android 画板之橡皮擦功能开发
08-12 389
记录一下橡皮擦功能开发。 讲一下原理： 橡皮擦功能要用到Paint类的一个属性： paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.DST_IN)); 这句代码的意思是： 只在源图像和目标图像相交的地方绘制目标图像 不懂没关系，首先用一个paint来绘制线条，然后用另一个paint作为橡皮擦并设置上句代码的属性，...
Android 橡皮擦功能，图层混合模式PorterDuff.Mode实践
u013624014的博客
11-25 1738
先上效果图： 使用图层混合模式注意点： 1.图层类型设置为软件类型，有些api不支持硬件类型，默认视图是没有开启图层的 setLayerType(LAYER_TYPE_SOFTWARE, null); 2.创建新的图层来完成混合模式的运算(离屏绘制)，然后更新到原始图层。如果直接在原始图层进行混合模式运算，原始图层的某些操作可能会影响混合模式运算结果，得不到预期的效果 //离屏绘制 int layer = canvas.saveLayer(0, 0, width, height, pa..
Android实现素材擦除功能
梦翼-的博客
04-29 1040
一、背景如果有这样一个需求，需要擦除的是素材而保留背景图片，并且保存的时候能将背景图片和素材重新绘制到一起生成一张新的图片，这张图片大小比例就和原图一样，只不过上面多了素材。之前在网上找过橡皮檫的实现，大多数是以整张view作为画板，但是这个需求情况下就不能使用整张view作为画板了，不然保存的时候还要裁剪出素材，一不小心还把素材大小什么的搞乱了，这时候就需要另一种办法了 二、实现先重写view的...
android画布橡皮,Android 橡皮擦功能的实现
weixin_36212334的博客
05-25 1164
Android中要实现橡皮擦，可利用Canvas以于paint的属性设置来实现，我们都知道paint中有一条属性:setAlpha(0),我们将其设置为0，那画上的是透明的笔划。记我们的笔划为src，要擦除的图像为dst，那么两者重合后的效果可得用xfermode来设置，我们都知道PorterDuffXfermode这是一个非常强大的转换模式，使用它，可以使用图像合成的16条Porter-Duf...
画布上涂鸦功能（可橡皮擦、可清除）
weixin_34117211的博客
12-28 491
2019独角兽企业重金招聘Python工程师标准>>> ...
Xfermode16-PorterDuff及Xfermode.rar
02-19
PorterDuff及Xfermode 贝塞尔曲线
android自定义View扫描人脸效果
08-04
本文利用SrcIn实现一个人脸扫描的效果，步骤如下： 1、准备两个人脸照片（一明一暗），暗照片作为背景，亮照片作为src前景显示 2、然后通过SrcIn用一个透明矩形框(Dst)与亮照片（src）取交集即可得出一个亮照片的...
Android ShimmerLayout实现微光效果解析
01-20
这里我们采用的是PorterDuff.MODE.SRC_IN，意思是在绘制的时候，显示上下图层相交的部分，且这部分显示上层图层。 1） 首先我们需要绘制出最上层的微光，这里通过LinearGradient线性渐变渲染器来绘制微光渐变效果，...
Android自定义View实现水面上涨效果
01-20
1、如何实现圆中水面上涨效果：利用Paint的setXfermode属性为PorterDuff.Mode.SRC_IN画出进度所在的矩形与圆的交集实现 2、如何水波纹效果：利用贝塞尔曲线，动态改变波峰值，实现“随着进度的增加，水波纹逐渐变小...
node-v9.6.0-x86.msi
04-29
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
Python基于机器学习的分布式系统故障诊断系统源代码，分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别
04-29
基于技术手段（包括但不限于机器学习、深度学习等技术）对分布式系统的故障数据进行分析，设计故障诊断模型，高效地分析并识别故障类别，实现分布式系统故障运维的智能化，快速恢复故障的同时大大降低分布式系统运维工作的难度，减少运维对人力资源的消耗。在分布式系统中某个节点发生故障时，故障会沿着分布式系统的拓扑结构进行传播，造成自身节点及其邻接节点相关的KPI指标和发生大量日志异常
JavaScript前端开发的核心语言前端开发的核心语言
最新发布
04-29
javascript 当今互联网时代，JavaScript已经成为了前端开发的核心语言它是一种高级程序设计语言，通常用于网页的交互和动态效果的实现。JavaScript的灵活性以及广泛的使用使得它变得异常重要，能够为用户带来更好的用户体验。 JavaScript的特点之一是它的轻量级，它可以在网页中运行无需单独的编译或下载。这意味着网页可以更快地加载并且用户无需安装额外的软件才能运行网页上的JavaScript代码。此外，与HTML和CSS紧密结合，可以直接在HTML文档中嵌入，使得网页的开发变得非常便捷。 JavaScript具有动态性，它可以在浏览器中实时修改页面内容和样。它可以通过操作DOM（文档对象模型来动态地修改网页的结构和布局，并且可以根据用户的行为实时地响应各种事件，如点击、标悬停、滚动等。这使得开发者可以轻松地为网页添加交互性和动态效果，提供更好的用户体验。 JavaScript也是一种面向对象的语言。它支持对象、类、继承、多态等面向对象编程的概念，使得代码结构更加清晰和可维护。开发者可以创建自定义的对象和方法，对功能进行封装和复用，提高代码的可读性和可维护性。
四则运算自动生成程序安装包
04-29
四则运算自动生成程序安装包
基于Linux的私有文件服务器(网盘).zip
04-29
基于Linux的私有文件服务器(网盘)
源代码-access 管理 系统 API 文件.zip
04-29
源代码-access 管理 系统 API 文件.zip
Drawable upArrow = ContextCompat.getDrawable(this, R.drawable.abc_ic_ab_back_material); upArrow.setColorFilter(getResources().getColor(R.color.white), PorterDuff.Mode.SRC_ATOP); mToolbar.setNavigationIcon(upArrow);
06-01
接着，通过upArrow.setColorFilter()方法将该图标的颜色进行修改，使其变为白色，第一个参数是资源文件中定义的颜色值，第二个参数是PorterDuff.Mode枚举值，用于指定颜色过滤器的模式。最后，通过调用mToolbar对象...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值