Java基础知识(2)

4.操作符
操作优先级结合性
后缀运算符[] . () 函数调用从左到右
单目运算符! ~ ++ -- +(单操作符) -(单操作符)从右到左
创建new从左到右
乘除* / %从左到右
加减+ -从左到右
移位<< >> >>>从左到右
关系< <= > >= instanceof从左到右
相等== !=从左到右
按位与&从左到右
按位异或^从左到右
按位或|从左到右
逻辑与&&从左到右
逻辑或||从左到右
条件? :从右到左
赋值= += -= *= /= %= ^= <<= >>= >>>=从右到左
  几乎所有运算符都只能操作“基本类型”(Primitives),只是=、==、!=可以操作所有对象,除此String类型可以支持+、+=操作符:
  i.赋值操作符:
  一般情况下基本类型可以直接使用=进行赋值操作,看简单的一份代码
package org.susan.java.basic;
/**
 *赋值操作符的使用
 **/
public class AssignMain {
    public static void main(String args[]){
        int i = 5;
        int j = 10;
        i += 5;
        j -= 2;
        System.out.println("i = " + i);
        System.out.println("j = " + j);
    }
}
  这段代码的输出为:
i = 10
j = 8
  赋值操作符一般使用=或者带操作的=进行,带操作的等号比如上边使用的+=、-=等。针对数值操作符而言:
i += b; 等价于 i = i + b;
  所以可以理解上边的两句话:
i += 5;
j -= 2;
  这种操作符就是带操作的赋值,这里需要说明的主要是赋值操作符=
  [1]针对原始类型的=操作符而言,比如a=b【a和b为两个变量】,在赋值的过程里面,这句话进行了下边的操作:JVM在内存里面为b保存一个栈地址用来存储真实的b的值,然后在赋值过程中,JVM创建一个b的副本,然后把b的副本的值赋值到a里面,也就是说在这种情况下如果a的值发生了变化的话,b本身的值是不会受到影响的,而b在赋值过程的副本也是瞬间的,当a一旦接受到b的值过后,b的副本就从内存里面清除掉,就使得a和b各自有了自己的栈地址
  [2]如果是非原始类型:比如有两个对象的引用a和b,如果进行了a=b的操作,这句话就进行了下边的操作:JVM会拷贝一个b的引用,然后把引用副本赋值到a,使得a引用和b引用指向同一个对象,a引用的对象发生改变的时候,b引用指向的对象也会发生同样的改变
  ——[$]一个赋值的概念说明例子——
package org.susan.java.basic;
/**
 *针对赋值符号的概念说明代码,主要是区分上边的不同类型进行赋值操作
 **/
public class AssignObject {
    public static void main(String args[]){
        // Primitives类型
        System.out.println("--------------------");
        int bNumber = 1;
        int aNumber = bNumber;
        System.out.println("Before assign aNumber is " + aNumber);
        System.out.println("Before assign bNumber is " + bNumber);
        aNumber = 12;
        System.out.println("After assign aNumber is " +aNumber);
        System.out.println("After assign bNumber is " + bNumber);

        // Reference类型
        System.out.println("--------------------");
        StringBuffer bBuffer = new StringBuffer("b");
        StringBuffer aBuffer = bBuffer;
        System.out.println("Before assign aBuffer is " + aBuffer);
        System.out.println("Before assgin bBuffer is " + bBuffer);
        aBuffer.append(" assign a");
        System.out.println("Before assign aBuffer is " + aBuffer);
        System.out.println("Before assgin bBuffer is " + bBuffer);
    }
}
  上边程序的输出为:
--------------------
Before assign aNumber is 1
Before assign bNumber is 1
After assign aNumber is 12
After assign bNumber is 1
--------------------
Before assign aBuffer is b
Before assgin bBuffer is b
Before assign aBuffer is b assign a
Before assgin bBuffer is b assign a
  【*:上边的程序输出刚好说明了上边的两点内容,这里有一点需要注意的是,在使用引用赋值的时候,所说的修改引用指代对象的内容的时候,这里不能使用String类型,因为使用了String类型就会出现很特殊的情况,这一点在String的说明里面我会特别讲述,需要重视的一点是:修改对象内容。这里针对StringBuffer而言,append方法就修改了StringBuffer对象的内容,所以这个程序这样说明是没有问题的,这里再次提醒一下:String类型的对象属于不可变对象,在针对不可变对象的时候,修改对象内容的原理和可变对象修改对象内容的原理不一样的,所以这里不能使用String,演示的代码使用的是StringBuffer。】
  简单总结:
  • leftVarl op= rightVal格式的表达式等同于leftVal = leftVal op rightVal
  • 原始类型赋值操作和引用类型的赋值操作有本质的区别
  • 可变对象不可变对象对内容的更改本质也不一样的
  ii.算术运算符:
  Java的算数运算符:+、-、/、*、%,优先级【仅针对算术运算符】:
  [1]/、*、%是第一优先级的,这三个操作符的运算是从左到右
  [2]+、-操作符是第二优先级的,其运算也是从左到右
  ——[$]浮点取模、整数取模——
