java基础3

-第三天：
目标： 1. 操作符；
           2. 条件语句；
            3. 循环语句；
            4. 变量
----------------------------------------------

1.java中变量的介绍
  程序的基本功能是处理数据
  程序用变量来接收并表示数据；
  程序中必须先定义变量才能使用；
  定义变量是指设定变量的数据类型和变量的名字，Java语言要求变量遵循先定义，再初始化，然后使用的规则。


  变量的使用有一个作用域的问题，作用域是指它的存在范围，只有在这个范围内，程序代码才能访问它。


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


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


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


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


2.局部变量
  1) 定义在方法的内部或方法的一个代码块的内部；
                     
     public void method1() {
         int a = 0;                      //局部变量，作用域为整个method01方法；
         if(a==0){ 
            int b = 0;                   //局部变量，作用域为所处的代码块；
            b = a;
         }
         b = 20;                         //编译出错，b不能被访问
     }


  2) 局部变量没有默认值，使用之前必须先初始化；


  3) 生命周期
      从声明开始,到这个局部变量直接所在的代码块结束为止
     public class Sample {
            public int add() {
                  int addResult = 1;
                  addResult = addResult+2;
                  return addResult;
            }


            public int subtract() {
                  int subResult = 1;
                  subResult = subResult-2;
                  return subResult;                                  
            }


            public static void main(String[] args) {
                Sample s = new Sample();
                s.add();
                s.add();
            }
     }


3.实例变量
  
  1) 在类中声明，它的作用域是整个类；


     class Test {
           private int n1=0;
           private int n2=0;


           public int add() {
                  int result = n2 + n2;
                  return result;
           }
     }


  2) 实例变量有默认值，使用之前可无须初始化；
注意每种变量的默认值
基本类型中的:
整型变量默认值都为0
浮点型默认值都为0.0
char默认值'\u0000'
boolean默认值false
引用类型的默认值都为null


  3) 生命周期
       从类的一个对象被创建开始,到这个对象被销毁
     class Test {
           private int n1=0;
           private int n2=0;


           public int add() {
                  int result = n2 + n2;
                  n1 = n1+1;
                  n2 = n2+2;
                  return result;
           }


           public static void main(String[] args) {
                  Test t1 = new Test();
                  Test t2 = new Test();


                  t1.add();
                  t1.add();


                  t2.add();
           }
     }                     


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


     =   :   int x=0,i=1,j=1;
     *=  :   a*=b 等价于 a=a*b
     /=  :   a/=b 等价于 a=a/b;
     %=  :   a%=b 等价于 a=a%b;
     +=  
     byte a=10;
     a+=1;  // a = a+1
     
     int a = 15;
     int b = 7;
     -=
     ...


     a++   ++a


  2) 比较操作符


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


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


     int a=1,b=1;
     double d=1.0;
     boolean result1 = a>b;        //result1的值为false;
     boolean result2 = a<b;        //result2的值为false;
     boolean result3 = a>=d;        //result3的值为true;
     boolean result4 = a<=b;        //result4的值为true;              

     Object s
      s instanceof com.briup.Student


    Teacher t = new Teacher(); 

     instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。该操作符左边是一个引用类型，右边是一个类
                 名或接口名。形式如下：


                 obj instanceof ClassName
                 或者
                 obj instanceof InterfaceName

  3) 相等操作符                     
    int a = 10;
    int b = 10;
    a == b


    a != b 

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


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


     a. 基本类型：


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


        System.out.println(a==b);        //输出true;
        System.out.println(a==c);        //输出true;
        System.out.println(a==d);        //输出true;
        System.out.println(c==d);        //输出true;
        
     b. 引用类型：


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


        Student s1 = new Student("zs",25,100);
        Student s2 = new Student("zs",25,100);
        Student s3 = s1;


        System.out.println(s1 == s2);    //输出false;
        System.out.println(s1 == s3);    //输出true;
        System.out.println(s2 == s3);    //输出false;


  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


     /   :   整除, 如操作数均为整数，运算结果为商的整数部分


     int a1=12/5;   2.4                              //a1变量的取值为2
     int a2=13/5;  2.6                             //a2变量的取值为2
     int a3=-12/5;                             //a3变量的取值为-2
     int a4=-13/5;                             //a4变量的取值为-2
     int a5=1/5;                               //a5变量的取值为0
     double a6=12/5;                           //a6变量的取值为2.0
     double a7=12/-5.0;                        //a7变量的取值为-2.4   
     
     %   :   取模操作符, 如操作数均为整数，运算结果为商的整数部分


     int a1=1%5;                               //a1变量的取值为1
     int a2=13%5;                              //a2变量的取值为3
     double a3=1%5;                            //a3变量的取值为1.0
     double a4=12%5.1;                         //a4变量的取值为1.8000000000000007
     
  5) 移位操作符    
    >> >>> <<


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


     int a1 = 12 >> 1;                          //a1变量的取值为6;
     13 / 2  
     0000 1101 
     00000 110

     0000 1100    13
     -----------
      000 0110    >>1
     -----------
     0000 0110    补位 因为是正数所以补0  结果为6


     int a2 = 128 >> 2;                         //a2变量的取值为32;
     int a3 = 129 >> 2;                         //a3变量的取值为32;                 
     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

 int a6 = -12 >> 2;                         //a4变量的取值为-3; 

