Java基础（三） Java变量、操作符及判断和循环语句

妖狐艹你老母 2022-07-12 03:22 126阅读 0赞

# Java基础（三） Java变量、操作符及判断和循环语句 #

*  变量
 *  操作符
 *  条件语句
 *  循环语句

## 1.变量 ##

### 1.1变量介绍 ###

#### 1.1.1变量综述 ####

在前一章的结尾，我们已经简单的介绍过了为什么需要使用变量，以及在什么时候需要使用变量。

*  程序的基本功能是处理数据；
 *  数据是变化的，所以需要使用变量来处理数据；
 *  程序中必须先定义变量才能使用变量，并且需要需要初始化。不初始化的变量，值是未知的，这必然导致程序处理结果的未知性。
 *  所以，在Java内声明的语句为`变量类型 变量名称`声明变量。并且需要`声明->初始化->使用`的原则使用变量。

#### 1.1.2作用域 ####

变量的使用有一个作用域，作用域是指变量的存在范围，只有在这个范围内，程序才能够访问它。当出了作用域的时候，变量会被销毁，变量所占用的内存会被GC进行回收。

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

*  成员变量：在类中被定义，其作用域是整个类；(属性/实例变量)
 *  局部变量：分为代码块内部声明和方法内部声明。方法内部声明，其作用域是其方法内部；代码块内部声明，其作用域是这个代码块。所谓代码块，就是一对以”\{\}”括号包含的代码块。
 *  方法参数：方法或构造方法参数，其作用域是整个方法或构造函数方法。
 *  异常处理参数：个人感觉是方法参数的一种。和方法参数很相似，差别在于前者是传递参数给异常处理代码块，而后者是传递参数给方法或者构造方法。异常处理参数是指catch(Exception e)语句中的异常参数”e”，它的作用域是紧跟着catch(Exception e)语句后的代码块。

### 1.2局部变量 ###

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

### 1.3实例变量 ###

1.在类中声明，它的作用域是整个类，也就是类的成员变量；

class Test {
               private int n1=0;
               private int n2=0;
    
               public int add() {
                      int result = n2 + n2;//不需要初始化，就可以直接使用。
                      return result;
               }
         }

2.实例变量有默认值，使用之前不需要进行初始化。每种类型变量的初始化值如下所示：

整数 byte/short/int/long    0
    浮点数 float                0.0f
    浮点数 double               0.0d
    char数据类型                    ‘\u0000’
    布尔类型 boolean            false
    引用类型                    null

3.声明周期：普通实例变量，从一个类的对象声明时开始创建，随着对象的销毁而销毁。若是类实例对象(static关键字标识的成员变量)，则应当一直存在，直至进行消亡。

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();
    
               }//Test对象作用域 超过，引用对象t1、t2都将被销毁。其成员变量n1，n2也将被销毁
         }

### 1.4Java内常见的作用域总结 ###

## 2.操作符 ##

### 2.1 常见操作符 ###

> 在一般情况下，不用刻意去记住操作符的优先级。当不能确定操作符的优先级时，使用括号来指定操作符的顺序。

这一小节主要向大家介绍下操作符，也就是运算符。诚然，我们在进行数学和其他计算的时候，需要用到数与数之间的各种操作，例如：加、减、乘、除等等。这便是我们所说的操作符，在Java中，常见的操作符主要有8种。

