android.graphics包-核心渲染包(绘图)

android.graphics包是核心渲染包，它提供了一些初级图形工具，诸如画布、颜色过滤器、画笔等，可以让你直接在屏幕上进行图像处理。这个包中提供了很多类，下面我们就看一下这个包中主要的几个类。

一、Canvas类android.graphics.Canvas

Canvas类好比手机中的画纸，我们可以在Canvas上画图形或者图像。一般我们用android来绘画的时候，需要四个组成部分：

1、位图：包含像素

2、Canvas画板：包含绘画内容，写入位图

3、初始图形：如Rect、Bitmap、text等

4、Paint：用来描述上面初始图形的颜色和类型等

Canvas类提供了三个构造方法：

Public Canvas（）；构造一个默认无参的Canvas对象

Public Canvas（Bitmap bitmap）；根据一个Bitmap构造一个Canvas对象

Public Canvas（GL gl）；根据一个GL来构造一个对象

下面我们来了解一下Canvas类提供的方法：

在Canvas类提供的方法中比较多经常用的是以draw开头的方法，draw开头的方法很容易理解就是向画板中画图形，比如可以向Canvas中画位图，给图形填充颜色等。

比如方法：

drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter, Paint paint)画弧形

drawCircle(float cx, float cy, float radius, Paint paint)画圆形

Canvas类提供的方法比较多，在此我们不一一赘述，在后面的内容中，我将给大家举几个实际的应用程序例子来演示Canvas类的使用方法。

 

二、Paint类android.graphics.Paint

Paint类包含有用来画几何图形、文本、位图的类型和颜色等信息，如果把Canvas类看作是画板，那我们可以把Paint类看做是画笔，可以根据需要画出不同颜色和样式的图形、文本等内容。

Paint类有三个构造方法：

Public Paint()构造一个缺省的Paint对象

Public  Paint(int flags);根据指定的flags来构造一个Paint对象，创建之后可以用

setFlags（）方法来更改

Public Paint(Paint paint)根据指定的paint对象来构造一个Paint对象

Paint类提供了很多方法来设置和获取Paint对象的属性，比如：

public int getColor ()获得Paint对象的颜色值

public ColorFilter getColorFilter ()获得颜色过滤器

public float getTextSize ()获得字体大小数值

public void setStyle (Paint.Style style)设置paint的类型

 

三Color类android.graphics.Color

此类定义了一些方法来创建和转换颜色值。颜色被表示为封装的数值，这个数值由四个字节组成，分别是：alpha、red、green、blue，这些值是非自左乘的，也就是说任何透明性只存储在alpha部分，而不是在颜色组成部分。每一部分按照如下的顺序保存：（alpha<<24）|(red<<16)|<green<<8)|blue.每一部分的取值范围在0-255之间，0意味着这部分不起作用，255表示100%的起作用。因此不透明的黑色应该是0xFF000000,不透明的白色应该是0xFFFFFFFF 。

Color类提供了12个常量值来代表不同的颜色值，我们在开发工程中可以直接调用这些常量值来设置我们所要修饰的文本、图形等对象。

Color类提供了一个无参的构造方法Color()

Color类提供了一些方法来进行颜色值的创建和转换如下：

其中三个方法是用来返回一个颜色常量值的红绿蓝分色，数值分别在0-255之间，如下：

Public static red(int color);

Public static green(int color);

Public static blue(int color);

其中Public static int rgb(int red,int green,int blue);输入红绿蓝三色，返回一个RGB颜色值。

下面几个方法大家可以参考Android API来了解：

Public static int HSVToColor(int alpha,float[] hsv);

Public static int HSVToColor(float[] hsv);

Public static void RGBToHSV(int red,int green,int blue,float[] hsv);

Public static int alpha(int color);

Public static int argb(int alpha,int red,int green,int blue);

Public static colorToHSV(int color,float[] hsv);

Public static parseColor(String colorString);

四．Typeface类android.graphics.Typeface

