精华内容
下载资源
问答
  • IOS Block 代码块使用 (一)

    千次阅读 2013-09-26 12:48:07
     代码块的书写和C语言函数的语法格式有点像,例如下面求和函数分别C 语言和代码块来实现: int add(int a,int b) {  return a+b; } int (^add)(int a,int b) = ^(int a,int b){ return a +b;}; 注意:a....
    
    
    一 代码块的语法 
    

     代码块的书写和C语言函数的语法格式有点像,例如下面求和函数分别用C 语言和代码块来实现:

    int add(int a,int b)
    {
         return a+b;
    }

    int (^add)(int a,int b) = ^(int a,int b)
    {
        
    return a +b;
    };


    注意:a.代码块最后的大括号后面一定要加分号。
              b.与c语言的函数签名不同的是,代码块的名字需要用'^'和括号。
              c. 代码块的签名部分和实现部分需要用'=^(参数列表)'来连接。

    除次之外代码块还可以将签名和实现部分分开来实现,例如:
    void (^PrintInfo)(NSString *info);
       
    PrintInfo = ^(
    NSString *info)
    {
       
    NSLog(@"%@",info);
    };

     代码块也可以看作是函数的指针,差别是用^代替了*.

    二 代码块的调用方式
    1.直接调用,例如,对于刚才定义的PrintInfo代码块

       PrintInfo( @"Hello World" );
          

    2.使用代码块"指针"的方式来实现,例如:
     
     typedef void (^Print) (NSString *info);
     
     void (^PrintName) (NSString * name) = ^(NSString * name)
     {
        
    NSLog(@"MyName:%@",name);
     };

     
    Print myBlock = PrintName;
     myBlock(
    @"Hello");


     void (^PrintCountry)(NSString * Country)= ^(NSString *Country)
     {
         
    NSLog(@"MyCountry:%@",Country);
     };
     myBlock= PrintCountry;
     myBlock(
    @"China");

      
    注: 在一个block的内部可以调用另外一个block
      /*************** Definition of first block object ***************/ 
    NSString *(^trimString)(NSString *) = ^(NSString *inputString)
    {
         
    NSString *result = [inputString stringByTrimmingCharactersInSet
                                              [NSCharacterSet whitespaceCharacterSet]];
         
    return result;
    };

    /*************** Definition of second block object ***************/ 
    NSString *(^trimWithOtherBlock)(NSString *) = ^(NSString *inputString)
    {
        
    return trimString(inputString);
    }
    3.使用方法举例
           
           代码块的作用主要是用来做回调函数来使用的,它可以代替IOS SDK中的代理方法。使用代码块比用代理
    方法的效率更高。

    a.首先定义两个代码块指针
    typedef void (^SucceedBlock)(void); //访问服务器成功的时候
    typedef void (^FailedBlock )(void); //访问服务器失败的时候


    b.定义访问服务器方法
    - (void) getDataFromServer:(NSString*) URL succeedBlock:(SucceedBlock) succeed 
                                                failedBlock:(FailedBlock) fail
    {
        //模拟调用成功和失败
       
     if ([URL isEqualToString:@"YES"])
        {
            succeed();
        }
       
     else
        {
            fail();
        }
    }

    c.调用上面的方法

    void (^succeedBlock)(void) = ^
    {
       
     NSLog(@"do something succeed thing");
    };

    void (^failedBlock)(void) = ^
    {
       
     NSLog(@"do some failed thing");
    };

    采用独立代码块的方式实现函数的调用
    [self getDataFromServer:@"YES" succeedBlock:succeedBlock failedBlock:failedBlock];

    也可以在调用的时候来定义代码块(内联的方式实现代码块的调用)
    [
    self getDataFromServer:@"NO" succeedBlock:^{
           
     NSLog(@"inline succeed block!");
        }
    failedBlock:^{
           
     NSLog(@"inline failed block!");
        }
    ];
    d.直接用代码块作参数
    -(void) testBlock:(NSString*)name completionBlock:(void (^)(NSString* addr)) block
    {
        block(name);
    }
    [self testBlock:@"zhangzhe" completionBlock:^(NSString *addr)
    {
         NSLog(@"addr:%@",addr);
    }];
    四 代码块中变量访问
    a.对于独立代码块,内部定义的局部变量的使用方式和普通的objective-c函数是相同的,可以进行读写
          void (^independentBlockObject)(void) = ^(void)
        {
           
     NSInteger localInteger = 10;
           
     NSLog(@"local integer = %ld", (long)localInteger);
            lojalitetger = 20;
           
     NSLog(@"local integer = %ld", (long)localInteger);
        };
    localInteger是可以被读写的
    b.对于内联方式定义的代码块,局部变量不仅包括在代码块内部定义的变量,而且还包含在实现代码块
       函数内部定义的变量。对于前一部分变量是可读写的,对于后一部分变量是只读的。例如:
    - (void)viewDidLoad
    {
        int outsideInteger = 10;
        [self getDataFromServer:@"NO" succeedBlock:^{
           
     int insideInteger = 10;
            ++insideInteger;
            //outsideInteger =
     5; //这样直接写会报错误 提示outsideInteger没有加__block
            NSLog(@"ousideInteger=%d  insideInteger=%d",outsideInteger,insideInteger);
        }
    failedBlock:^{
           
     NSLog(@"inline failed block!");
        }];
    }
    所以对于代码块外定义的局部变量是只读的,要想可以读写需要在改变量前面加两个下划线+block  
        __block   int outsideInteger = 10;
    c.对于selfl变量的访问,如果是在独立代码块不能直接访问self变量,要访问可以将其作为代码块参数传入,对于内联点名块,只要在实现该代码块的函数可以访问的话,在代码块内部就可以直接访问。
    void (^correctBlockObject)(id) = ^(id self)
    {
         
    NSLog(@"self = %@", self);
    };
    - (void)viewDidLoad
    {
        [self getDataFromServer:@"NO" succeedBlock:^{
           
     NSlog(@"self = %@",self);
        }
    failedBlock:^{
            
    NSLog(@"inline failed block!");
        }];
    }
    d.对于使用 @property定义的属性变量的访问,如果内联代码块可以使用点号的方式访问,也可以使用
      方括号的方式来访问,但是对于独立代码块的话只能使用后者来访问。

     @interface GASSViewController : UIViewController
      @property(nonatomic,strongNSString *name;
     @end

    对于独立代码块
     void (^correctBlockObject)(id) = ^(id self)
     {
        NSLog(@"self = %@", self);
        
    /* Should use setter method instead of this */
        
    self.name = @"Block Objects"; /* Compile-time Error */
        
    /* Should use getter method instead of this */
         NSLog(
    @"self.name = %@",self.name); /* Compile-time Error */

     };

    对于内联代码块
    [self getDataFromServer:@"NO" succeedBlock:^{
           
     NSLog(@"self.name = %@",self.name);
        }
    failedBlock:^{
           
     NSLog(@"inline failed block!");
    }];
    e.对于代码块外的变量,代码块会拷贝到自己的一个结构体内(相当于深拷贝),需要注意的是这个深拷贝是在定义代码块的时候进行的,而不是你调用的时候。
      typedef void (^BlockWithNoParams)(void); 
       - (void) scopeTest  
       {
            NSUInteger integerValue = 10;
           
     /*************** Definition of internal block object ***************/ 
            BlockWithNoParams myBlock = ^{
                NSLog(
    @"Integer value inside the block = %lu", (unsigned long)integerValue);
            };
           
     /*************** End definition of internal block object ***************/
            integerValue =
     20;
           
     /* Call the block here after changing the value of the integerValue variable */
            myBlock();
            NSLog(
    @"Integer value outside the block = %lu", (unsigned long)integerValue);
        }
       输出的结果:
          Integer value inside the block  = 10 
         Integer value outside the block = 20

    避免这种情况
       - (void) scopeTest  
       {
             __block NSUInteger integerValue = 10;
            
    /*************** Definition of internal block object ***************/ 
            BlockWithNoParams myBlock = ^{
                NSLog(
    @"Integer value inside the block = %lu", (unsigned long)integerValue);
            };
            
    /*************** End definition of internal block object ***************/
            integerValue = 
    20;
            
    /* Call the block here after changing the value of the integerValue variable */
            myBlock();
            NSLog(
    @"Integer value outside the block = %lu", (unsigned long)integerValue);
        }
       输出的结果:
         Integer value inside the block  = 20 
         Integer value outside the block = 20

    d.对于类中的实例成员来说,在代码块中可以直接访问是可以读写的,不用写__block
      @interface GASSViewController ()
      @property(nonatomic,strong) NSArray *testArr;
     @end

       @implementation GASSViewController
      @synthesize testArr = _testArr;

      void (^independentBlockObject)(void) = ^(void)
      {
         
    self.testArr = @[@"ONE",@"TWO"];
      
    };
      independentBlockObject();

    展开全文
  • 今天有个同事问我关于代码块的问题 只记得静态代码块要提前执行 怕说错,查了资料,实测的一下,供大家参考 public class book { { System.out.println("这里是构造代码块");//所有类中有一个默认的构造函数,...

    今天有个同事问我关于代码块的问题   只记得静态代码块要提前执行 怕说错,查了资料,实测的一下,供大家参考

    public class book {

    {
    System.out.println("这里是构造代码块");//所有类中有一个默认的构造函数,这里的代码块为构造代码块,在类中的对象被创建时执行
    }
    public static void main(String[] args) {

    {
    System.out.println("这里是普通代码块A");
    }
    new book();//第二次类加载时静态代码块不执行
    new book();

    {
    System.out.println("这里是普通代码块B");
    }
    }
    static{
    System.out.println("这里是静态代码块");
    }
    }

    运行结果

    这里是静态代码块
    这里是普通代码块A
    这里是构造代码块//实例化时才创建 
    这里是构造代码块
    这里是普通代码块B



    静态代码块:每个静态代码块只会执行一次(类在内存中加载时执行,类在内存中加载后类已经存在)由于JVM在加载类时会执行静态代码块,所以静态代码块先于主方法执行。如果类中包含多个静态代码块,那么将按照"先定义的代码先执行,后定义的代码后执行。

    构造块:(直接在类中定义)且没有加static关键字的代码块称为{}构造代码块。

    构造代码块在创建对象时被调用,每次创建对象都会被调用,并且构造代码块的执行次序优先于类构造函数。

    子类父类有继承关系

    class book {

    {
    System.out.println("这里是父类构造代码块");
    }


    static {
    System.out.println("这里是父类静态代码块");
    }
    }

    class Englishbook extends book {


    {
    System.out.println("这里是子类构造代码块");
    }
    static {
    System.out.println("这里是子类静态代码块");
    }


    public static void main(String[] args) {


    {
    System.out.println("这里是子类普通代码块");
    }


    new Englishbook();
    new Englishbook();


    }
    }

    结果

    这里是父类静态代码块
    这里是子类静态代码块
    这里是子类普通代码块
    这里是父类构造代码块
    这里是子类构造代码块
    这里是父类构造代码块
    这里是子类构造代码块

    简单总结:父类静态代码块初始化时执行一次,只要在类里面,方法外面都属于构造代码块,子类每次new都会调用父类的构造代码块,普通代码块按顺序执行。

    Ps实践是检验真理的唯一标准

    展开全文
  • 主要介绍了Java中普通代码块、构造代码块与静态代码块的相关资料,静态代码块>Main()>构造代码块。非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • 在Java中,使用{}括起来的代码被称为代码块 代码块的分类 根据位置和声明不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块 局部代码块:在方法中出现,限定变量生命周期,及早释放,提高内存利用...
    1. 代码块的概述
    • 在Java中,使用{}括起来的代码被称为代码块
    1. 代码块的分类
      根据位置和声明不同,可以分为局部代码块,构造代码块,静态代码块,同步代码块
    • 局部代码块:在方法中出现,限定变量生命周期,及早释放,提高内存利用率
    • 构造代码块(初始化块):在类中方法外出现
    • 静态代码块:一般用于加载驱动
      static{}
    1. 测试代码
    public class face_code_question {
        public static void main(String[] args) {
            System.out.println("我是主方法");
            //创建对象
            question s=new question();
            question s1=new question("清杉夫人");               			//主方法,在主方法类中的静态代码块执行之后执行
            {
                System.out.println("我是局部代码块");
            }
        }
        static {
            System.out.println("我是主方法类中的静态代码块");            //主方法类中的静态代码块优先于主方法执行
        }
    }
    class question {
        private String name;
        //无参构造
        public question() {
            System.out.println("我是无参构造");
        }
        //有参构造
        public question(String name) {
            this.name=name;
            System.out.println("我是有参构造");
        }
        {
            System.out.println("我是构造代码块");              		//随着对象的创建而加载,对象创建一次,构造代码块执行一次
        }
        static {
            System.out.println("我是静态代码块");              		//静态代码块,随着类的加载而加载,并且只执行一次
        }
    }
    
    1. 运行结果
      在这里插入图片描述
    2. 总结
    • 局部代码块:在方法中出现
    • 构造代码块:在类中方法外出现,随着对象的创建而加载,创建一次对象构造代码块执行一次
    • 静态代码块:随着类的加载而加载,并且只执行一次(一般用于加载驱动)
    • 主方法类中的静态代码块:优先于主方法执行
    1. 面试题
    • 以下代码运行后会有怎样的输出结果,为什么?
    public class face_extends_question_2 {
        public static void main(String [] args) {
            Zi s=new Zi();
        }
    }
    
    class Fu {
        static {
            System.out.println("父类  静态构造代码块");
        }
        {
            System.out.println("父类  构造代码块");
        }
        public Fu () {
            System.out.println("父类  构造方法");
        }
    }
    
    class Zi extends Fu {
        static {
            System.out.println("子类  静态构造代码块");
        }
        {
            System.out.println("子类  构造代码块");
        }
        public Zi() {
            System.out.println("子类  构造方法");
        }
    }
    
    • 运行结果
      在这里插入图片描述
    • 分析
      • jvm调用了main方法,main方法进栈
      • 遇到zi s=new zi();会先将fu.class和zi.class分别加载近内存,在创建对象,当fu.class加载进内存
        父类的静态代码块会随着父类的加载而加载,当Zi.class加载进内存,子类中的静态代码块会随着子类的加载而加载。
      • 走子类的构造方法,因为Java中是分层初始化的,先初始化父类,在初始化子类,所以先走父类构造,但是在执行父类构造是,发现父类构造中有构造代码块,构造代码块是优先于构造方法执行的,所以打三个输出父类的构造代码块,接着输出父类的构造方法
      • 父类的构造方法初始化完成,走子类的构造方法,子类中也有优先于构造方法的构造代码块,所以先显示子类中的构造代码块,再显示子类的构造方法
    展开全文
  • 主要介绍了Java 中普通代码块,构造代码块,静态代码块区别及代码示例的相关资料,需要的朋友可以参考下
  • 静态代码块和构造代码块

    千次阅读 2014-06-19 02:32:45
    静态代码块和构造代码块的 ...使用static关键字修饰的代码块称为静态代码块,一般用于初始化类的静态属性和对象创建前的环境。静态代码块在类装载时会自动执行,换言之,一旦触发类,其中的静态代码块

    静态代码块和构造代码块

    所谓代码块是指使用“{}”括起来的一段代码。Java有四种代码块,分别是普通代码块(如方法后大括号中的代码)、构造代码块、静态代码块、同步代码块(与多线程数据安全有关)。

    1.静态代码块

    使用static关键字修饰的代码块称为静态代码块,一般用于初始化类的静态属性和对象创建前的环境。静态代码块在类装载时会自动执行,换言之,一旦触发类,其中的静态代码块便会最先得到执行,并且只执行一次,与创建的对象个数无关。

    2.构造代码块

    从名字上可以看出构造代码块同构造方法有密切关系,构造代码块本身是为简化构造方法而设计的,通常将多个构造方法中相同的代码放到构造代码块中。

    示例如下:

    public class Some {
        public static String test = "测试代码!";
    
        // 静态代码块
        static {
            System.out.println("静态代码块已执行!!!");
        }
    
        // 构造代码块
        {
            System.out.println("构造代码块已执行!!!");
        }
    
        public Some()
        {
            System.out.println("无参构造方法已调用!");
        }
    
        public Some(int num)
        {
            System.out.println("有参构造方法已调用!");
        }
    }
    public class Main {
        /*
         * 输出结果:
         * 调用Some.test:
         * 静态代码块已执行!!!
         * 测试代码!
         * 
         * 创建无参 Some 对象:
         * 构造代码块已执行!!!
         * 无参构造方法已调用!
         * 
         * 创建有参 Some 对象:
         * 构造代码块已执行!!!
         * 有参构造方法已调用!
         * 
         * 再次调用 Some.test:
         * 测试代码!
         */
        public static void main(String[] args)
        {
            System.out.println("调用Some.test:");
            System.out.println(Some.test);
    
            System.out.println("\n创建无参 Some 对象:");
            Some some1 = new Some();
    
            System.out.println("\n创建有参 Some 对象:");
            Some some2 = new Some(10);
    
            System.out.println("\n再次调用 Some.test:");
            System.out.println(Some.test);
        }
    }
    

    从结果中可以看出,静态代码块在类被触发时最先得到执行并且只执行一次,而构造代码块则总是在构造方法之前执行。

    如果将上面的main方法移到Some类中,则无论main中的代码怎么写,“静态代码块已执行!!!”总是显示在最前面(此时执行main方法触发了Some类)。

    展开全文
  • 代码块

    千次阅读 2019-05-05 20:41:17
    代码块:就是{}扩起来的代码。 根据位置和关键字的不同分为普通代码块、构造块、静态代码块、同步代码块。 1、普通代码块:就是直接在方法或语句中定义的代码块。 public class CodeDemo01 { public static void ...
  • 1什么是代码块?? 答:代码块:在Java中用{}括... *变量x在类中只使用一次, 一个局部代码块,是为了在代码块结束后,内存自动释放,减少内存的使用 是顺序执行的,只是在执行结束后,立即消失。* main(.....
  • welcome to my blog 折叠当前代码块ctrl - 展开当前代码块ctrl = 折叠所有代码块ctrl shift - 展开所有代码块ctrl shift +
  • 主要介绍了java 代码块与静态代码块加载顺序的相关资料,需要的朋友可以参考下
  • Static静态代码块以及各代码块之间的执行顺序

    万次阅读 多人点赞 2019-10-16 19:56:49
    文章目录代码块的分类1、静态代码块(也叫静态块、静态初始化块)2、构造代码块(也叫构造初始化块)3、代码块(又叫普通代码块、初始化块)执行顺序的代码测试继承中各代码块的执行顺序 代码块的分类 基本上代码...
  • 所谓代码块是指使用“{}”括起来的一段代码。Java有四种代码块, 分别是普通代码块(如方法后大括号中的代码)、构造代码块、静态代码块、同步代码块(与多线程数据安全有关)。 1.静态代码块 使用sta
  • Java—代码块详解

    多人点赞 热门讨论 2021-09-16 20:36:40
    代码块概念代码块分类普通代码块构造代码块静态代码块同步...普通代码块使用不多,这里不过多讲解 构造代码块 也叫:实例代码块 定义在类中的代码块(不加修饰符) 构造代码块一般用于初始化实例成员变量 public class P.
  • MarkDown 代码块

    千次阅读 2020-12-06 16:04:59
    MarkDown 代码块 1、代码行 单行代码引用使用单个符号,反引号(`),就是英文状态下的波浪线。(符号位于 ESC 键下方) `我是代码行` 我是代码行 2、代码块 三个反引号(`)定义段开始和结束 ````# 显示...
  • 主要介绍了Java构造代码块,静态代码块,结合实例形式分析了Java构造代码块,静态代码块的功能、原理、用法及操作注意事项,需要的朋友可以参考下
  • * 加了static的是静态代码块,在类中写了一对{}是构造代码块,在方法中写了一对{}是普通代码块, * java中还有一种代码块是同步代码块,常用在多线程中, synchronized关键字, * 同步代码块格式是:synchronized(同步...
  • 除了说普通代码块,静态代码块,构造代码块的执行顺序外,还有静态方法,静态变量等,都放在一起的话,这个执行顺序,怎么确定。 我就实际弄个代码,看下执行顺序。 public class Line { static { System.out....
  • Java的静态代码块、非静态代码块、构造函数的简单的java代码
  • 执行优先级:静态代码块 > mian方法 > 构造代码块 > 构造方法 废话不多说,我们来介绍一下大家不经常接触到的静态代码块和构造代码块。1. 静态代码块随着类的加载而执行,只执行一次,并优先于主函数执行,是对类...
  • 所谓的代码块是指使用“{}”括起来的一段代码,根据位置不同,代码块可以分为构造代码块、构造函数、静态代码块。 静态代码块staitc声明,jvm加载类时执行,仅执行一次 构造代码块:类中直接 {} 定义,每一...
  • 转自 Java中普通代码块,构造代码块,静态代码块区别及代码示例 //执行顺序:(优先级从高到低。)静态代码块>mian方法>构造代码块>构造方法。 其中静态代码块只执行一次。构造代码块在每次创建对象是...
  • 代码块和静态代码块

    千次阅读 2013-11-30 14:57:36
    类似构造器,一般使用构造器代替代码块的功能。(优先于构造方法执行) 静态代码块: 在类加载期间执行的代码块, 只执行一次。有时候用于加载一次性资源, 如:背景图片   package day04; /** * 代码块: 是在创建...
  • 在Java中,静态代码块、... 在java类中(方法中不能存在静态代码块使用static关键字和{}声明的代码块: 1 2 3 4 5 publicclassCodeBlock { static{ System.out.println(...
  • java-代码块以及代码块执行顺序

    千次阅读 2017-06-24 16:40:44
    代码块{}括起来的代码。 根据{}的位置可以分为 局部代码块:方法中,局部位置,作用:限定...静态代码块:在类中方法外(成员位置),{}括起来,static修饰。作用:给类进行初始化。 代码块执行顺序: 静态代
  • java静态代码块与非静态代码块比较

    千次阅读 2018-10-23 00:20:45
    得出结论1:非静态代码块不会在调用方法与成员时执行.     结论2:非静态代码块在创建实例时...结论4:静态代码块优先非静态代码块优先构造函数,无论如何访问类(实例化,调用函数,成员),都会执行静态代码块 ...
  • 在Java中存在代码块这一结构这一结构又主要分为普通代码块和初始化代码块两类。 一、普通代码块 普通代码块仅出现于方法中,起到分隔不同功能代码的作用,其运行顺序依据代码块出现的先后。 public static void main...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,875,392
精华内容 750,156
关键字:

代码块怎么用