*  赋值操作符：  
    
    
    1.  = 等于号 : `int i=1;int j=i;i=3;`
    2.  \*= 乘等于 : `int a*=2; a=a*2;`
    3.  /= 除等于 : `int b/=2; b=b/2;`
    4.  %= 取余等于 :`int b%=2; b=b%2;`
    5.  \+= 加等于 : `int a+=2; a=a+2;`
    6.  \-= 减等于 : `int a-=2; a=a-2;`
 *  比较操作符：
    
    1.  > 大于
    2.  < 小于
    3.  <= 大于等于
    4.  >= 小于等于
    
    以上的操作符，仅仅适用于整数类型和浮点数类型；
    
        int a=1,b=2;
        double b=1.0;
        boolean result1= a>b; //false
        boolean result2= a<b; //false
        boolean result3= a>=d;//true
        boolean result4= a<=d;//true
    
    5.`instanceof` :判断一个引用类型的对象是否为一个类的实例。该操作符的左边是一个引用类型实例，右边是一个类名或者接口名。如下所示：`obj instanceof ClassName`或者`obj instanceof InterfaceName`
    
        //Exp1
        String a="s2";
        Systsem.out.println(a instanceof String);
        
        //Exp2
        Student s1=new Student();
        Studnet s2=new Student();
        Systsem.out.println(s1 instanceof Student);
        Systsem.out.println(s2 instanceof Student);
        Systsem.out.println(s2 instanceof Teacher);
 *  相等操作符：
    
    1.  == 等于
    2.  != 不等于
    
    等式的左右两边既可以是基本数据类型，可以是引用数据类型。
    
     *  基本数据类型
    
        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;
        特别注意的是,比较运算符的时候。浮点数计算可能会出现误差。例如：1.0==1.0 结果为false。需要特别注意，基本例子详见另一篇的博客。
    
     *  引用数据类型
    
    这两个引用变量必须都引用同一个对象，结果才为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;
 *  数学运算操作符：
    
    1.  `＋` 加法运算符
        
         *  数据类型相加
        
            int    a=1+2;                      //a值为3;
            double b=1+2;                      //b值为3.0; 
            double b=1+2.0;                    //c值为3.0;
        
         *  字符串链接
        
            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
            //总结 应该是遇到数字应当优先计算数字，当遇到第一个字符串后，其后的所有内容，都按字符串链接直接字符串相连。
    2.  `－` 减法运算符
    3.  `*` 乘法运算符
    4.  `/` 除法运算符：整除，如果除数为整数，则只去商的整数部分。
        
            ？除数不能为0，当除数为小数时？ 当除数为负数时候？
            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 特别注意
    5.  `%` 取余运算符
        
            // 自己实验下，效果更佳
            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
 *  移位操作符：

`>> ` :  算术右移位运算，也称做带符号右移位运算。
    
         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;

*  位运算操作符：  
    
    
    > 位运算符在进行运算的时候，需要将数字准换为二进制数字进行计算。整数和浮点数都需要转换为2进制的数字。  
    > 
    > 
    > 1.  `&`: 与运算，对两个操作元的每个二进制位进行与运算，运算规则为：`1&1->1, 1&0->0, 0&1->0, 0&0->0;`
    > 2.  `|`: 或运算，对两个操作元的每个二进制位进行或运算，运算规则为：`1|1->1, 1|0->1, 0|1->1, 0|0->0;`
    > 3.  `^`: 异或运算，对两个操作元的每个二进制位进行或运算，运算规则为：`1^1->0, 0^0->0，1^0->1, 0^1->1,; 相同为0 不同位1 运算特点: a^0=a; a^a=0;`
    > 4.  `~`: 取反运算, `~1->0, ~0->1;`
 *  逻辑操作符：
    
    短路操作符：如果能从左边的表达式推算出表达式的数值的话，将不执行右边。有时叫做`短路与`和`短路或`。(原因:为了加快运算的速度。)
    
    && : 短路与运算符。左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式。
    
    || : 短路或运算符。左边的布尔表达式的值为true, 整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。
    
    & : 与运算符。左右都需要计算。
    
    ｜ : 或运算符。左右都需要计算。
 *  条件操作符：
    
    三目运算符：布尔表达式? 表达式1 : 表达式2 (三目度由来时有三个操作部分组成)  
    如果布尔表达式结果为true，执行1的部分，否则执行2的部分。
    
        int a=1,b=2;
        int bigger=(a>b)?(a):(b); //用于比较两个数字的大小

### 2.2 类型转换 ###

和自动拆箱和装箱有很大的联系。

## 3.条件语句 ##

## 4.循环语句 ##