Java 基础 —— 变量；操作符；条件语句；循环语句

1. java中变量的介绍

变量的使用有一个作用域的问题，作用域是指它的存在范围，只有在这个范围内，程序代码才能访问它。
其次，作用域决定了变量的生命周期。变量的生命周期是指从一个变量被创建并分配内存空间开始，到这个变量被销毁并清除其所占用内存空间的过程。当一个变量被定义时，它的作用域就被确定了。按照作用域的不同，变量可分为以下类型：

. 成员变量：在类中声明，它的作用域是整个类；
成员变量又叫做 属性/实例变量

. 局部变量：在一个方法的内部或方法的一个代码块的内部声明。
如果在一个方法内部声明，它的作用域是整个方法；如果在一个方法的某个代码块的内部声明，它的作用域是这个代码块。
代码块是指位于一对大括号”{}”以内的代码。

. 方法参数：方法或者构造方法的参数，它的作用域是整个方法或者构造方法。

. 异常处理参数：和方法参数很相似，差别在于前者是传递参数给异常处理代码块，而后者是传递参数给方法或者构造方法。
异常处理参数是指catch(Exception e)语句中的异常参数”e”，它的作用域是紧跟着catch(Exception e)语句后的代码块。

2.局部变量

1) 定义在方法的内部或方法的一个代码块的内部；
2) 局部变量没有默认值，使用之前必须先初始化；
3) 生命周期
从声明开始,到这个局部变量直接所在的代码块结束为止

3.实例变量

1) 在类中声明，它的作用域是整个类；
2) 实例变量有默认值，使用之前可无须初始化；

注意每种变量的默认值

基本类型中的:
    整型变量默认值都为0
    浮点型默认值都为0.0
    char默认值'\u0000'
    boolean默认值false

 引用类型的默认值都为null 

3) 生命周期
从类的一个对象被创建开始,到这个对象被销毁

4. 操作符Operator

一般情况下，不用去刻意记住操作符的优先级，当不能确定操作符的执行顺序时，可以使用圆括号来显示指定运算顺序。
1) 赋值操作符：

  =     
 *=     
 /=     
 %=     
 +=
 -= 

2) 比较操作符

 >  :   大于
 >= :   大于等于
 <  :   小于
 <= :   小于等于 

 以上操作符只适用于整数类型和浮点数类型；


 instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。

      该操作符左边是一个引用类型，右边是一个类名或接口名。

 形式如下：
    obj  instanceof  ClassName    
    或者    
    obj  instanceof  InterfaceName 

3) 相等操作符

 ==  :    是否    等于
 !=   :   是否    不等于

 既可以是基本类型，也可以是引用类型： 

 a. 基本类型：

    int a = 1, b = 1; 
    float c = 1.0f;
    double d = 1.0;

    System.out.println(a==c);        //输出true;
    System.out.println(a==d);        //输出true;
    System.out.println(c==d);        //输出true; 

 b. 引用类型：

    这两个引用变量必须都引用同一个对象，结果才为true.

4) 数学运算操作符

 +   :   数据类型值相加或字符串连接;

 a. 数据类型值相加；

    int    a=1+2;                     //a值为3;
    double b=1+2;                     //b值为3.0;   
    double b=1+2.0;                   //c值为3.0;

 b. 字符串连接；

    System.out.println(1+2+"a");          //输出3a
    System.out.println(1+2.0+"a");        //输出3.0a
    System.out.println(1+2.0+"a"+true);   //输出3.0atrue
    System.out.println("a"+1+2);          //输出a12
    System.out.println(1+"a"+2);          //输出1a2 

 /   :   整除, 如操作数均为整数，运算结果为商的整数部分
 double a6 = 12 / 5;               //a6变量的取值为2.0
double a7= 12 / -5.0;          //a7变量的取值为-2.4   

 %   :   取模操作符, 如操作数均为整数，运算结果为余数的整数部分
 double a3 = 1 % 5;                 //a3变量的取值为1.0
 double a4= 12 % 5.1;               //a4变量的取值为1.8000000000000007

5) 移位操作符
>> : 算术右移位运算，也称做 带符号右移 位运算。

正数移位：

 int a1 = 12 >> 1;       //a1变量的取值为6;
 0000 1100    12
 -----------
  000 0110    >>1
 -----------
 0000 0110    补位       因为是正数所以补0  结果为6 

负数移位：

int a5 = -12 >> 1;                         //a4变量的取值为-6; 

0000 1100    12
--------------
1111 0011    取反
--------------
1111 0100    +1       这个就是-12的二进制形式
--------------
  111 1010    >>1

1111 1010    补位   因为是负数所以补1  这个负数就是最终结果
--------------
1111 1001    -1
--------------
0000 0110    取反    结果为6 所以上面的最终结果是 -6 

>>> : 逻辑右移位运算，也称为 不带符号右移 位运算。

 注：a. 对 12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一个0;
     b. 对-12右移二位的过程为：舍弃二进制数的最后二位，在二进制数的开头增加二个0; 

<< : 左移位运算，也称为不带符号左移位运算。

 注：a. 对 12左移一位的过程为：舍弃二进制数的开头一位，在二进制数的尾部增加一个0;
     b. 对-12左移二位的过程为：舍弃二进制数的开头二位，在二进制数的尾部增加二个0; 