package org.susan.java.basic;
/**
 *普通运算的优先级,整数取模和浮点取模
 **/
public class NumberOpTester {
    public static void main(String args[]){
        int a = 2;
        int b = 4;
        int c = 3;
        int result = c + b / a;
        System.out.println("c + b / a = " + result);
        result = c * b / a;
        System.out.println("c * b / a = " + result);

        double b1 = 4.5f;
        double a1 = 2;
        double result1 = b1 % a1;
        System.out.println(" b % c = " + (b % c));
        System.out.println(" b1 % a1 = " + result1);
    }
}
  上边的输出为:
c + b / a = 5
c * b / a = 6
b % c = 1
b1 % a1 = 0.5
  根据上边的运算符,需要说明一点:
  在Java运算符里面,不仅仅像C++一样支持整数取模,而且还支持浮点类型的取模,就像上边的最后一个表达式result1 = b1 % a1,就是进行的浮点取模操作;而运算符的优先级,上边代码已经一目了然了这里就不重复了
  iii.自动递增、递减运算:
  Java和C++一样存在前递增和前递减(++A和--A),这种情况先进行运算,再生成值;后递增和后递减(A++和A--),会先生成值,再执行运算;因为++和--操作一样,所以提供一段说明代码:
package org.susan.java.basic;
/**
 *自动递增递减的代码示例
 **/
public class AutoIncreasement {
    public static void main(String args[]){
        int i = 3;
        int j = 3;
        System.out.println("++i:" + (++i));
        System.out.println("j++:" + (j++));
        System.out.println("i:" + i);
        System.out.println("j:" + j);
        
        System.out.println(i==(i++));
        System.out.println(i==(++i));

        float floatValue = 0.3F;
        System.out.println(floatValue++);
        System.out.println(floatValue);
    }
}
  上边代码的输出为:
++i:4
j++:3
i:4
j:4
true
false
0.3
1.3
  需要说明的是:A++A = A + 1是等效的,++A最终执行效果 A = A + 1也是等效的,二者只有一个最简单的区别,上边代码可以看出来
  [1]前递增(递减)和后递增(递减)就是上边表达的那种情况,但是有一点特殊就是前递增(递减)是先改变变量的值,而后递增(递减)是在进行运算过后修改变量的值
  [2]而且在Java里面,自动递增递减是支持浮点类型的,最后那一些代码可以说明这一点
  注意:可以这样来理解,i,i++,++i代表三个不同的变量,如果i的值是a,那么i++本身的值是在递增之前返回的,i++的判断是和i一样的,而++i本身的值是在递增之后返回的,++i和i的判断却是不一样的,所以这里应该理解的是变量是什么时候进行更改的。主要参考上边的代码:
System.out.println(i==(i++));
System.out.println(i==(++i));
  根据这段代码的输出就可以知道(更改变量的时间)在自增自减的运算中的重要性了,提供一个更加迷惑的例子:
package org.susan.java.basic;
/**
 *一个比较迷惑的自增自减的例子
 **/
public class AutoIncreaseMain {
    public static void main(String args[]){
        int i = 4;
        int j = 6;
        int result = i+++ ++j + i+++ ++i + i + ++i;
        System.out.println("result:" + result);
        int a = 5;
        int result1 = a+++a+++a+++a++;
        System.out.println("result1:" + result1);
    }
}
  先看输出:
result:38
result1:26
  仔细分析一下上边的输出:
  在分析过程模拟一个堆栈,把每次的结果都压入堆栈进行运算:
  第一个表达式result的结果:
  [1]最先压入栈的是i++,这个地方i的值为4,那么i++返回值就是4,但是运算过后i的值变成了5结果为:4 +
  [2]然后压入栈的是++j,这个地方j的值为6,那么++j返回值就是7,但是运算过后同样使得j变成了7结果为:4 + 7 +
  [3]然后压入栈的同样是i++,但是这个时候i的值为5,那么i++也是5,运算过后i的值变成了6结果为:4 + 7 + 5 +
  [4]按照这种方式运算下去,最终的结果是:4 + 7 + 5 + 7 + 7 + 8,所以result的值为38
  按照同样的方式可以运算result1的结果:result1的最终结果为26;至于这种操作的表达式写法有一定的规则,下边的是合法和不合法的例子:
  合法的写法
i+++ ++i;
i+++i++;
i+ ++i;
i+++i;
i++ +(++i);
  不合法的写法