Typeface类定义字体和字体内在的类型。这个类被用在画笔Paint设置的时候，比如用textSize,textSkewX和textScale设置来指定text在画的时候如何来显示和测量。

Typeface提供了一些常量值来表示自身的一些属性，比如BOLD，BOLD_ITALIC，ITALIC等，开发者可以用defaultFrOPhone SDNtyle(int style)获得内在的Typeface对象。读者可以参考详细的API文档再这里就不再赘述了。

下面我们来看一下Typeface的主要方法。

Typeface类没有构造方法，通常如果一个类没有构造函数就无法通过构造来生成一个对象实体，此时一般会有特定的静态方法来取得这个类的实体。Typeface就提供了四个静态方法间接来得到Typeface实体分别如下：

Public static Typeface create（Typeface family，int style）；

此方法返回一个与已经存在的Typeface字形体系相匹配且类型是指定类型的Typeface。如果你想得到一个与已经存在的Typeface字形体系相类似，但是样式不一样的Typeface时可以调用此方法。其中family参数可以为null，如果为空则表示从默认的Typeface字形体系中选择。

Public static Typefaxe create(String familyname,int style);

此方法通过给定的字形体系的名称familyname和指定的类型返回一个Typeface对象。如果给定字形体系的名称为null，我们可以通过getStyle（）方法来获得返回Typeface对象的真正的属性。

Public static Typeface createFromAsset(AssetManager mgr,String path);

此方法通过规定的字体数据来返回一个Typeface对象。第一个参数为资源管理器，第二个参数是指定字体类型。

Public static Typeface defaultFrOPhone SDNtyle(int style);此方法返回一个指定类型的Typeface对象

Typeface还提供了另外三个方法：

Public int getStyle();此方法返回Typeface内在的类型属性

Public final Boolean isBold();如果getStyle（）有BOLD位组将返回true

Public final Boolean isItalic();如果getStyle（）有ITALIC位组将返回true

五、Path类android.graphics.Path

Path类（一组区域）的描画，类囊括多种几何图形比如直线线段、二次曲线、三次曲线等，

调用Canvas.drawPath()方法可以将Path以所定义的paint的方式来画到画板上或者填出图形，也可以用paint所指定方式来画图形。

 

六、RectF类android.graphics.RectF和Rect类android.graphics.Rect

RectF这个类包含一个矩形的四个单精度浮点坐标。矩形通过上下左右4个边的坐标来表示一个矩形。这些坐标值属性可以被直接访问，用width（）和height（）方法可以获取矩形的宽和高。注意：大多数方法不会检查这些坐标分类是否错误（也就是left<=right和top<=bottom）.

RectF一共有四个构造方法：

RectF（）构造一个无参的矩形

RectF（float left,float top,float right,float bottom）构造一个指定了4个参数的矩形

RectF(Rect F r)根据指定的RectF对象来构造一个RectF对象(对象的左边坐标不变)

RectF(Rect r)根据给定的Rect对象来构造一个RectF对象

RectF提供了很多方法，下面介绍几个方法：

Public Boolean contain(RectF r);判断一个矩形是否在此矩形内，如果在这个矩形内或者和这个矩形等价则返回true，同样类似的方法还有public Boolean contain(float left,float top,float right,float bottom)和public Boolean contain(float x,float y)。

Public void union(float x,float y)更新这个矩形，使它包含矩形自己和（x，y）这个点。

RectF类提供的方法都比较简单，容易理解，再此就不再一一赘述

Android.graphics.Rect类，这个类同android.graphics.RectF很相似，不同的地方是Rect类的坐标是用整形表示的，而RectF的坐标是用单精度浮点型表示的。

 

七、Point类android.graphics.Point

    这个类从字面意思就可以看出它跟点有关系，是点的一个对象类。

这个类有两个属性，分别是：X坐标和y坐标。

构造函数有三个：Point（），Point（int x，int y），Point（Point p）

主要方法有：

Public void set（x，y）；重新设定一下x，y的坐标

