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

旧城等待， 2022-05-18 05:46 370阅读 0赞

目标：        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;  
     +=  
     -=  
     ...  
  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;

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==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;                              //a1变量的取值为2  
     int a2=13/5;                              //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;  
     0000 1100    12  
     -----------  
      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;

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

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

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;     
     |   :   或运算，对两个操作元的每个二进制位进行或运算，运算规则为：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的值。

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 o1 = new Object();  
    Student s1 = (Student) o1;

6. 条件语句  
   有些程序代码只有满足特定条件的情况下才会被执行，Java语言支持两种条件处理语句：if语句和switch语句  
   1) if ... else  
     布尔表达式指的是能返回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;  
     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. 循环语句

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

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

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()\{  
        for(int i=0;i<6;i++)\{  
            for(int j=0;j<6;j++)\{  
                System.out.print(j);  
                  
            \}  
            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();  
        \}  
    \}