当前位置:  编程技术>移动开发
本页文章导读:
    ▪RESTful 学习札记        RESTful 学习笔记 理解RESTful架构 http://www.ruanyifeng.com/blog/2011/09/restful.html   虚拟研讨会:如何设计好的RESTful API? http://www.infoq.com/cn/articles/how-to-design-a-good-restful-api   RESTful 设计最佳实践 http://.........
    ▪ Handler Runnable跟Thread之间的区别和联系 应用        Handler Runnable和Thread之间的区别和联系 应用 ......
    ▪ objective c之中的类跟实例,方法等基本语法(一)       objective c之中的类和实例,方法等基本语法(一) holydancer原创,如需转载,请在显要位置注明: 转自holydancer的CSDN专栏,原文地址:http://blog.csdn.net/holydancer/article/details/7329490   我们知道,.........

[1]RESTful 学习札记
    来源: 互联网  发布时间: 2014-02-18
RESTful 学习笔记

理解RESTful架构

http://www.ruanyifeng.com/blog/2011/09/restful.html

 

虚拟研讨会:如何设计好的RESTful API?

http://www.infoq.com/cn/articles/how-to-design-a-good-restful-api

 

RESTful 设计最佳实践

http://blog.jobbole.com/41233/

 


    
[2] Handler Runnable跟Thread之间的区别和联系 应用
    来源: 互联网  发布时间: 2014-02-18
Handler Runnable和Thread之间的区别和联系 应用
Android开发:Handler Runnable和Thread之间的区别和联系 应用--------------------看完本篇,从此一览无余!
分类: Android开发2013-02-16 00:47 1696人阅读 评论(2) 收藏 举报

在java中可有两种方式实现多线程,一种是继承Thread类,一种是实现Runnable接口;Thread类是在java.lang包中定义的。一个类只要继承了Thread类同时覆写了本类中的run()方法就可以实现多线程操作了,但是一个类只能继承一个父类,这是此方法的局限。

下面看例子:

 


  • package org.thread.demo;  
  • class MyThread extends Thread{  
  • private String name;  
  • public MyThread(String name) {  
  • super();  
  • this.name = name;  
  • }  
  • public void run(){  
  • for(int i=0;i<10;i++){  
  • System.out.println("线程开始:"+this.name+",i="+i);  
  • }  
  • }  
  • }  
  • package org.thread.demo;  
  • public class ThreadDemo01 {  
  • public static void main(String[] args) {  
  • MyThread mt1=new MyThread("线程a");  
  • MyThread mt2=new MyThread("线程b");  
  • mt1.run();  
  • mt2.run();  
  • }  
  • }

 

