重新开始学习javase_控制程序流程

@学习thinking in java

二、控制程序流程

  1. 负数使用 Java 运算符：
    运算符以一个或多个自变量为基础，可生成一个新值。自变量采用与原始方法调用不同的一种形式，但效果
    是相同的。根据以前写程序的经验，运算符的常规概念应该不难理解。
    加号（+）、减号和负号（-）、乘号（*）、除号（/）以及等号（=）的用法与其他所有编程语言都是类似
    的。
    所有运算符都能根据自己的运算对象生成一个值。除此以外，一个运算符可改变运算对象的值，这叫作“副
    作用”（Side Effect）。运算符最常见的用途就是修改自己的运算对象，从而产生副作用。但要注意生成的
    值亦可由没有副作用的运算符生成。
    几乎所有运算符都只能操作“主类型”（Primitives）。唯一的例外是“=”、“==”和“!=”，它们能操作
    所有对象（也是对象易令人混淆的一个地方）。除此以外，String 类支持“+”和“+=”。
  2. 优先级：个人觉得不必花费力气去记什么优先级，因为能常情况下我们直接用“（）”小括号去定义我们的优先级就可以了
  3. 赋值：

    赋值是用等号运算符（=）进行的。它的意思是“取得右边的值，把它复制到左边”。右边的值可以是任何常
    数、变量或者表达式，只要能产生一个值就行。但左边的值必须是一个明确的、已命名的变量。也就是说，
    它必须有一个物理性的空间来保存右边的值。举个例子来说，可将一个常数赋给一个变量（A=4;），但不可
    将任何东西赋给一个常数（比如不能4=A）。

    1. 　　基本类型：首先我们要知道java内存中对于基本类型的存储是位于栈空间中的，下面看例子：

      @Test
    public void test() {
        int a=12;
        int b;
        b=a;
        a=13;
        System.out.println(b);//12
        /*
         * 这里我们在栈中创建一个a=12,一个b
         * 然后把b=a也就是说b的值也等于a，即12
         * 这个时候把a变成了13，操作的是a
         * b没有影响，故b还是12
         * */
    }
    2. 　　引用类型也就是对象，这也是初学者最容易出错的地方，下面看例子：

      @Test
    public void test01() {
        // 本来想用Integer来做例子的，发现Integer除了new新对象改值，没有什么方法去修改，所以就用Demo1类吧
        // 1.创建Demo对象d1并赋值为12,这里我们要注意的是程序首先在栈中创建一个d1的句柄，然后在堆中new 一个对象，然后这个d1的句柄
        // 指向了这个对象
        Demo1 d1 = new Demo1();
        d1.i = 12;
        // 2.创建Demo对象d2，并让其也具体d1的功能，d1指向对象A，所以d2也指向对象A，
        Demo1 d2 = d1;
        // d1指向的对象A的值改变了
        d1.i = 13;
        // d2指向的对象，即同样的A,所以当然也改变了
        System.out.println(d2.i);// 13
    }

    class Demo1 {
        int i;
    }
    3. String对象的赋值：@学习http://www.cnblogs.com/ITtangtang/p/3976820.html
      • 　　Java内存模型
        对于String常量，它的值是在常量池中的。而JVM中的常量池在内存当中是以表的形式存在的， 对于String类型，有一张固定长度的CONSTANT_String_info表用来存储文字字符串值，注意：该表只存储文字字符串值，不存储符号引用。说到这里，对常量池中的字符串值的存储位置应该有一个比较明了的理解了。在程序执行的时候,常量池会储存在Method Area,而不是堆中。常量池中保存着很多String对象; 并且可以被共享使用，因此它提高了效率
      • 例：这个例子是我在网上看到的比较全的，讲的比较透彻的例子 
        @Test
    public void test04() {
        /**
         * 情景一：字符串池 JAVA虚拟机(JVM)中存在着一个字符串池，其中保存着很多String对象; 并且可以被共享使用，因此它提高了效率。
         * 由于String类是final的，它的值一经创建就不可改变。
         * 字符串池由String类维护，我们可以调用intern()方法来访问字符串池。
         */
        String s1 = "abc";
        // ↑ 在字符串池创建了一个对象
        String s2 = "abc";
        // ↑ 字符串pool已经存在对象“abc”(共享),所以创建0个对象，累计创建一个对象
        System.out.println("s1 == s2 : " + (s1 == s2));
        // ↑ true 指向同一个对象，
        System.out.println("s1.equals(s2) : " + (s1.equals(s2)));
        // ↑ true 值相等
        // ↑------------------------------------------------------over
        /**
         * 情景二：关于new String("")
         *
         */
        String s3 = new String("abc");
        // ↑ 创建了两个对象，一个存放在字符串池中，一个存在与堆区中；
        // ↑ 还有一个对象引用s3存放在栈中
        String s4 = new String("abc");
        // ↑ 字符串池中已经存在“abc”对象，所以只在堆中创建了一个对象
        System.out.println("s3 == s4 : " + (s3 == s4));
        // ↑false s3和s4栈区的地址不同，指向堆区的不同地址；
        System.out.println("s3.equals(s4) : " + (s3.equals(s4)));
        // ↑true s3和s4的值相同
        System.out.println("s1 == s3 : " + (s1 == s3));
        // ↑false 存放的地区多不同，一个栈区，一个堆区
        System.out.println("s1.equals(s3) : " + (s1.equals(s3)));
        // ↑true 值相同
        // ↑------------------------------------------------------over
        /**
         * 情景三： 由于常量的值在编译的时候就被确定(优化)了。 在这里，"ab"和"cd"都是常量，
         * 这行代码编译后的效果等同于： String str3 = "abcd";
         */
        String str1 = "ab" + "cd"; // 1个对象
        String str11 = "abcd";
        System.out.println("str1 = str11 : " + (str1 == str11));
        // ↑------------------------------------------------------over
        /**
         * 情景四： 局部变量str2,str3存储的是存储两个拘留字符串对象(intern字符串对象)的地址。
         *
         * 第三行代码原理(str2+str3)： 运行期JVM首先会在堆中创建一个StringBuilder类，
         * 同时用str2指向的拘留字符串对象完成初始化， 然后调用append方法完成对str3所指向的拘留字符串的合并，
         * 接着调用StringBuilder的toString()方法在堆中创建一个String对象，
         * 最后将刚生成的String对象的堆地址存放在局部变量str3中。
         *
         * 而str5存储的是字符串池中"abcd"所对应的拘留字符串对象的地址。 str4与str5地址当然不一样了。
         *
         * 内存中实际上有五个字符串对象： 三个拘留字符串对象、一个String对象和一个StringBuilder对象。
         */
        String str2 = "ab"; // 1个对象
        String str3 = "cd"; // 1个对象
        String str4 = str2 + str3;
        String str5 = "abcd";
        System.out.println("str4 = str5 : " + (str4 == str5)); // false
        // ↑------------------------------------------------------over
        /**
         * 情景五： JAVA编译器对string + 基本类型/常量 是当成常量表达式直接求值来优化的。
         * 运行期的两个string相加，会产生新的对象的，存储在堆(heap)中
         */
        String str6 = "b";
        String str7 = "a" + str6;
        String str67 = "ab";
        System.out.println("str7 = str67 : " + (str7 == str67));
        // ↑str6为变量，在运行期才会被解析。
        final String str8 = "b";
        String str9 = "a" + str8;
        String str89 = "ab";
        System.out.println("str9 = str89 : " + (str9 == str89));
        // ↑str8为常量变量，编译期会被优化
        // ↑------------------------------------------------------over

    }
      • 补充：
        1. 代码中的字符串常量在编译的过程中收集并放在class文件的常量区中，如"123"、"123"+"456"等，含有变量的表达式不会收录，如"123"+a。
        2. JVM在加载类的时候，根据常量区中的字符串生成常量池，每个字符序列如"123"会生成一个实例放在常量池里，这个实例是不在堆里的，也不会被GC
        3. 在执行到双引号包含字符串的语句时，如String a = "123"，JVM会先到常量池里查找，如果有的话返回常量池里的这个实例的引用，否则的话创建一个新实例并置入常量池里。如果是 String a = "123" + b (假设b是"456")，前半部分"123"还是走常量池的路线，但是这个+操作符其实是转换成[SringBuffer].Appad()来实现的，所以最终a得到是一个新的实例引用，而且a的value存放的是一个新申请的字符数组内存空间的地址(存放着"123456")，而此时"123456"在常量池中是未必存在的。

          要注意: 我们在使用诸如String str = "abc"；的格式定义类时，总是想当然地认为，创建了String类的对象str。担心陷阱！对象可能并没有被创建！而可能只是指向一个先前已经创建的对象。只有通过new()方法才能保证每次都创建一个新的对象

        4. 在执行String a = new String("123")的时候，首先走常量池的路线取到一个实例的引用，然后在堆上创建一个新的String实例，走以下构造函数给value属性赋值，然后把实例引用赋值给a
        5. String对象的实例调用intern方法后，可以让JVM检查常量池，如果没有实例的value属性对应的字符串序列比如"123"(注意是检查字符串序列而不是检查实例本身)，就将本实例放入常量池，如果有当前实例的value属性对应的字符串序列"123"在常量池中存在，则返回常量池中"123"对应的实例的引用而不是当前实例的引用，即使当前实例的value也是"123"。
        6. 存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的 intern()方法就是扩充常量池的 一个方法；当一个String实例str调用intern()方法时，Java 查找常量池中 是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常 量池中增加一个Unicode等于str的字符串并返回它的引用；看示例就清楚了： 
          @Test
    public void test06() {
        String s0 = "kvill";
        String s1 = new String("kvill");
        String s2 = new String("kvill");
        System.out.println( s0 == s1 ); //false
        System.out.println( "**********" );
        s1.intern(); //虽然执行了s1.intern(),但它的返回值没有赋给s1
        s2 = s2.intern(); //把常量池中"kvill"的引用赋给s2
        System.out.println( s0 == s1); //flase
        System.out.println( s0 == s1.intern() ); //true//说明s1.intern()返回的是常量池中"kvill"的引用
        System.out.println( s0 == s2 ); //true

    }
  4. 　算术运算
    • 　　注意优先级（用“()"就能解决）
    • 关于进阶的问题
      • 　　整数与整数运算不存在进阶，直接砍掉小数：例：System.out.println(3/2)//1
    • 　　自动递增和递减（注意++i和i++,前者先运算后用值，后者先用值，用运算

      @Test
    public void test08() {
        int i=0;
        int j=0;
        System.out.println(i++);//先用i所以输出为0
        System.out.println(++j);//先运算后等于1，再打印为1
    }
    • 关系运算符（注意：检查对象是否相等）
    • 逻辑运算符
      • 逻辑运算符 AND（&&）、OR（||）以及 NOT（!）能生成一个布尔值（true 或 false）——以自变量的逻辑关
        系为基础。要注意其优先级的问题，不过本人还是一般用”（）“来搞定这个问题
      • 短路的问题（&）、（｜）其实很简单比如说：A||B||C和A|B|C，如果A正确显示不管B和C是否正确，整个表达式肯定是正确的，前者将不再验证BC的条件，后者却依然进行验证，这称为短路，举个例子：

        @Test
    public void test09() {
        Demo2_1 d = new Demo2_1();
        System.out.println(d.A() || d.B() || d.C());
        System.out.println("**************");
        System.out.println(d.A() | d.B() | d.C());
    }

    class Demo2_1 {
        public boolean A() {
            System.out.println("A");
            return true;
        }

        public boolean B() {
            System.out.println("B");
            return true;
        }

        public boolean C() {
            System.out.println("C");
            return true;
        }

    }