i+++++i;
i++ +++i;
  至于其他的写法对与不对可以直接在Eclipse里面进行编译来判断表达式的正确与否
  iv.关系运算符:
  关系运算符包括<、>、<=、>=、==、!=:
  关于关系运算符需要说明的是:
  • ==和!=是适合所有的基本类型(Primitives)的,但是其他关系运算符不能比较boolean
  • 如果是针对两个引用指向的对象内容进行比较,必须用特殊的操作方法equals()
  • ==和!=在比较两个引用的时候,比较的是引用的指向,而不是对象的内容信息
  ——[$]仅提供一个例子说明——
package org.susan.java.basic;

public class CompareMain {
    public static void main(String args[]){
        int i = 4;
        System.out.println((i==4));
        System.out.println((i!=4));
        System.out.println((i >= 3));
        System.out.println((i < 4));
        System.out.println((i > 6));
        System.out.println((i <= 4));
    }
}
  上边的输出为:
true
false
true
false
false
true
  v.逻辑运算符和按位运算符:
  逻辑运算符有&&、||、!能够结合表达式生成一个boolean返回值
  按位运算符AND(&)、OR(|)、XOR(^)、NOT(~)运算
下边是所有的逻辑关系表:
非关系表:
A!A
truefalse
falsetrue
逻辑与关系:
ABA && B
falsefalsefalse
truefalsefalse
falsetruefalse
truetruetrue
逻辑或关系:
ABA || B
false false false
truefalsetrue
false truetrue
truetruetrue
下边是按位运算关系表:
非位运算符:
A~A
10
01
与位运算符:
ABA & B
111
100
010
000
或位运算符:
ABA | B
111
101
011
000
异或运算符:
ABA ^ B
110
101
011
000
  关于逻辑运算符一定要理解的是“短路”现象,比如下边的表达式:
if( 1==1 && 1==2 && 1==3)
  代码从左到右开始执行,指定第一个表达式1==1是为true,因为是为true,然后就开始运算1==2,运算了第二个表达式过后结果如下:
true && false && 1==3
  到了这个时候就不再运算下去了,因为在这种运算里面第二个表达式为false,这种情况就短路了,因为不论最后一个表达式为什么,最终返回就已经是false,短路现象在&&和||中都是常见的,只有逻辑关系运算符存在短路现象,位逻辑运算符中是不存在短路现象
  ——[$]提供一个运算的例子——
package org.susan.java.basic;

public class ShortTruFalseTester {
    public static void main(String args[]){
        boolean a = true;
        boolean b = false;
        System.out.println(!a);
        System.out.println(a && b);
        System.out.println(a || b);

        int aNumber = 15;
        int bNumber = 5;
        System.out.println(aNumber & bNumber);
        System.out.println(aNumber | bNumber);
        System.out.println(aNumber ^ bNumber);
        System.out.println(~aNumber);
    }
}
  输出为:
false
false
true
5
15
10
-16
  逻辑运算符这里不做任何解释,但是另外三个计算机底层的位运算符是需要简单解释一下:
aNumber=15中,aNumber转换成为二进制位为:1111
bNumber=5中,bNumber转换成为二进制位为:0101
  1111&0101的结果每一位进行&运算可以得到1111&0101=0101,运算规则就为每一位1&1=1,1&0和0&1为0,0&0=0,最后结果转换为0101=5
  1111|0101的结果是每一位进行|运算1111|0101=1111,运算规则为1|1=1,1|0=1和0|1=1,0|0=0,最后结果为1111=15
  1111^0101的结果是每一位进行^运算1111^0101=1010,运算规则为1^1和0^0为0,1^0和0^1为1,最后结果为1010=10
  ~aNumber在这个地方相对复杂:
其实在32bit系统中,aNumber的真实数值为:
0000 0000 0000 0000 0000 0000 0000 1111
按位运算结果为:
1111 1111 1111 1111 1111 1111 1111 0000
转化成为数值就为:-16
  vi.三元操作符:
  三目运算符是一个特殊的运算符,它的语法形式如下:
  布尔表达式?表达式1:表达式2
  运算过程,如果布尔表达式的值为true就返回表达式1的值,如果为false返回表达式2的值,简单用一个例子说明:
package org.susan.java.basic;
/**
 *三元操作符
 **/
public class ThirdMain {
    public static void main(String args[]){
        int sum = 90;
        String resultValue = (sum > 90)?"Bigger than 90":"Smaller than 90";
        String resultValue1 = (sum < 100)?"Smaller than 100":"Bigger than 100";
        System.out.println(resultValue);
        System.out.println(resultValue1);
    }
}
  输出结果为:
Smaller than 90
Smaller than 100
  vii.移位运算符:
  移位运算符操作的对象是二进制位,可以单独用移位运算符来处理int类型的整数,下边是概念表:
运算符含义例子
<<左移运算符,将运算符左边的对象向左异动运算符右边指定的位(在低位补0)x << 3
>>"有符号"右移运算 符,将运算符左边的对象向右移动运算符右边指定的位数。使用符号扩展机制,也就是说,如果值为正,则在高位补0,如果值为负,则在高位补1。x >> 3
>>>"无符号"右移运算 符,将运算符左边的对象向右移动运算符右边指定的位数。采用0扩展机制,也就是说,无论值的正负,都在高位补0。x >>> 3
  1)计算机里面的原码、反码、补码
  在计算机里面所有的数据都是按照字节来存储的,1个字节等于8位(1Byte=8bit),而计算机只能识别0和1,所以根据排列,1个字节可以存储256种不同的信息,就是28(0和1两种可能,8位排列),比如定义一个字节大小的无符号整数,那么表示的就是0~255(0~28-1),这些数一共是256个数。这里只是标识了一个无符号的整数,那么需要进一步剖析这个数,0是这些数字中最小的一个:00000000,在计算机里面,无符号整数就是这样的方式来进行整数的存储,也就是说如果知道了一个无符号整数的二进制码就可以直接计算该整数的值了。而计算机里面有两外一种存储整数的方式,这种方式是针对有符号的整数而言的。
  只有有符号的整数才有原码、反码和补码,其他的类型一概都没有,而且不需要。虽然我们也可以用二进制中最小的数去对应最小的负数,最大的也对应最大的,但是那样不科学,计算机本身却不使用这样的方式,二是有另外的存储方式。如果1个字节不管怎样还是只能标识256位,那么带符号的整数就应该是:-128~127,这种情况在计算机里面怎么存储呢?其实该字节的最高位是符号位,比如:
0 1111111
  在上边的8位里面,最高位是0,代表的是符号位,在计算机里面0代表+,1代表-,这样的存储就可以知道实际只有255个数。那么计算机的存储原理是什么呢?
  可以这样理解,用最高位表示符号位,如果是0表示正数,如果是1表示负数,剩下的7位用来储存数的绝对值的话,能表示27个数的绝对值,再考虑正负两种情况,27*2还是256个数。首先定义0在计算机中储存为00000000,对于正数我们依然可以像无符号数那样换算,从00000001到01111111依次表示1到127。那么这些数对应的二进制码就是这些数的原码。到这里很多人就会想,那负数是不是从10000001到11111111依次表示-1到-127,那你发现没有,如果这样的话那么一共就只有255个数了,因为10000000的情况没有考虑在内。实际上,10000000在计算机中表示最小的负整数,就是这里的-128,而且实际上并不是从10000001到11111111依次表示-1到-127,而是刚好相反的,从10000001到11111111依次表示-127到-1。负整数在计算机中是以补码形式储存的,补码是怎么样表示的呢,这里还要引入另一个概念——反码,所谓反码就是把负数的原码除符号位(负数的原码除符号位和它的绝对值所对应的原码相同,简单的说就是绝对值相同的数原码相同)各个位按位取反,是1就换成0,是0就换成1,如-1的原码是0000001(注意这里只有7位,不看符号位,我这里所说的负数符号位都是1),和1的原码相同,那么-1的反码就是1111110(这也是7位,后面加上了符号位都是8位了),而补码就是在反码的基础上加1,即-1的补码是11111110+1=11111111,因此我们可以算出-1在计算机中是按11111111储存的。总结一下,计算机储存有符号的整数时,是用该整数的补码进行储存的,0的原码、补码都是0,正数的原码、补码可以特殊理解为相同,负数的补码是它的反码加1。
  举个简单的例子:
有符号的整数原码反码补码
47001011110010111100101111(正数补码和原码、反码相同,不能从字面的值进行理解)
-47101011111101000011010001(负数补码是在反码上加1)
  简单讲:
  整数的补码和原码相同
  负数的补码则是符号位为“1”,数值部分按位取反过后在末位加1,也就是“反码+1”
  【*:这里只是简单介绍一下计算机存储的码,如果读者需要更加详细的资料,可以去查阅,这里讲这些是为了方便初学者能够理解Java里面的移位运算符】
  2)移位运算例子
  这里提供简单的例子:

-5>>3=-1
1111 1111 1111 1111 1111 1111 1111 1011
1111 1111 1111 1111 1111 1111 1111 1111
其结果与 Math.floor((double)-5/(2*2*2)) 完全相同。

-5<<3=-40
1111 1111 1111 1111 1111 1111 1111 1011
1111 1111 1111 1111 1111 1111 1101 1000 
其结果与 -5*2*2*2 完全相同。