但是,此时结果很有规律,先第一个对象执行,然后第二个对象执行,并没有相互运行。在JDK的文档中可以发现,一旦调用start()方法,则会通过JVM找到run()方法。下面启动start()方法启动线程:

  • package org.thread.demo;  
  • public class ThreadDemo01 {  
  • public static void main(String[] args) {  
  • MyThread mt1=new MyThread("线程a");  
  • MyThread mt2=new MyThread("线程b");  
  • mt1.start();  
  • mt2.start();  
  • }  
  • }; 
  • 这样程序可以正常完成交互式运行。那么为啥非要使用start();方法启动多线程呢?

    在JDK的安装路径下,src.zip是全部的java源程序,通过此代码找到Thread中的start()方法的定义,可以发现此方法中使用了private native void start0();其中native关键字表示可以调用操作系统的底层函数,那么这样的技术成为JNI技术(java Native Interface)

    Runnable接口

    在实际开发中一个多线程的操作很少使用Thread类,而是通过Runnable接口完成。

  • public interface Runnable{  
  • public void run();  
  • 例子:

  • package org.runnable.demo;  
  • class MyThread implements Runnable{  
  • private String name;  
  • public MyThread(String name) {  
  • this.name = name;  
  • }
  • public void run(){  
  • for(int i=0;i<100;i++){  
  • System.out.println("线程开始:"+this.name+",i="+i);  
  • }  
  • }  
  • }; 
  • 但是在使用Runnable定义的子类中没有start()方法,只有Thread类中才有。此时观察Thread类,有一个构造方法:public Thread(Runnable targer)此构造方法接受Runnable的子类实例,也就是说可以通过Thread类来启动Runnable实现的多线程。(start()可以协调系统的资源):

  • package org.runnable.demo;  
  • import org.runnable.demo.MyThread;  
  • public class ThreadDemo01 {  
  • public static void main(String[] args) {  
  • MyThread mt1=new MyThread("线程a");  
  • MyThread mt2=new MyThread("线程b");  
  • new Thread(mt1).start();  
  • new Thread(mt2).start();  
  • }  
  • 两种实现方式的区别和联系:

    在程序开发中只要是多线程肯定永远以实现Runnable接口为主,因为实现Runnable接口相比继承Thread类有如下好处:

    • 避免点继承的局限,一个类可以继承多个接口。
    • 适合于资源的共享

    以卖票程序为例,通过Thread类完成:

  • package org.demo.dff;  
  • class MyThread extends Thread{  
  • private int ticket=10;  
  • public void run(){  
  • for(int i=0;i<20;i++){  
  • if(this.ticket>0){  
  • System.out.println("卖票:ticket"+this.ticket--);  
  • }  
  • }  
  • }  
  • }; 
  • 下面通过三个线程对象,同时卖票:

  • package org.demo.dff;  
  • public class ThreadTicket {  
  • public static void main(String[] args) {  
  • MyThread mt1=new MyThread();  
  • MyThread mt2=new MyThread();  
  • MyThread mt3=new MyThread();  
  • mt1.start();//每个线程都各卖了10张,共卖了30张票  
  • mt2.start();//但实际只有10张票,每个线程都卖自己的票  
  • mt3.start();//没有达到资源共享  
  • }  
  • 如果用Runnable就可以实现资源共享,下面看例子:

  • package org.demo.runnable;  
  • class MyThread implements Runnable{  
  • private int ticket=10;  
  • public void run(){  
  • for(int i=0;i<20;i++){  
  • if(this.ticket>0){  
  • System.out.println("卖票:ticket"+this.ticket--);  
  • }  
  • }  
  • }  
  • }  
  • package org.demo.runnable;  
  • public class RunnableTicket {  
  • public static void main(String[] args) {  
  • MyThread mt=new MyThread();  
  • new Thread(mt).start();//同一个mt,但是在Thread中就不可以,如果用同一  
  • new Thread(mt).start();//个实例化对象mt,就会出现异常  
  • new Thread(mt).start();  
  • }  
  • }; 
  • 虽然现在程序中有三个线程,但是一共卖了10张票,也就是说使用Runnable实现多线程可以达到资源共享目的。

    Runnable接口和Thread之间的联系:

    public class Thread extends Object implements Runnable

    发现Thread类也是Runnable接口的子类。

     

    第二:

    Thread是系统给你的资源,有了Thread你才有从CPU那里得到可执行时间片的权力, Thread并不认识你的程序,不知道有test 这样的类,因为编序员有千千万,每个人命名都不一样,想要做的事都不一样, 所以 Thread只认识一个! 那就是Runnable 。 Thread认识Runnable 并且知道Runnable 里面有一个run方法. 一旦调用Thread的start方法,Runnable 方法里的run就会被Thread自动运行。 所以,当我们把我们的类继承(这里应该叫实现接口)自Runnable 的时候,我们的程序就是属于Runnable 一个类型的了。 虽然是Runnable 的子类,但人家认识你爸爸,当然也知道了你。 Thread可以不管你内部有什么情况,他只管你有run()方法就行了,他就调start让你去运行run 所以我们在run里面写点东西,这样就可以让系统运行我们想要做的代码了。 是不是很通俗很易懂呢? 所以要运行线程的步骤是, 1。生成我们自己的类对象 2。从系统那里得到Thread 3。让Threa调我们的类对象,让其start起来 代码: test a=new test(); Thread thread=new Thread(a); //Thread需要一个参数,就是你编的线程类,这样他就认识了你的线程,也有资格向系统申请拿到CPU时间片thread.start(); 你可以简单点写: new Thread(a).start();

    第三:

     

    Runnable 并不一定是新开一个线程,比如下面的调用方法就是运行在UI主线程中的:

         Handler mHandler=new Handler(); 
         mHandler.post(new Runnable(){ 
            @Override public void run() 
            { // TODO Auto-generated method stub 
             } 
         });

    官方对这个方法的解释如下,注意其中的:“The runnable will be run on the user interface thread. ”

    boolean android.view.View .post(Runnable action)

    Causes the Runnable to be added to the message queue. The runnable will be run on the user interface thread.

    Parameters:

    action The Runnable that will be executed.

    Returns:

    Returns true if the Runnable was successfully placed in to the message queue. Returns false on failure, usually because the looper processing the message queue is exiting.

    我们可以通过调用handler的post方法,把Runnable对象(一般是Runnable的子类)传过去;handler会在looper中调用这个Runnable的Run方法执行。

    Runnable是一个接口,不是一个线程,一般线程会实现Runnable。所以如果我们使用匿名内部类是运行在UI主线程的,如果我们使用实现这个Runnable接口的线程类,则是运行在对应线程的。

    具体来说,这个函数的工作原理如下:

    View.post(Runnable)方法。在post(Runnable action)方法里,View获得当前线程(即UI线程)的Handler,然后将action对象post到Handler里。在Handler里,它将传递过来的action对象包装成一个Message(Message的callback为action),然后将其投入UI线程的消息循环中。在Handler再次处理该Message时,有一条分支(未解释的那条)就是为它所设,直接调用runnable的run方法。而此时,已经路由到UI线程里,因此,我们可以毫无顾虑的来更新UI。

    如下图,前面看到的代码,我们这里Message的callback为一个Runnable的匿名内部类

    这种情况下,由于不是在新的线程中使用,所以千万别做复杂的计算逻辑。



     


     

     

    第四:在多线程编程这块,我们经常要使用Handler,Thread和Runnable这三个类,那么他们之间的关系你是否弄清楚了呢?

      首先说明Android的CPU分配的最小单元是线程,Handler一般是在某个线程里创建的,因而Handler和Thread就是相互绑定的,一一对应。

      而Runnable是一个接口,Thread是Runnable的子类。所以说,他俩都算一个进程。

      HandlerThread顾名思义就是可以处理消息循环的线程,他是一个拥有Looper的线程,可以处理消息循环。

      与其说Handler和一个线程绑定,不如说Handler是和Looper一一对应的。

      最后需要说明的是,在UI线程(主线程)中:

      mHandler=new Handler();

      mHandler.post(new Runnable(){

      void run(){

      //执行代码...

      }

      });

      这个线程其实是在UI线程之内运行的,并没有新建线程。

      常见的新建线程的方法是:

      Thread thread = new Thread();

      thread.start();

      HandlerThread thread = new HandlerThread("string");

      thread.start();

    第五:Java Runnable接口在进行相关编写的时候需要我们不断的学习相关代码。下面我们就来看炫如何才能使用相关的代码。Runnable接口只有一个方法run(),我们声明自己的类实现Runnable接 口并提供这一方法,将我们的线程代码写入其中,就完成了这一部分的任务。

      但是Runnable接口并没有任何对线程的支持,我们还必须创建Thread类 的实例,这一点通过Thread类的构造函数public Thread(Runnable target);来实现。下面是一个例子:

      1.public class MyThread implements Runnable

      2.{

      3.int count= 1, number;

      4.public MyThread(int num)

      5.{

      6.numnumber = num;

      7.System.out.println("创建线程 " + number);

      8.}

      9.public void run()

      10.{

      11.while(true)

      12.{

      13.System.out.println

      14.("线程 " + number + ":计数 " + count);

      15.if(++count== 6) return;

      16.}

      17.}

      18.public static void main(String args[])

      19.{

      20.for(int i = 0; i 〈 5;

      21.i++) new Thread(new MyThread(i+1)).start();

      22.}

      23.}

      严格地说,创建Thread子类的实例也是可行的,但是必须注意的是,该子类必须没有覆盖 Thread 类的 run 方法,否则该线程执行的将是子类的 run 方法,而不是我们用以实现Runnable 接口的类的 run 方法,对此大家不妨试验一下。

      使用 Java Runnable接口来实现多线程使得我们能够在一个类中包容所有的代码,有利于封装,它的缺点在于,我们只能使用一套代码,若想创建多个线程并使各个线程执行不同的代 码,则仍必须额外创建类,如果这样的话,在大多数情况下也许还不如直接用多个类分别继承 Thread 来得紧凑。

    参考:

    http://www.cnblogs.com/qingblog/archive/2012/08/08/2628245.html

    http://java.chinaitlab.com/net/807900.html

    http://czhjchina.blog.163.com/blog/static/20027904720111153382495/

    http://zhidao.baidu.com/question/82198667.html

    http://developer.51cto.com/art/201203/321042.htm


        
    [3] objective c之中的类跟实例,方法等基本语法(一)
        来源: 互联网  发布时间: 2014-02-18
    objective c之中的类和实例,方法等基本语法(一)

    holydancer原创,如需转载,请在显要位置注明:

    转自holydancer的CSDN专栏,原文地址:http://blog.csdn.net/holydancer/article/details/7329490

     

    我们知道,在objective c之中是有面向对象的概念的,这也是为什么别人说oc要比c优雅的原因。虽然objective c继承了c的语法习惯等,但是在涉及到面向对象时,语法仍然是很令初学者大为头疼的。

     

    OC下类的创建分为两个部分,一个是类的声明(@interface),一个是类的实现(@implementation),在创建一个类时,我们可以在main.m中 main()方法之前,作出声明与实现,

     

    [plain] view plaincopy
     
  • @interface student :NSObject    //声明开始,类名为student,继承自NSObject类;  
  • {  
  •     @public int age;  
  •     NSString *name;  
  • }           //大括号中为属性;age属性前加@public 是为了能在main()直接赋值。  
  • -(void)study;       //"-"减号代表为成员方法,"+"代表类方法,类似static  
  • @end            //声明结束  
  •   
  • @implementation student //实现开始,后面类名与声明中要一致  
  •   
  •   
  • -(void)study        //实现方法中仅实现方法。  
  • {  
  •     NSLog(@"我正在学习,我%d岁了",age);  
  • }  
  •   
  • @end            //类中方法实现结束。  


  •  

     

    以上为一个类在main()方法之前简单的定义,然后我们就可以在main()方法中实例该类并设置属性,调用方法。

     

    [plain] view plaincopy
     
  • int main(int argc, const char * argv[])  
  • {  
  •   
  •     @autoreleasepool {  
  •   
  •         student *student1 = [student new];  //实例该类,生成student1对象   
  •         student1->age=5;         //@public属性的age可以在此直接赋值  
  •         [student1 study];           //调用该对象中的study方法,输出语句;  
  •          
  •     }  
  •     return 0;  
  • }  


  •  


     

    上面是类的简单定义和实现,正常情况下为了程序代码的可操作与维护,都会另建单独的类文件,我们在Xcode中新建一个类后,会自动生成两个文件,一个是以.h为后缀的头文件,一个是以.m为后缀的文件,其中头文件用来存放类文件的声明部分,.m文件用来存储类文件的实现部分,然后在main.m文件中导入该.h头文件就可以正常使用该类。下面我们生成一个teacher类的.h文件:

     

    [plain] view plaincopy
     
  • #import <Foundation/Foundation.h>  
  •   
  • @interface teacher : NSObject  
  • {  
  •     int age;  
  •     NSString *name;  
  •       
  • }  
  • -(void)teach;  
  • -(void)introduce;  
  • -(void)setName:(NSString *)name setAge:(int)age;  
  • //两个参数,一个是NSString *类型,一个是int类型,一定要注意  
  • @end                        //结束声明。  


  •  

     

     

    然后是.m文件:

     

    [plain] view plaincopy
     
  • #import "teacher.h"     //注意要导入头文件,和声明连接起来。  
  •   
  • @implementation teacher  
  • -(void)teach{             
  •     NSLog(@"我在教你们哦");  
  • }  
  • -(void) setName:(NSString *)n setAge:(int)a{    //此处要注意的是,如果一个方法有两个参数,  
  •     name=n; //将声明中的形参name,age改成n,a,是为了不冲突,因为OC中没有this概念。  
  •     age=a;  //此处说明声明和实现中的形参名称可以不一致,但一定要对应。  
  • }  
  •   
  • -(void)introduce    //一个单纯的无参方法,so cute;  
  • {  
  •     NSLog(@"我叫%@,我今年%d,我正在自我介绍",name,age);  
  • }  
  • @end  


  •  


    下面我们在main()方法中进入类的初始化,属性赋值,方法调用:

     

     

    [plain] view plaincopy
     
  • #import <Foundation/Foundation.h>  
  • #import "teacher.h"  
  • @interface student :NSObject  
  • {  
  •     @public int age;  
  •     NSString *name;  
  • }  
  • -(void)study;  
  • @end  
  •   
  • @implementation student  
  •   
  •   
  • -(void)study  
  • {  
  •     NSLog(@"我正在学习,我%d岁了",age);  
  • }  
  •   
  • @end  
  • int main(int argc, const char * argv[])  
  • {  
  •   
  •     @autoreleasepool {  
  •         teacher *teacher1 = [teacher new];  //生成一个teacher类对象:teacher1  
  •         [teacher1 teach];           //调用该对象的teach方法  
  •         [teacher1 setName:@"holydancer" setAge:22];//调用该对象的setName:setAge方法并赋值给对象属性  
  •         [teacher1 introduce];                 
  •          
  •          
  •     }  
  •     return 0;  
  • }  


  •  



     

    得到以上结果,需要注意的还是双参数方法,在上面代码给teacher1的属性赋值时,只调用了一个方法,方法名为:setName:setAge

     

    关键字:objective-c ,objective c , oc ,基本语法,类,实例


        
    最新技术文章:
    ▪Android开发之登录验证实例教程
    ▪Android开发之注册登录方法示例
    ▪Android获取手机SIM卡运营商信息的方法
    ▪Android实现将已发送的短信写入短信数据库的...
    ▪Android发送短信功能代码
    ▪Android根据电话号码获得联系人头像实例代码
    ▪Android中GPS定位的用法实例
    ▪Android实现退出时关闭所有Activity的方法
    ▪Android实现文件的分割和组装
    ▪Android录音应用实例教程
    ▪Android双击返回键退出程序的实现方法
    ▪Android实现侦听电池状态显示、电量及充电动...
    ▪Android获取当前已连接的wifi信号强度的方法
    ▪Android实现动态显示或隐藏密码输入框的内容
    ▪根据USER-AGENT判断手机类型并跳转到相应的app...
    ▪Android Touch事件分发过程详解
    ▪Android中实现为TextView添加多个可点击的文本
    ▪Android程序设计之AIDL实例详解
    ▪Android显式启动与隐式启动Activity的区别介绍
    ▪Android按钮单击事件的四种常用写法总结
    ▪Android消息处理机制Looper和Handler详解
    ▪Android实现Back功能代码片段总结
    ▪Android实用的代码片段 常用代码总结
    ▪Android实现弹出键盘的方法
    ▪Android中通过view方式获取当前Activity的屏幕截...
    ▪Android提高之自定义Menu(TabMenu)实现方法
    ▪Android提高之多方向抽屉实现方法
    ▪Android提高之MediaPlayer播放网络音频的实现方法...
    ▪Android提高之MediaPlayer播放网络视频的实现方法...
    ▪Android提高之手游转电视游戏的模拟操控
     


    站内导航:


    特别声明:169IT网站部分信息来自互联网,如果侵犯您的权利,请及时告知,本站将立即删除!

    ©2012-2021,,E-mail:www_#163.com(请将#改为@)

    浙ICP备11055608号-3