6) 位运算操作符

 &   :   与运算，    对两个操作元的每个二进制位进行与运算，运算规则为：1&1 -> 1,  1&0 -> 0,  0&1 -> 0,  0&0 -> 0;   
 |   :   或运算，    对两个操作元的每个二进制位进行或运算，运算规则为：1|1 -> 1,  1|0 -> 1,  0|1 -> 1,  0|0 -> 0;
 ^   :   异或运算，  对两个操作元的每个二进制位进行或运算，运算规则为：1^1 -> 0,  0^0 -> 0,  1^0 -> 1,  0^1 -> 1;   
         相同为0、不同为1  运算特点: a^0=a; a^a=0;
 ~   :   取反运算,   ~1 -> 0, ~0 -> 1;

7) 逻辑操作符
短路操作符，如果能根据操作符左边的布尔表达式就能推算出整个表达式的布尔值，将不执行操作符右边的布尔表达式；

 &&    :   左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式。
 ||    :   左边的布尔表达式的值为true,  整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。 

8) 条件操作符

 三目运算
 布尔表达式 ? 表达式1 : 表达式2  

 如果布尔表达式的值为true, 就返回表达式1的值, 否则返回表达式2的值。

5. 类型转换

隐式转换: 自动转换

基本类型: 精度小可以自动转换为精度大的
引用类型: 子类类类型可以自动转换为父类类型

显式转换: 强制类型转换

基本类型: 精度大的可以强制类型转换为精度小的,但是可能损失精度
引用类型: 父类类型可以强制类型转换转换为子类类型, 但是可能出现类型转换错误

6. 条件语句

有些程序代码只有满足特定条件的情况下才会被执行，Java语言支持两种条件处理语句：if语句 和 switch语句
1) if … else

a. if后面的表达式必须是布尔表达式，而不能为数字类型
b. 假如if语句或else语句的程序代码块中包括多条语句，则必须放在大括号{}内。若程序代码块只有一条语句则可以不用大括号{}。

    流程控制语句(如if...else语句)可作为一条语句看待。

 写一个方法判断某一年是否为闰年。
 标准：    1) 能被4整除，但不能被100整除;
          或
          2) 能被400整除；

                  /**实现方式一*/
                  public boolean isLeapYear(int year) {
                      if((year%4==0 && year%100!=0) || (year%400==0))
                           return true;
                      else 
                           return false;
                  }


                  /**实现方式二*/
                  public boolean isLeapYear(int year) {
                      boolean leap;
                      if(year%4!=0) 
                         leap=false;
                      else if(year%100!=0) 
                         leap=true;
                      else if(year%400!=0)
                         leap=false;
                      else
                         leap=true;

                      return leap;
                  }

                  /**实现方式三*/
                  public boolean isLeapYear(int year) {
                      boolean leap;
                      if(year%4==0) {
                         if(year%100==0) {
                             if(year%400==0)
                                 leap=true;
                             else
                                 leap=false;
                         } else 
                             leap=true;
                      } else
                             leap=false;

                      return leap;
                  }

2) switch

 语法：switch(expr) {
            case value1:
                 statements;
                 break;
            ...
            case valueN:
                 statments;
                 break;

            default:
                 statements;
                 break;
       }

 a. expr的类型必须是byte, short, char或者int;
 b. valuesN类型必须是byte, short, char或者int, 该值必须是常量。各个case子句的valueN值不同；
 c. 当switch表达式的值不与任何case子句匹配时，程序执行default子句，假如没有default子句，则程序直接退出switch语句。
default子句可以位于switch语句中的任何位置。
 d. 如果switch表达式与某个case表达式匹配，或者与default情况匹配，就从这个case子句或default子句开始执行。
    假如遇到break，就退出整个switch语句，否则依次执行switch语句中后续的case子句，不再检查case表达式的值。
 e. switch语句的功能也可以用if...else语句来实现。但switch语句会使程序更简洁，可读性更强。而if...else功能更为强大。  

写一个方法，返回指定月份最后一天到底是多少号？

              public int getLastDay(int year, int month) {
                 int day=30;
                  //1
                 switch(month) {
                     case 1:
                     case 3:
                     case 5:
                     case 7:
                     case 8:
                     case 10:
                     case 12:
                          day=31;
                          break;
                     case 2:
                          day = getLeapYear(year)? 29:28;
                 }

                 return day;
              }

7. 循环语句

循环语句的作用是反复执行一段代码，直到不满足循环条件为止。循环语句一般应包括如下四部分内容：

. 初始化部分: 用来设置循环的一些初始条件，比如循环控制变量的初始值；
. 循环条件：  这是一个布尔表达式，每一次循环都要对该表达式求值，以判断到底继续循环还是终止循环。
. 循环体：    这是循环操作的主体内容，可以是一条语句，也可以是多条语句；
. 迭代部分：  用来改变循环控制变量的值，从而改变循环条件表达式的值； 

Java语言提供三种循环语句：for语句、while语句和do…while语句。

    for语句、while语句在执行循环体之前测试循环条件，而do...while语句在执行循环体之后测试循环条件。
    因此for语句、while语句有可能连一次循环都未执行，而do...while至少执行一次循环体。

作为一种编程惯例，for语句一般用在循环次数事先可确定的情况下，则while和do…while语句则用在循环次数事先不可确定的情况下。

8. 循环语句中流程跳转

1) break: 终止当前或指定循环；
2) continue: 跳过本次循环，执行下一次循环，或 执行标号标识的循环体。
3) label: 标号用来标识程序中的语句，标号的名字可以是任意的合法标识符。