Public final void offset(int dx,int dy);给坐标一个补偿值，值可以使正的也可以是负的。

Public final void negate();否定坐标值。

Point类和android.graphics.PointF类似，不同点是前者坐标值的类型是int型，而后者的坐标值是float型。除此之外PointF类多加了几个方法，比如：

Public final float length();返回（0，0）点到该点的距离。

Public static float length(float x,float y);返回（0，0）点到（x，y）点的距离。

下面的例子能让大家很好的了解以上几个类的用法：

@Override

protected void onDraw(Canvas canvas) { 

    Paint paint = new Paint(); 

    paint.setColor(Color.argb(255, 255, 255, 255)); 

     

    Rect rect = new Rect(10, 20, 30, 40); 

    canvas.drawRect(rect, paint); 

     

    RectF rectF = new RectF(40.5f, 20.5f, 60.5f, 40.5f); 

    canvas.drawRect(rectF, paint); 

     

    paint.setStyle(Style.STROKE); 

    canvas.drawRect(10, 50, 30, 80, paint); 

}

 

另外我们可以通过Canvas画图的方法轻松的画一个图片,运行的效果和原代码如下：

这个比较简单,直接看代码吧.

package p.com;

import android.app.Activity;

import android.content.Context;

import android.content.res.Resources;

import android.graphics.Bitmap;

import android.graphics.Canvas;

import android.graphics.Paint;

import android.graphics.drawable.Drawable;

import android.os.Bundle;

import android.view.View;

public class PActivity extends Activity {

        public void onCreate(Bundle savedInstanceState) {

                super.onCreate(savedInstanceState);

                MyView myView = new MyView(this);

                myView.loadLogo();

                setContentView(myView);

        }

        private class MyView extends View {

                public MyView(Context context) {

                        super(context);

                }

                Bitmap bLogo;

                private final Paint mPaint = new Paint();

                /**

                 * 装在logo

                 */

                public void loadLogo() {

                        Resources r = this.getContext().getResources();

                        Drawable logo = r.getDrawable(R.drawable.omslogo);

                        Bitmap bitmap = Bitmap.createBitmap(200, 100,

                                        Bitmap.Config.ARGB_8888);

                        Canvas canvas = new Canvas(bitmap);

                        logo.setBounds(0, 0, 200, 100);

                        logo.draw(canvas);

                        bLogo = bitmap;

                }

                protected void onDraw(Canvas canvas) {

                        if(bLogo != null){

                                canvas.drawBitmap(bLogo, 0, 0, mPaint);

                        }

                }

        }

} 

绘制几何图形：使用android.graphics类

本范例将运用Paint对象（绘笔）的设置值不同，在Cavas(画布）上绘制空心、实习及渐变色的多种几何多形。

范例说明

　　“如何在和机上绘制2D图形呢？”这是许多android游戏开发都是常提到的问题，在android SDK 当中，并没有JavaGraphics2D的函数可以使用，而是使用android.graphics底下的类来绘制2D向量图。这个package提供了许多在手机上绘制图形的类与方法，其中Canvas上，而Paint（Android.graphics.Paint)类则像是彩色铅笔，给予不同的调协，即可绘制不同颜色、不同种类效果的向量图形。

