Android中利用画图类和线程画出闪烁的心形，送给亲爱的他

大家先看图片：


因为前一段时间在写画图类，刚好有一个线程控制画图闪烁的，我就想说我能不能做一个心形闪烁的，出来的效果就如图，先贴再讲解代码：
里面设置两个类，一个是我们的activity类，这个类用来显示示图，然后建一个继承SurfaceView的类，我们在这里面画图。先贴两个累的代码：
主类名：IaiaiMainActivity，画图类类名：Love.

Java代码  

1. package com.iaiai.activity;  
2.   
3. import android.app.Activity;  
4. import android.os.Bundle;  
5.   
6. /** 
7.  *  
8.  * <p> 
9.  * Title: IaiaiActivity.java 
10.  * </p> 
11.  * <p> 
12.  * E-Mail: 176291935@qq.com 
13.  * </p> 
14.  * <p> 
15.  * QQ: 176291935 
16.  * </p> 
17.  * <p> 
18.  * Http: iaiai.iteye.com 
19.  * </p> 
20.  * <p> 
21.  * Create time: 2011-8-11 
22.  * </p> 
23.  *  
24.  * @author 丸子 
25.  * @version 0.0.1 
26.  */  
27. public class IaiaiActivity extends Activity {  
28.   
29.     @Override  
30.     public void onCreate(Bundle savedInstanceState) {  
31.         super.onCreate(savedInstanceState);  
32.         Love love = new Love(this);  
33.         setContentView(love);  
34.     }  
35. }  

Java代码  

1. package com.iaiai.activity;  
2.   
3. import android.content.Context;  
4. import android.graphics.Canvas;  
5. import android.graphics.Color;  
6. import android.graphics.Paint;  
7. import android.graphics.RectF;  
8. import android.graphics.Typeface;  
9. import android.view.SurfaceHolder;  
10. import android.view.SurfaceView;  
11.   
12. /** 
13.  *  
14.  * <p> 
15.  * Title: Love.java 
16.  * </p> 
17.  * <p> 
18.  * E-Mail: 176291935@qq.com 
19.  * </p> 
20.  * <p> 
21.  * QQ: 176291935 
22.  * </p> 
23.  * <p> 
24.  * Http: iaiai.iteye.com 
25.  * </p> 
26.  * <p> 
27.  * Create time: 2011-8-11 
28.  * </p> 
29.  *  
30.  * @author 丸子 
31.  * @version 0.0.1 
32.  */  
33. public class Love extends SurfaceView implements SurfaceHolder.Callback,  
34.         Runnable {  
35.   
36.     boolean mbloop = false;  
37.     SurfaceHolder mSurfaceHolder = null;  
38.     private Canvas canvas;  
39.     int miCount = 0;  
40.     int y = 50;  
41.   
42.     /** 
43.      * @param context 
44.      */  
45.     public Love(Context context) {  
46.         super(context);  
47.         mSurfaceHolder = this.getHolder();  
48.         mSurfaceHolder.addCallback(this);  
49.         this.setFocusable(true);  
50.         this.setKeepScreenOn(true);  
51.         mbloop = true;  
52.     }  
53.   
54.     /* 
55.      * (non-Javadoc) 
56.      *  
57.      * @see 
58.      * android.view.SurfaceHolder.Callback#surfaceChanged(android.view.SurfaceHolder 
59.      * , int, int, int) 
60.      */  
61.     @Override  
62.     public void surfaceChanged(SurfaceHolder holder, int format, int width,  
63.             int height) {  
64.         // TODO Auto-generated method stub  
65.   
66.     }  
67.   
68.     /* 
69.      * (non-Javadoc) 
70.      *  
71.      * @see 
72.      * android.view.SurfaceHolder.Callback#surfaceCreated(android.view.SurfaceHolder 
73.      * ) 
74.      */  
75.     @Override  
76.     public void surfaceCreated(SurfaceHolder holder) {  
77.         // TODO Auto-generated method stub  
78.         new Thread(this).start();  
79.     }  
80.   
81.     /* 
82.      * (non-Javadoc) 
83.      *  
84.      *  
85.      * @seeandroid.view.SurfaceHolder.Callback#surfaceDestroyed(android.view. 
86.      * SurfaceHolder) 
87.      */  
88.     @Override  
89.     public void surfaceDestroyed(SurfaceHolder holder) {  
90.         // TODO Auto-generated method stub  
91.         mbloop = false;  
92.     }  
93.   
94.     /* 
95.      * (non-Javadoc) 
96.      *  
97.      * @see java.lang.Runnable#run() 
98.      */  
99.     @Override  
100.     public void run() {  
101.         // TODO Auto-generated method stub  
102.         while (mbloop) {  
103.             try {  
104.                 Thread.sleep(200);  
105.             } catch (Exception e) {  
106.                 // TODO: handle exception  
107.             }  
108.             synchronized (mSurfaceHolder) {  
109.                 Draw();  
110.             }  
111.         }  
112.     }  
113.   
114.     private void Draw() {  
115.         // TODO Auto-generated method stub  
116.         canvas = mSurfaceHolder.lockCanvas();  
117.         try {  
118.             if (mSurfaceHolder == null || canvas == null) {  
119.                 return;  
120.             }  
121.             if (miCount < 100) {  
122.                 miCount++;  
123.             } else {  
124.                 miCount = 0;  
125.             }  
126.             Paint paint = new Paint();  
127.             paint.setAntiAlias(true);  
128.             paint.setColor(Color.BLACK);  
129.             canvas.drawRect(0, 0, 320, 480, paint);  
130.             switch (miCount % 6) {  
131.             case 0:  
132.                 paint.setColor(Color.BLUE);  
133.                 break;  
134.             case 1:  
135.                 paint.setColor(Color.GREEN);  
136.                 break;  
137.             case 2:  
138.                 paint.setColor(Color.RED);  
139.                 break;  
140.             case 3:  
141.                 paint.setColor(Color.YELLOW);  
142.                 break;  
143.             case 4:  
144.                 paint.setColor(Color.argb(255, 255, 181, 216));  
145.                 break;  
146.             case 5:  
147.                 paint.setColor(Color.argb(255, 0, 255, 255));  
148.                 break;  
149.             default:  
150.                 paint.setColor(Color.WHITE);  
151.                 break;  
152.             }  
153.             int i, j;  
154.             double x, y, r;  
155.   
156.             for (i = 0; i <= 90; i++) {  
157.                 for (j = 0; j <= 90; j++) {  
158.                     r = Math.PI / 45 * i * (1 - Math.sin(Math.PI / 45 * j))  
159.                             * 20;  
160.                     x = r * Math.cos(Math.PI / 45 * j)  
161.                             * Math.sin(Math.PI / 45 * i) + 320 / 2;  
162.                     y = -r * Math.sin(Math.PI / 45 * j) + 400 / 4;  
163.                     canvas.drawPoint((float) x, (float) y, paint);  
164.                 }  
165.             }  
166.   
167.             paint.setTextSize(32);  
168.             paint.setTypeface(Typeface.create(Typeface.SERIF, Typeface.ITALIC));  
169.   
170.             RectF rect = new RectF(60, 400, 260, 405);  
171.             canvas.drawRoundRect(rect, (float) 1.0, (float) 1.0, paint);  
172.             canvas.drawText("Loving You", 75, 400, paint);  
173.             mSurfaceHolder.unlockCanvasAndPost(canvas);  
174.         } catch (Exception e) {  
175.         }  
176.   
177.     }  
178. }  