5>>3=0
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0000 0000
其结果与 5/(2*2*2) 完全相同。

5<<3=40
0000 0000 0000 0000 0000 0000 0000 0101
0000 0000 0000 0000 0000 0000 0010 1000
其结果与 5*2*2*2 完全相同。

-5>>>3=536870911      
1111 1111 1111 1111 1111 1111 1111 1011
0001 1111 1111 1111 1111 1111 1111 1111

无论正数、负数,它们的右移、左移、无符号右移 32 位都是其本身,比如 -5<<32=-5、-5>>32=-5、-5>>>32=-5。
一个有趣的现象是,把 1 左移 31 位再右移 31 位,其结果为 -1。
0000 0000 0000 0000 0000 0000 0000 0001
1000 0000 0000 0000 0000 0000 0000 0000
1111 1111 1111 1111 1111 1111 1111 1111

  小结:到这里基本的Java运算符就已经讲完了,唯一没有讲到的就是instanceof操作符以及关于String的一些操作符,instanceof已经在《类和对象》章节里面讲到了,而String的操作会在String的专程章节里面讲述。


5.控制流程
  Java程序和普通程序运行流程一样,有三种运行顺序:顺序、循环和选择,接下来介绍以下Java里面的这三种程序运行流程【本章节的概念代码可能更加基础,而且这一小节不讲保留字goto】:
  1)顺序运行:
  顺序运行是最简单的Java程序,基本不需要任何关键字就可以操作,提供一段简单的代码读者就可以明白了:
package org.susan.java.basic;

public class CommonFlow {
    public static void main(String args[]){
        System.out.println("Step One");
        System.out.println("Step Two");
        System.out.println("Step Three");
    }
}
  上边的输出这里就不列出了,它会按照顺序打印Step One——>Step Two——>Step Three
  2)选择运行:
  选择运行需要使用到Java里面的条件语句,条件语句主要包括:
  [1]if语句;
  [2]if...else语句;
  [3]switch语句:
  if语句:
  if语句的语法有两种:
  if(boolean表达式) 语句1;
  if(boolean表达式){ 语句1;语句2;}
  它所意味着的含义为如果boolean表达式的返回为true就执行语句1或者执行语句1所在的语句块{}内的内容:
package org.susan.java.basic;

import java.util.Random;

public class IfSingleMain {
    public static void main(String args[]){
        Random random = new Random();
        int result = random.nextInt(3);
        if( result == 2){
            System.out.print("This is if block,");
            System.out.println("Test block flow.");
        }
        if( result == 1)
            System.out.println("This is if single flow.");
            System.out.println("This is Inner or Outer."); //这句的写法是故意的
        System.out.println("Main flow.");
    }
}
  上边这段代码的输出是不固定的,主要是看result返回的值是多少,它会随机生成三个整数值:1、2、3
  result值为2的时候直接是块语句,所以不需要讲解什么,但是需要知道if还支持直接的不带块的语句,所以不论任何值生成,都会有下边这两句输出:
This is Inner or Outer.
Main flow.
  这里提醒读者的只有一个关键点:在使用if语句的时候,如果后边的语句块不带{},那么它能产生的效果只有紧跟着if的后边一句话(单条语句),这种情况下,其他的语句都会视为和if无关的语句
  if-else语句
  该语句的语法为:
  if(布尔表达式1)
  {语句执行块1}
  else if(布尔表达式2)
  {语句执行块2}
  else
  {语句执行块3}
  针对该语句,简单修改一下上边的程序:
package org.susan.java.basic;

import java.util.Random;

public class IfSingleMain {
    public static void main(String args[]){
        Random random = new Random();
        int result = random.nextInt(3);
        if( result == 2){
            System.out.print("This is if block,");
            System.out.println("Test block flow.");
        }else if( result == 1){
            System.out.println("This is if single flow.");
            System.out.println("This is Inner or Outer."); 
        }else {
            System.out.print("This is other flow.");
            System.out.println("This is single else flow."); 
        }
        System.out.println("Main flow.");
    }
}
  这是一个简单的if-else语句,这里只用了else的块语句,没有使用else的单条语句,如果使用else的单条语句,和if是一样的规则:
  如果result随机生成的值是0【*:这个地方result只可能有三个值就是0,1,2】,就会得到下边的结果:
This is other flow.This is single else flow.
Main flow.
  如果去掉最后一个else后边的{}后会有什么效果呢,去掉了最后一个括号过后,下边的语句不论result为任何值的时候都会输出:
This is single else flow.
Main flow.
  原因和if语句一样,如果紧随其后的不是{}的语句块,只能影响一行完整的语句,也就是当去掉上边代码最后一个else后边的{}过后,else只能影响语句:
System.out.print("This is other flow.");
  switch语句:
  该语句的语法为:
  switch(输入因子){
  case 匹配因子1:{执行语句块1;}break;
  caes 匹配因子2:{执行语句块2;}break;
  default:{执行语句块3;}break;
  }
  当编程过程需要多个分支语句的时候,就需要使用到switch语句,也就是进行多项选择的语句,这里同样提供一个概念说明例子:
package org.susan.java.basic;

import java.util.Random;

public class SwitchTester {
    public static void main(String args[]){
        Random random = new Random();
        int result = random.nextInt(4);
        switch (result) {
        case 1:
            System.out.println("Result is 1");
            break;
        case 2:
            System.out.println("Result is 2");
        case 3:
            System.out.println("Result is 3");
            break;
        default:
            System.out.println("Result is 4");
            break;
        }
    }
}
  当result的值为各种值的时候输出为:
Result is 1【*:result的值为1的输出】
Result is 2
Result is 3【*:result的值为2的输出】
Result is 3【*:result的值为3的输出】
Result is 4【*:result的值为0的输出】
  针对switch语句有几点需要说明:
  • switch后边的括号里面的输入因子有类型限制的,只能为:
    [1]int类型的变量
    [2]short类型的变量
    [3]char类型的变量
    [4]byte类型的变量
    [5]enum的枚举类型的变量【
    JDK1.5过后支持】
    其他的变量都是不能传入switch的输入因子的
  • 关于case语句的一点点限制:
    [1]case语句后边必须是一个整型的常量或者常量表达式
    [2]如果使用常量表达式,表达式中的每个变量,必须是final
    [3]case后边不能是非final的变量,比如使用一个case val这种情况将会直接通不过编译,因为val不是final类型的变量,只是一个普通变量
    [4]case后边的常量和常量表达式不能使用相同的值
  • 关于语句的执行顺序:
    当接收到合法的输入因子过后,JVM会去寻找和系统输入因子匹配的case语句,如果没有任何一个case语句匹配的话就直接执行default语句;当匹配到case语句过后,会执行该case到紧接着代码里面写的该case的下一个case之间的语句块,一旦执行完该语句块过后,如果没有遇到return或者break就继续执行下一个case,执行的流程和该case的执行流程是一样的,知道碰到最终的case为止。所以就可以理解为什么上边的代码当result的值为2的时候会输出:
    Result is 2
    Result is 3
  【*:这里思考一个问题,如果把default语句写在case语句的前边会发生什么情况呢?稍稍改动一下上边的代码,就会发现其实default的位置不重要关键是最终满足的case是否能够匹配,可以这样认为:当所有case条件都不满足的时候选择执行default里面的语句块,当然前提条件是所有的case语句都跟随了一个break语句。一般编程过程中都是直接使case和break配对出现的,因为一旦case执行完了过后,遇到break语句就直接跳出switch语句块了,不会再执行其他的case,如果没有break,还会继续往下一个case执行。而且需要注意一点,执行完匹配的case而没有遇到break或者return的时候,再往下执行就不需要再匹配case条件了,这个时候不论接下来指定的case是否匹配都会执行下去,也就是说,所有的输入因子在进入switch语句过后只匹配一次。还有一点需要提醒一下,当default放在前面的时候,如果default没有匹配的break语句,同样执行完default对应的语句块过后需要执行紧跟着default下边的case语句块,直到遇到break语句。】
  3)循环运行
  [1]while和do-while循环
  [2]for循环
  [3]中断循环
  while和do-while:
  while循环和do-while循环称为条件循环,也就是循环的终止条件为当判断语句为false的时候就终止循环,while和do-while的区别在于不论条件判断返回false还是true,do-while语句至少执行一次,而while语句必须是当条件返回true的时候才会一次次执行
  语法规则为:
  while(布尔表达式){执行语句块}
  do{执行语句块}while(布尔表达式);
  下边是一个while和do-while循环的例子:
package org.susan.java.basic;

public class WhileLoopMain {
    public static void main(String args[]){
        int i = 4; 
        System.out.println("While loop:");
        while(i < 4){
            System.out.println(i);
            i++;
        }
        i = 4;
        System.out.println("Do While loop:");
        do{
            System.out.println(i);
            i++;
        }while(i < 4);
    }
}
  上边是一个很极端的例子,先看输出,然后再分析结果:
While loop:
Do While loop:
4
  这里可以知道的是在while语句里面,先判断i<4,因为i的初始值是4,所以该条件不成立,所以while语句里面直接跳过语句执行块,不打印任何内容;但是针对do-while语句而言,虽然i的初始值也是4,但是i<4是在进行了一次运行过后才比较的,实际上细心的读者会发现,两个循环返回false的条件不一样。第一个while语句是因为4<4返回false的,而do-while语句却是因为5<4返回false的,这里可以看出while和do-while的细微差异
  for循环:
  语法规则为:
  for(初始条件;判断条件;变化条件){执行语句块;}
  for(每一项:包含项的列表)【*:等效于C#里面的foreach语句,而且是JDK1.5里面才支持的功能】
  同样用一段代码来说明用法:
package org.susan.java.basic;

public class ForLoopMain {
    public static void main(String args[]){
        String[] arrayStrings = {"A","B","C"};
        //进行arrayStrings的遍历
        for( int i= 0; i < arrayStrings.length; i++){
            System.out.println(arrayStrings
);
        }
        System.out.println("---------------");
        for(String item:arrayStrings){
            System.out.println(item);
        }
    }
}
  上边代码的输出为:
A
B
C
---------------
A
B
C
  这两种都可以进行循环遍历操作,简单总结以下前两种循环:
  • 一般情况下,while和do-while循环主要用于无限循环,就是不知道循环次数,但是当终止条件满足的时候就退出循环
  • for循环一般是用于有限循环,就是已经知道了循环次数,当到达某种条件的时候退出
  这两种循环没有本质的区别,针对哪种循环的选择主要是在于用户在写程序的时候如何设计的问题
  中断循环:
  循环中断一般有三种方式:break、continue、标签中断
  break的特征为:当循环遇到了break语句的时候,直接跳出本循环
  continue的特征为:当循环遇到了continue语句的时候,直接跳出本轮循环,进入下一次循环
  标签中断:可以在循环里面使用标签让break或者continue的时候直接从标签位置继续,这种情况有时候用于嵌套循环的一些内容;
  ——[$]break和continue——
package org.susan.java.basic;

public class BreakContinueMain {
    public static void main(String args[]){
        System.out.println("Break Loop");
        for( int i = 0; i < 4; i++){
            if( i == 2)
                break;
            System.out.println("Loop " + i);
        }
        System.out.println("Continue Loop");
        for( int i = 0; i < 4; i++){
            if( i == 2)
                continue;
            System.out.println("Loop " + i);
        }
    }
}
  上边这段代码的输出为:
Break Loop
Loop 0
Loop 1
Continue Loop
Loop 0
Loop 1
Loop 3
  【*:读者仔细思考一下,如果没有break和continue语句,应该依次打印i的值为0,1,2,3的每一句话,第一个循环是Break循环,当i=2的时候直接跳出了该循环,按照break的语法是直接跳出循环,所以只打印了i=0和1的时候的情况。而第二个循环是continue循环,当i=2的时候使用了continue,一旦使用了continue过后,该次循环就不执行了,直接进入下一轮循环,所以在continue循环的语句里面只有i=2的语句没有打印出来。】
  ——[$]使用标签——
package org.susan.java.basic;

public class LabelLoopMain {
    public static void main(String args[]){
        outer:for(int i=1; i < 4; i++){
            inner:for(int j =0; j < 5; j++){
            if( j == 2 )
                continue inner;
            System.out.println("i + j = " + (i+j));
            if( j == 4)
                break outer;
            }
        }
        other:for(int i = 0; i < 4; i++){
            if( i == 3){
                break other;
            }
            System.out.println("i = " + i);
        }
    }
}
  上边这段代码定义了三个循环标签分别为outer,inner,other,输出为:
i + j = 1
i + j = 2
i + j = 4
i + j = 5
i = 0
i = 1
i = 2
  这里仅仅讲解一下简单的标签的语意,这段程序的详细逻辑留给读者自行去分析
  • break labelname:跳出该标签指代的循环,标签指代的循环就是标签的:后边的内容
  • continue labelname:继续标签指代的循环,标签指代的循环就是标签的:后边的内容
  【*:这里需要说明的是,没有特殊情况可以不用考虑标签循环,标签中断循环主要是设计来为嵌套循环的相互之间的跳转用的,比如有三层循环,在某种条件满足的情况下仅仅想从内层循环跳到中层循环,这种情况下就可以使用标签,直接使用break labelmiddle的方式,labelmiddle就为中间那一层的循环前边定义的标签的名称,其他正常的编程情况能不使用标签的情况可以避免使用标签。】
  
        }
        System.out.println("---------------");
        for(String item:arrayStrings){
            System.out.println(item);
        }
    }
}
  上边代码的输出为:
A
B
C
---------------
A
B
C
  这两种都可以进行循环遍历操作,简单总结以下前两种循环:
  • 一般情况下,while和do-while循环主要用于无限循环,就是不知道循环次数,但是当终止条件满足的时候就退出循环
  • for循环一般是用于有限循环,就是已经知道了循环次数,当到达某种条件的时候退出
  这两种循环没有本质的区别,针对哪种循环的选择主要是在于用户在写程序的时候如何设计的问题
  中断循环:
  循环中断一般有三种方式:break、continue、标签中断
  break的特征为:当循环遇到了break语句的时候,直接跳出本循环
  continue的特征为:当循环遇到了continue语句的时候,直接跳出本轮循环,进入下一次循环
  标签中断:可以在循环里面使用标签让break或者continue的时候直接从标签位置继续,这种情况有时候用于嵌套循环的一些内容;
  ——[$]break和continue——