0000 1100     12
---------
1111 0011     取反
---------
1111 0100     +1  这个就是-12的二进制形式
---------- 
 11 1101     >>2
 
1111 1101     补位 因为是负数所以补1  这个负数就是最终结果
---------
1111 1100     -1
---------
0000 0011     取反 结果为3 所以上面的最终结果是 -3

     注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一位符号位，由于12是正整数，因此增加的符号位为0;
         b. 对-12右移俩位的过程为：舍弃二进制数的最后俩位，在二进制数的开头增加俩位符号位，由于-12是负整数,因此增加的符号位为1;

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

     int a1 = 12 >>> 1;                          //a1变量的取值为6;
     int a2 = -12 >>> 2;                         //a2变量的取值为1073741821;                   


    1111.... 0100 
    001111.... 01

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


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


     12 << 2


     00.... 110000
     -12 << 2


     0000 .... 1100
     1111 .... 0011
     11 .... 010000
     00 .... 110000  48

     int a1 = 12 << 1;                          //a1变量的取值为24;
     int a2 = -12 << 2;                         //a2变量的取值为-48;                   
     int a3 = 128 << 2;                         //a3变量的取值为512;
     int a4 = 129 << 2;                         //a4变量的取值为516;    


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


  6) 位运算操作符  


     &   :   与运算，对两个操作元的每个二进制位进行与运算，运算规则为：1&1->1, 1&0->0, 0&1->0, 0&0->0;  
     12&6 = 4 
     12|6=14
     0000 .... 1100
     0000 .... 0110
     0000 .... 1110


     |   :   或运算，对两个操作元的每个二进制位进行或运算，运算规则为：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;
     int a = 10;int b =20;
     a = a^b;
     b = a^b;
     a = a^b;

     a= a+b
     b = a-b;
     a = a-b;


     ~   :   取反运算, ~1->0, ~0->1;
      ~12  
     0000 .... 1100
     1111 .... 0011
     0000 .... 1101 -13


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


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


  8) 条件操作符  
     三目运算   ?:
     布尔表达式 ? 表达式1 : 表达式2

     if(布尔表达式){
      表达式1
     }else{
      表达式2
     }


     boolean gender ;

     String str = gender?"男":"女";

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

     int score = 61;
     String result = score>=60?"及格":"不及格";   

5. 引用类型之间转换

   隐式转换:自动转换
      基本类型:精度小可以自动转换为精度大的
byte b = 1;
int a = b;
      引用类型:子类类类型可以自动转换为父类类型
Student s = new Student();
Object o = s;
   显式转换:强制类型转换
      基本类型:精度大的可以强制类型转换为精度小的,但是可能损失精度
int a = 1;
byte b = (byte)a;
      引用类型:父类类型可以强制类型转换转换为子类类型，但是可能出现类型转换错误
Object类 是 Student类的父类
//这个是正确的
Object o = new Student();
Student s = (Student)o;

  Object o = new String("hello");
  Student s = (Student)o;

//这个会报错
    Object o1 = new Object();
Student s1 = (Student) o1;
为了防止产生强转后，编译通过，但是报类型不匹配异常，可以先用instanceof

6. 条件语句
   有些程序代码只有满足特定条件的情况下才会被执行，Java语言支持两种条件处理语句：if语句和switch语句
   1) if ... else
      int num =5
      if(num >3){
          1
      }
      if(num >2){
          2
      }
      if(num <3) {
          3
      }

     布尔表达式指的是能返回true或者false的运算式子: 1<2  1==1  1!=2
     a. if后面的表达式必须是布尔表达式，而不能为数字类型，例如下面的if(x)是非法的。

        int x=0;
//编译出错
        if(x) {              
            System.out.println("x不等于0");
        } else {
            System.out.println("x等于0");
        }
        
int x=0;
//正确
        if(x!=0) {               
            System.out.println("x不等于0");
        } else {
            System.out.println("x等于0");
        }

     b. 假如if语句或else语句的程序代码块中包括多条语句，则必须放在大括号{}内。若程序代码块只有一条语句
        则可以不用大括号{}。流程控制语句(如if...else语句)可作为一条语句看待。

        public void amethod(int x) {
           if(x>0)
              System.out.println("x不等于0");
           else
              if(x==0) 
                  System.out.println("等于0");
              else if(x<0)
                  System.out.println("小于0");
        }

等价于:

public void amethod(int x) {
           if(x>0){
              System.out.println("x不等于0");
  }
           else{
              if(x==0){
                  System.out.println("等于0");
              }
              else if(x<0){
                  System.out.println("小于0");
     }

  }
        }
        
     练习：1) 写一个方法实现分时问侯, 如是8点至12点，返回"上午好", 12点至14点，返回"中午好",
                  14点至18点，返回"下午好", 其它时间返回"晚上好"
                  public String sayHello(int hour) {
                      String msg; 
                      if(hour >=8 && hour < 12) 
                          msg = "上午好";
                      else if(hour>=12 && hour <14) 
                          msg = "中午好";
                      else if(hour>=14 && hour <18) 
                          msg = "下午好";
                      else 
                          msg = "晚上好";

                      return msg;
                  }

               2) 写一个方法判断某一年是否为闰年。


                  标准：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=false;
                      } 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 String;
     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功能更为强大。

     练习：1) 写一个方法，能实现数值星期和中文星期的转换，如0会转换为星期天, 1会转换为星期一。

                  public String switchWeekLabel(int week) {
                       String result;
                       switch(week) {
                          case 0:
                               result = "星期天";
                               break;
                          case 1:
                               result = "星期一";
                               break;
                          case 2:
                               result = "星期二";
                               break;
                          case 3:
                               result = "星期三";
                               break;
                          case 4:
                               result = "星期四";
                               break;
                          case 5:
                               result = "星期五";
                               break;
                          case 6:
                               result = "星期六";
                               break;
                          default:
                               result = "您输入的星期数值为"+week+",不能进行转换";
                        }
return result;
                  }

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


                  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. 循环语句
      int i = 1;
    for(int i=1;i==10;i++){
    }
   
    int num = 0
    while(num<=5){

      num++;
    }

    while(){}

    do{

    }while();

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


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


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


  1) for循环


     语法：for(初始化部分；循环条件；迭代部分) {
               循环体
           }


     在执行for语句时，先执行初始化部分，这部分只会被执行一次；
     接下来计算作为循环条件的布尔表达式，如果为true，就执行循环体；
     接着执行迭代部分，然后再计算作为循环条件的布尔表达式，如此反复；


        练习：1) 写一方法，完成计算从1加到100的和；


                  public int sum() {
                      int result = 0;
                      for(int i=1;i<=100;i++) {
                          result = result + i;
                      }
                      return result;
                  }

               2) 在练习一基础上，完成计算从1加到指定数值的和；
                  
                  public int sum(int n) {
                      int result = 0;
                      for(int i=1;i<=n;i++) {
                          result = result + i;
                      }
                      return result;
                  }
      
  2) while循环


     语法：[初始化部分]
           while(循环条件) {
               循环体,包括迭代部分
           }

     当循环条件为true时，就重复执行循环，否则终止循环；                 

     练习：1) 用while循环完成计算从1加到指定数值的和；
                  
                  public int sum(int n) {
                      int result = 0,i=1;


                      while(i<=n) {
                          result = result + i;
                          i=i+1;//i++;
                      }
                      return result;
                  }


  3) do ... while循环
     和while非常类似，只不过先执行循环体，然后再判断循环条件。


     语法：[初始化部分]
           do {
               循环体,包括迭代部分
           } while(循环条件);


     练习：1) 用do...while循环完成计算从1加到指定数值的和；
                  
                  public int sum(int n) {
                      int result = 0,i=1;
                      do {
                          result = result + i;
                          i=i+1;
                      } while(i<=n)

                      return result;
                  }


  以上三种循环，功能类同。作为一种编程惯例，for语句一般用在循环次数事先可确定的情况下，则
  while和do...while语句则用在循环次数事先不可确定的情况下。


    练习：往控制台上输出以下内容：
                  
            *
            **
            ***
            ****
            *****
            ******
            *******


public void myPrint(int n){

for(int i=0;i<n;i++){
for(int j=0;j<i+1;j++){
System.out.print("*");
}
System.out.println();
}
}


8. 循环语句中流程跳转

  1) break: 终止当前或指定循环；

     public int sum(int n) {
         int result = 0,i=1;
         while(i<=n) {
             result = result + i;
             i=i+1;
             if(i>10) 
                break;
         }
         return result;
     }
     
     实现1加到n;但是i大于10的话就直接退出循环


  2) continue: 跳过本次循环，执行下一次循环，或执行标号标识的循环体。

     public int sum(int n) {
         int result = 0;


         for(int i=1;i<=100;i++) {
             if(i%2==0)
continue;
             result = result + i;
         }


         return result;
     }


     实现指定范围内奇数的和；


  3) label: 标号用来标识程序中的语句，标号的名字可以是任意的合法标识符。
观察三个效果有什么不同:
public void lableTest1(){
loop1:for(int i=0;i<6;i++){
for(int j=0;j<6;j++){
System.out.print(j);
break loop;
}
System.out.println();
}
}

public void lableTest2(){
for(int i=0;i<6;i++){
for(int j=0;j<6;j++){
System.out.print(j);
if(j==3){
break;
}
}
System.out.println();
}
}

public void lableTest3(){
f1:for(int i=0;i<6;i++){
for(int j=0;j<6;j++){
System.out.print(j);
if(j==3){
break f1;
}
}
System.out.println();
}
}