　　本范例将运用Paint对象（绘笔）的设置值不同，在Cavas(画布）上绘制空心、实习及渐变色的多种几何多形。

　　运行结果如果

　　范例程序

　　主程序中继承自Android.view.View的 MyView类，重写 MyView的onDraw（）方法，一开始就会运行绘制的工作，在onDraw（）中以Paint将几何图形绘制在Canvas上，以 paint.setColor() 改变图形颜色、以 paint.setStyle()的设置来控制画出的的图形是空心还是实心。程序的最后一段，就是直接在Canvas写上文字，随着Paint对象里的属性设置，也会有不同的外观模式。

package　com.graphices;　
　
import　 android.app.Activity;
import　android.os.Bundle;
import　 android.view.View;
import　android.content.Context;
import　 android.graphics.Canvas;
import　android.graphics.Color;
import　 android.graphics.Paint;
import　android.graphics.RectF;
import　 android.graphics.Path;
import　android.graphics.Shader;
import　 android.graphics.LinearGradient;
public　class　GraphicesActivity　 extends　Activity　{
　　　　/**　Called　when　the　activity　is　first　created. 　*/
　　　　@Override
　　　　public　void　onCreate(Bundle　 savedInstanceState)　{
　　　　　　　　super.onCreate(savedInstanceState);
　　　　　　　　/*设置ContentView为自定义的MyVieW*/
　　　　　　　　MyView　myView=new　 MyView(this);
　　　　　　　　setContentView(myView);
　　　　}
　　　　/*　自定义继承View　的MyView*/
private　class　MyView　extends　View
{
　　　　　public 　MyView(Context　context){
　　　　　　　　super(context)　;
　　　　　}
　　　　　 /*重写onDraw（）*/
　　　　　@Override
　　　　　protected　void　onDraw(Canvas　 canvas)
　　　　　{　　　
　　　　　　　　　super.onDraw(canvas);
　　　　　　　　　/*设置背景为白色*/
　　　　　　　　　canvas.drawColor(Color.WHITE);
　　　　　　　　　　Paint　 paint=new　Paint();
　　　　　　　　　　/*去锯齿*/
　　　　　　　　　　 paint.setAntiAlias(true);
　　　　　　　　　　/*设置paint的颜色*/
　　　　　　　　　　 paint.setColor(Color.RED);
　　　　　　　　　　/*设置paint的　style　为STROKE：空心*/
　　　　　　　　　　paint.setStyle(Paint.Style.STROKE);
　　　　　　　　　　/*设置paint的外框宽度*/
　　　　　　　　　　paint.setStrokeWidth(3);
　　　　　　　　　　/*画一个空心圆形*/
　　　　　　　　　　canvas.drawCircle(40,　40,　30,　paint);
　　　　　　　　　　/*画一个空心正方形*/
　　　　　　　　　　canvas.drawRect(10,　90,　70,　150,　paint);
　　　　　　　　　　/*画一个空心长方形*/
　　　　　　　　　　canvas.drawRect(10,　170,　70,200,　paint);
　　　　　　　　　　 /*画一个空心椭圆形*/
　　　　　　　　　　RectF　re=new　RectF(10,220,70,250);
　　　　　　　　　　canvas.drawOval(re,　paint);
　　　　　　　　　　/*画一个空心三角形*/
　　　　　　　　　　 Path　path=new　Path();
　　　　　　　　　　path.moveTo(10,　330);
　　　　　　　　　　 path.lineTo(70,330);
　　　　　　　　　　path.lineTo(40,270);
　　　　　　　　　　 path.close();
　　　　　　　　　　canvas.drawPath(path,　paint);
　　　　　　　　　　/* 画一个空心梯形*/
　　　　　　　　　　Path　path1=new　Path();
　　　　　　　　　　 path1.moveTo(10,　410);
　　　　　　　　　　path1.lineTo(70,410);
　　　　　　　　　　 path1.lineTo(55,350);
　　　　　　　　　　path1.lineTo(25,　350);
　　　　　　　　　　 path1.close();
　　　　　　　　　　canvas.drawPath(path1,　paint);
　　　　　　　　　　
　　　　　　　　　　/*设置paint　的style为　FILL：实心*/
　　　　　　　　　　 paint.setStyle(Paint.Style.FILL);
　　　　　　　　　　/*设置paint的颜色*/
　　　　　　　　　　paint.setColor(Color.BLUE);
　　　　　　　　　　/*画一个实心圆*/
　　　　　　　　　　 canvas.drawCircle(120,40,30,　paint);
　　　　　　　　　　/*画一个实心正方形*/
　　　　　　　　　　canvas.drawRect(90,　90,　150,　150,　paint);
　　　　　　　　　　/*画一个实心长方形*/
　　　　　　　　　　canvas.drawRect(90,　170,　150,200,　paint);
　　　　　　　　　　/*画一个实心椭圆*/
　　　　　　　　　　RectF　re2=new　RectF(90,220,150,250);
　　　　　　　　　　 canvas.drawOval(re2,　paint);
　　　　　　　　　　/*画一个实心三角形*/
　　　　　　　　　　Path 　path2=new　Path();
　　　　　　　　　　path2.moveTo(90,　330);
　　　　　　　　　　 path2.lineTo(150,330);
　　　　　　　　　　path2.lineTo(120,270);
　　　　　　　　　　 path2.close();
　　　　　　　　　　canvas.drawPath(path2,　paint);
　　　　　　　　　　 /*画一个实心梯形*/
　　　　　　　　　　Path　path3=new　Path();
　　　　　　　　　　 path3.moveTo(90,　410);
　　　　　　　　　　path3.lineTo(150,410);
　　　　　　　　　　 path3.lineTo(135,350);
　　　　　　　　　　path3.lineTo(105,　350);
　　　　　　　　　　path3.close();
　　　　　　　　　　canvas.drawPath(path3,　paint);
　　　　　　　　　　/*设置渐变色*/
　　　　　　　　　　Shader　mShader=new　LinearGradient(0,0,100,100,
　　　　　　　　　　　　　　　　　　new　 int[]{Color.RED,Color.GREEN,Color.BLUE,Color.YELLOW},
　　　　　　　　　　　　　　　　　　null,Shader.TileMode.REPEAT);
　　　　　　　　　　paint.setShader(mShader);
　　　　　　　　
　　　　　　　　　　/*画一个渐变色圆*/
　　　　　　　　　　 canvas.drawCircle(200,40,30,　paint);
　　　　　　　　　　/*画一个渐变色正方形*/
　　　　　　　　　　canvas.drawRect(170,　90,　230,　150,　paint);
　　　　　　　　　　/*画一个渐变色长方形*/
　　　　　　　　　　canvas.drawRect(170,　170,　230,200,　paint);
　　　　　　　　　　/*画一个渐变色椭圆*/
　　　　　　　　　　RectF　re3=new　RectF(170,220,230,250);
　　　　　　　　　　canvas.drawOval(re3,　paint);
　　　　　　　　　　/*画一个渐变色三角形*/
　　　　　　　　　　Path　path4=new　Path();
　　　　　　　　　　path4.moveTo(170,330);
　　　　　　　　　　path4.lineTo(230,330);
　　　　　　　　　　path4.lineTo(200,270);
　　　　　　　　　　path4.close();
　　　　　　　　　　canvas.drawPath(path4,　paint);
　　　　　　　　　　/*画一个渐变色梯形*/
　　　　　　　　　　Path　path5=new　Path();
　　　　　　　　　　 path5.moveTo(170,　410);
　　　　　　　　　　path5.lineTo(230,410);
　　　　　　　　　　path5.lineTo(215,350);
　　　　　　　　　　path5.lineTo(185,　350);
　　　　　　　　　　path5.close();
　　　　　　　　　　canvas.drawPath(path5,　paint);
　　　　　　　　　　
　　　　　　　　　　/*写字*/
　　　　　　　　　　paint.setTextSize(24);
　　　　　　　　　　 canvas.drawText(getResources().getString(R.string.str_text1),　240,　50,　 paint);
　　　　　　　　　　 canvas.drawText(getResources().getString(R.string.str_text2),　240,　120,　 paint);
　　　　　　　　　　 canvas.drawText(getResources().getString(R.string.str_text3),　240,　190,　 paint);
　　　　　　　　　　 canvas.drawText(getResources().getString(R.string.str_text4),　240,　250,　 paint);
　　　　　　　　　　 canvas.drawText(getResources().getString(R.string.str_text5),　240,　320,　 paint);
　　　　　　　　　　 canvas.drawText(getResources().getString(R.string.str_text6),　240,　390,　 paint);　　
　　　　　}
}
}