关于这个程序要讲解的几点：

1. 画图的时候你可以继承View,也可以继承SurfaceView,这两者的区别在于：surfaceView是在一个新起的单独线程中可以重新绘制画面而View必须在UI的主线程中更新画面。SurfaceView可以控制表面的格式，比如大小，显示在屏幕中的位置，最关键是的提供了SurfaceHolder类，使用getHolder方法获取，还有涉及的surfaceCreated（SurfaceHolder holder）,surfaceDestroyed(SurfaceHolder holder),surfaceChanged(SurfaceHolder holder, int format, int width, int height)方法，而在SurfaceHolder.Callback 接口回调中可以通过重写来改变这些方法

2.程序其实很简单， 既然生命了Runnable接口，就有相对应的Run方法，在surfaceCreate（）的时候开启线程，线程每隔200ms就刷新一次，这样我们看到的效果就是闪烁的，每200毫秒 画一次图，根据经过的间隔时间来设置画笔的颜色，然后通过循环描点，画出心形，然后设置字体大小，画字和字下面的横线。

3.关于心形函数，是从一个例子中看来得，关于x和y的得到，
x = r * Math.cos(Math.PI / 45 * j)  * Math.sin(Math.PI / 45 * i) + 320 / 2；  y = -r * Math.sin(Math.PI / 45 * j) + 400 / 4;
320是屏幕的宽度，本来竖屏我设置的是480，可是下面得写字，就设置为400的了，关于画更好看的心形还有一个函数，大家可以看下：

• 
• 大小: 59.6 KB

• 
• 大小: 10.6 KB