package org.susan.java.basic;

public class BreakContinueMain {
    public static void main(String args[]){
        System.out.println("Break Loop");
        for( int i = 0; i < 4; i++){
            if( i == 2)
                break;
            System.out.println("Loop " + i);
        }
        System.out.println("Continue Loop");
        for( int i = 0; i < 4; i++){
            if( i == 2)
                continue;
            System.out.println("Loop " + i);
        }
    }
}
  上边这段代码的输出为:
Break Loop
Loop 0
Loop 1
Continue Loop
Loop 0
Loop 1
Loop 3
  【*:读者仔细思考一下,如果没有break和continue语句,应该依次打印i的值为0,1,2,3的每一句话,第一个循环是Break循环,当i=2的时候直接跳出了该循环,按照break的语法是直接跳出循环,所以只打印了i=0和1的时候的情况。而第二个循环是continue循环,当i=2的时候使用了continue,一旦使用了continue过后,该次循环就不执行了,直接进入下一轮循环,所以在continue循环的语句里面只有i=2的语句没有打印出来。】
  ——[$]使用标签——
package org.susan.java.basic;

public class LabelLoopMain {
    public static void main(String args[]){
        outer:for(int i=1; i < 4; i++){
            inner:for(int j =0; j < 5; j++){
            if( j == 2 )
                continue inner;
            System.out.println("i + j = " + (i+j));
            if( j == 4)
                break outer;
            }
        }
        other:for(int i = 0; i < 4; i++){
            if( i == 3){
                break other;
            }
            System.out.println("i = " + i);
        }
    }
}
  上边这段代码定义了三个循环标签分别为outer,inner,other,输出为:
i + j = 1
i + j = 2
i + j = 4
i + j = 5
i = 0
i = 1
i = 2
  这里仅仅讲解一下简单的标签的语意,这段程序的详细逻辑留给读者自行去分析
  • break labelname:跳出该标签指代的循环,标签指代的循环就是标签的:后边的内容
  • continue labelname:继续标签指代的循环,标签指代的循环就是标签的:后边的内容
  【*:这里需要说明的是,没有特殊情况可以不用考虑标签循环,标签中断循环主要是设计来为嵌套循环的相互之间的跳转用的,比如有三层循环,在某种条件满足的情况下仅仅想从内层循环跳到中层循环,这种情况下就可以使用标签,直接使用break labelmiddle的方式,labelmiddle就为中间那一层的循环前边定义的标签的名称,其他正常的编程情况能不使用标签的情况可以避免使用标签。】
  
6.关键字清单
  对Java初学者而言,记忆对应的关键字也是一个不错的学习方式,这里提供一个与Java关键字相关的查询文档:
  i.关键字、字面量、保留字
  在Java里,按照使用的方式把所有可以被IDE着色的Java字分为三种类型
  • 关键字:关键字就是目前正在使用的Java语法
  • 字面量:在Sun公司的官方规范里面有明确的说明,false、true和null这三个虽然IDE提供了语法着色,但是这三个不能称为关键字,而是使用的时候提供的字面量
  • 保留字:保留字在Java里面称为以后可能会用到的语法,就是定义标识符的时候不能使用,主要有const和goto
  ii.关键字清单以及说明

 

 

  • [3]访问控制private、protected、public
  • [13]类、方法和变量修饰符abstract、class、extends、final、implements、interface、native、new、static、strictfp、synchronized、transient、volatile
  • [12]程序控制语句break、continue、return、do、while、if、else、for、instanceof、switch、case、default
  • [5]错误处理catch、finally、throw、throws、try
  • [2]包相关import、package
  • [8]基本类型boolean、byte、char、double、float、int、long、short
  • [3]变量引用super、this、void
  • [1]JDK1.5新关键字enum
  • [2]其他new、assert

 

  【*:需要说明的是const和goto从概念上来将属于Java里面的保留字,不应该列入关键字之列;true、false和null三个属于字面量,虽然属于Java里面的关键字,但是在规范里面不列入关键字之列。这里解释一下,很多资料都说Java里面有51个关键字,数数上边就会发现只有49个,51个关键字的来历是什么呢?51个关键在是在上边关键字的基础上计算了false、true和null,而且是JDK1.4的说法,还去掉了新关键字enum,所以很多资料都记载了51个关键字。】

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值