/*
运行结果：
A
true
**************
A
B
C
true

*/
    • 　　按位运算符（就是将任意一个数转化成二进制，然后在二进制的基础上按下面的原则进行计算，注意负数的二进制就是对应正数的反码+1）

      若两个输入位都是1，则按位AND运算符（&）在输出位里生成一个1；否则生成0。若两个输入位里至少有一个是1，则按位OR运算符（|）在输出位里生成一个1；只有在两个输入位都是0的情况下，它才会生成一个0。若两个输入位的某一个是1，但不全都是1，那么按位XOR（^，异或）在输出位里生成一个1。按位NOT（~，也叫作“非”运算符）属于一元运算符；它只对一个自变量进行操作（其他所有运算符都是二元运算符）。按位NOT生成与输入位的相反的值——若输入0，则输出1；输入1，则输出0，例：
    • 移位运算符
      • 　　左移：将二进制码向左移动N格，空白位用0补足，例：

        @Test
    public void test11() {
        int i=3;
        System.out.println(i<<2);//12
    }

      • 右移：将二进制码向右移动N格，空白位用符号位数字补足，即正数用0补，负数用1补，例：

        @Test
    public void test12() {
        int i=3;
        int j=-3;
        System.out.println(i>>2);
        System.out.println(j>>2);
    }

      • 无符号右移（>>>)，针对右移（>>）java中的无符号右移就是改变了右移(>>)中的用符号位填充空白处用0去填充空白处，例：

        @Test
    public void test13() {
        int i=3;
        int j=-3;
        System.out.println(i>>>2);
        System.out.println(j>>>2);
    }

    • 三元 if-else 运算符（个人感觉就是if—else的减化版)　
      布尔表达式 ? 值 0:值 1     例： 
      @Test
    public void test14() {
        int a = 12;
        int b = 10;
        if (a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
        System.out.println("*************");
        System.out.println(a > b ? a : b);
        /*
         * 12
         *************
         * 12
         */
    }
    • 字符串运算符
      运用“String +”时一些有趣的现象。若表达式以一个String起头，那么后续所有运算对象都必
      须是字串
    • 转型(低位与高位加运算,自动向高位转)

二、执行控制

  1. if-else
    if-else 语句或许是控制程序流程最基本的形式。其中的 else 是可选的，所以可按下述两种形式来使用if：
    if(布尔表达式)
    语句
    或者
    if(布尔表达式)
    语句
    else
    语句

    条件必须产生一个布尔结果。“语句”要么是用分号结尾的一个简单语句，要么是一个复合语句——封闭在
    括号内的一组简单语句。在本书任何地方，只要提及“语句”这个词，就有可能包括简单或复合语句。
    作为if-else 的一个例子，下面这个 test()方法可告诉我们猜测的一个数字位于目标数字之上、之下还是相
    等：
    static int test(int testval) {
      int result = 0;
      if(testval > target)
        result = -1;
      else if(testval < target)
        result = +1;
      else
        result = 0; // match
        return result;
    }
    最好将流程控制语句缩进排列，使读者能方便地看出起点与终点。

    • 1. return
      return关键字有两方面的用途：指定一个方法返回什么值（假设它没有 void 返回值），并立即返回那个
      值。可据此改写上面的 test()方法，使其利用这些特点：
      85
      static int test2(int testval) {
        if(testval > target)
          return -1;
        if(testval < target)
           return +1;
           return 0; // match
      }
      不必加上else，因为方法在遇到 return后便不再继续。
  2. 　　循环
      1. 　　while，do-while和 for控制着循环，有时将其划分为“反复语句”。除非用于控制反复的布尔表达式得到
        “假”的结果，否则语句会重复执行下去。while 循环的格式如下：
        while(布尔表达式)
        语句
        在循环刚开始时，会计算一次“布尔表达式”的值。而对于后来每一次额外的循环，都会在开始前重新计算
        一次。
        下面这个简单的例子可产生随机数，直到符合特定的条件为止：

        public class WhileTest {
public static void main(String[] args) {
    double r = 0;
    while(r < 0.99d) {
        r = Math.random();
        System.out.println(r);
    }
  }
} ///:~
      2. do-while
        do-while 的格式如下：

        do
        语句
        while(布尔表达式)

        while 和do-while 唯一的区别就是do-while肯定会至少执行一次；也就是说，至少会将其中的语句“过一
        遍”——即便表达式第一次便计算为false。而在 while 循环结构中，若条件第一次就为false，那么其中的
        语句根本不会执行。在实际应用中，while 比 do-while 更常用一些。

      3. for

    for(初始表达式; 布尔表达式; 步进)语句

      • 　要学习for中的执行顺序：

        @Test
    public void test() {
        for (int i = getI(); i < getJ(); i = IJaJa(i)) {
            System.out.println("****************");
        }
        /*
         * 分析：首先执行语句之前初始表达式（这个过程只执行一次）故先打印一个"getI()"
         * 然后，判断条件，满足打印一个"getJ()"，满足就执行语句块打印************** 再然后，步进，打印一个“i++"
         * 再然后，判断条件，满足打印一个"getJ()"，满足就执行语句块打印************** 再然后，步进，打印一个“i++"
         * 再然后，判断条件，不满足，则结束程序
         */

    }

    public int getI() {
        System.out.println("getI()");
        return 0;
    }

    public int getJ() {
        System.out.println("getJ()");
        return 2;
    }

    public int IJaJa(int i) {
        System.out.println("i++");
        return ++i;
    }

        其实等效下列的语句：

        @Test
    public void test01() {
        int i=0;
        while(i<2){
            System.out.println("************");
            ++i;
        }
    }

        这是for例子的结果：

        getI()
getJ()
****************
i++
getJ()
****************
i++
getJ()
      • 　无论初始表达式，布尔表达式，还是步进，都可以置空。
        其实知道了for的执行顺序之后，相信应该明白，当for循环全部置空就是无限循环了
      • for循环中的无论初始表达式，布尔表达式，还是步进可以为多个条件，例：

        @Test
    public void test02() {
        for(int i=0,j=0;i<2&&j<1;i++,j++){
            int count=1;
            System.out.println("******count: "+count);//******count: 1
            count++;
        }
    }
  3. 　　循环的中断(对while和for通用，这里仅用for举例)
    • 　　用break 和continue 控制循环的流程

      • 　　break:中断当前循环，例：

        @Test
    public void test03() {
        for(int i=0;;){//这是一个无限循环
            System.out.println(i++);
            if(i>1)//当i>1的时候终止当前循环，注意if可不是循环
                break;//所以输出0，1
        }
    }
      • continue:忽略循环体后面的内容，继续进行循环体：

        @Test
    public void test04() {
        for(int i=0;;){//这是一个无限循环
            i++;
            if(i<2)//当i<2的时候，注意if可不是循环
                continue;//不再后面的的内容，再次循环，所以执行下面的语句
            System.out.println(i);//2
            if(i>=2)
                break;

        }
    }
    • 　　使用“标签”配合continue和break：

      “标签”是后面跟一个冒号的标识符，就象下面这样：
      label1:
      对Java 来说，唯一用到标签的地方是在循环语句之前。进一步说，它实际需要紧靠在循环语句的前方——在
      标签和循环之间置入任何语句都是不明智的。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另
      一个循环或者一个开关。这是由于 break和 continue 关键字通常只中断当前循环，但若随同标签使用，它们
      就会中断到存在标签的地方。如下所示：

      label1:
      外部循环{
      内部循环{
      //...
      break; //1
      //...
      continue; //2
      //...
      continue label1; //3
      //...
      break label1; //4
      }
      }

      在条件1 中，break 中断内部循环，继续外部循环。在条件2 中，continue 移回内部循环的起始处。但
      在条件3 中，continue label1 却同时中断内部循环以及外部循环，并移至label1 处。随后，它实际是继续
      循环，但却从外部循环开始。在条件4 中，break label1也会中断所有循环，并回到label1 处，但并不重
      新进入循环。也就是说，它实际是完全中止了两个循环。
      下面是for 循环的一个例子：

          @Test
    public void test06() {
        int i = 0;
        outer: // 标签要紧邻着循环
        for (; true;) { // 这是个无限循环
            inner: // 标签要紧邻着循环
            for (; i < 10; i++) {
                prt("i = " + i);// static void prt(String s)
                                // {System.out.println(s);}
                if (i == 2) {
                    prt("continue");
                    continue;
                }
                if (i == 3) {
                    prt("break");
                    i++; // i增加的语句不能放break后面，不然永远不会得到增加
                    break;
                }
                if (i == 7) {
                    prt("continue outer");
                    i++; // i增加的语句不能放break后面，不然永远不会得到增加
                    continue outer;
                }
                if (i == 8) {
                    prt("break outer");
                    break outer;
                }
                for (int k = 0; k < 5; k++) {
                    if (k == 3) {
                        prt("continue inner");
                        continue inner;
                    }
                }
            }
        }
        /*
         * i = 0 continue inner i = 1 continue inner i = 2 continue i = 3 break
         * i = 4 continue inner i = 5 continue inner i = 6 continue inner i = 7
         * continue outer i = 8 break outer
         */
    }

    static void prt(String s) {
        System.out.println(s);
    }

      如果没有break outer 语句，就没有办法在一个内部循环里找到出外部循环的路径。这是由于break 本身只
      能中断最内层的循环（对于continue 同样如此）。
      当然，若想在中断循环的同时退出方法，简单地用一个return 即可。
      备注：其实吧，这种也不推荐使用，我们完成可以做个flag来控制循环，达到同样的效果

  4. 　　switch

    switch(整数选择因子) {
    case 整数值1 : 语句; break;
    case 整数值2 : 语句; break;
    case 整数值3 : 语句; break;
    case 整数值4 : 语句; break;
    case 整数值5 : 语句; break;
    //..
    default:语句;
    }
    要注意的是这里的break不能少，少了break不会报错，会一直往下执行

    • 　　在Java7之前，switch只能支持 byte、short、char、int或者其对应的封装类以及Enum类型。在Java7中，呼吁很久的String支持也终于被加上了。例：

      @Test
    public void test07() {
        String a="a";
        switch(a){
        case "b" :
        case "a" : System.out.println("a"); break;//a
        default  :System.out.println("**");
        }
    }

      注意这里的String a不能为空，代码的原理其实是根据String的hashCode来匹配的，String 为null ,String.hashCode必然会报空指针异常

　　

　

时间： 2024-10-30 13:29:11

重新开始学习javase_控制程序流程的相关文章

C++学习 之 控制程序流程

1.使用if...else有条件的执行 在一些时候语句需要进行有条件的执行.比如如果输入"Y"就执行赋值语句N=1:否则N=0: #include<iostream> using namespace std; int main () { char Judge='N'; int N; cin>>Judge; if(Judge=='Y') { N=1; }//if条件下一条语句时{}可省略,此处给出 else { N=0; } cout<<N<&l

控制程序流程

我叫鱼汤,是一名菜鸡.如有高手路过,望指点.望传功. 这一篇是要整理我的三份笔记,主要内容就是java里几个简单的控制程序流程的方法,程序自然执行顺序是由上而下依次执行,但是有时这样达不到我们想要的目的,这里就会用到流程控制的方法. 一.选择 1. 单分支if语句 if(布尔表达式){ //布尔表达式为true时所执行的语句: } 如果()里的条件得到满足,{}里的语句才回执行,主要用于只有一个筛选要求. 2. 双分支if语句 if(布尔表达式) { //布尔表达式为true时所执行的语句: }

4.JAVA编程思想——控制程序流程

欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/51040228 控制程序流程 在Java 里,我们利用运算符操纵对象和数据,并用执行控制语句作出选择.Java 是建立在C++基础上的,所以对C 和C++程序员来说,对Java 这方面的大多数语句和运算符都应是非常熟悉的.当然,Java 也进行了自己的一些改进与简化工作. 1      使用 Java 运算符 加号(+).减号和负号(-).乘号(*).除号(/)以及等号(=)的

TinyOS学习：安装流程

还是记一下TinyOS的安装 第一步:安装java jdk,请移步:http://www.oracle.com/technetwork/java/javase/downloads/index.html下载 尽量下载1.6版本吧..别太新就行.我用的1.7 台式机用的1.6都是可以用的 配置jdk很简单了,解压到/usr/lib/jvm文件夹下,(没有就新建).然后配置环境变量 配置到.bashrc或者/etc/profile下 最后添加: #====================jdk pro

读TIJ -3 控制程序流程

<Think in java·第 3 章控制程序流程> 这一章应该不会涉及"思想",<编程导论(Java)·0.2.2 操作符和操作数>后,将相关内容压缩成一节<第3章功能抽象·3.2实现>. 3.1 使用Java 运算符 副作用(side effect):[p98:副作用一般是针对操作(表达式)而言的,一个操作/表达式有"副作用"是指在对该表达式求值时,会改变程序的一个或多个数据,以致再次对该表达式求值时,可能会得出不同的结果.

控制程序流程（2）

3.2 执行控制   Java使用了C的全部控制语句,所以假期您以前用C或C++编程,其中大多数都应是非常熟悉的.大多数程序化的编程语言都提供了某种形式的控制语句,这在语言间通常是共通的.在Java里,涉及的关键字包括if-else.while.do-while.for以及一个名为switch的选择语句.然而,Java并不支持非常有害的goto(它仍是解决某些特殊问题的权宜之计).仍然可以进行象goto那样的跳转,但比典型的goto要局限多了. 3.2.1 真和假 所有条件语句都利用条件表达式的

Android Camera fw学习(四)-recording流程分析

Android Camera fw学习(四)-recording流程分析 备注:备注:本文是Android5.1学习笔记.博文按照软件启动流程分析.  且行且惜,一步一个脚印,这次学习camera Video.虽然标题是recording流程分析,但这里很多和preview是相似的(包含更新,创建Stream,创建Request),这里主要分析MediaRecorder对象创建.video帧监听对象注册.帧可用事件以及一系列callback流程分析. 一.认识video(mediaRecorde

《21天学会C++》学习笔记第7章控制程序流程

1.迭代意味着重复做同样的工作.迭代的主要方法是循环. 2.while()循环,do...while()循环,for循环, 3.注意do...while()循环的do是真的要出现的,不仅仅是一个标志而已: 1 #include<iostream> 2 int main() 3 { 4 using namespace std; 5 int counter; 6 cout<<"how many hellows"; 7 cin>>counter; 8 do

oVirt (Open Virtual) 之 VDSM 学习笔记 (二) 流程追踪

概述: 追踪 VDSM 启动后的代码大概流程,是继 vdsm/vdsm 文件学习后的继续. Let's go! 从 “def serve_clients(log)” 开始 1 def serve_clients(log): 2 cif = None 3 irs = None 4 scheduler = None 5 running = [True] 6 7 def sigtermHandler(signum, frame): 8 log.debug("Received signal %s&quo