java-变量及各种使用场景

定义

• 定义：用来命名一个数据的标识符。

int year = 2020; 

int 是数据类型，表示是整数。
year 是一个标识符。
= 是赋值操作符。
2020 是一个数字类型的值。
; 表示该行结束。

数据类型

• 数据类型
  
• 以下仅介绍 基本数据类型

1. 定义：基本数据类型是Java里一种内置的特殊数据类型。
   注：它并不是某个类的对象，创建一个Student实例对象会用到new关键字，但是给一个基本类型变量赋值却不是用new。
2. 分类
   

类型转换

• 类型转换
  

1. 转换规则
   精度高的数据类型就像容量大的杯子，可以放更大的数据
   精度低的数据类型就像容量小的杯子，只能放更小的数据
   小杯子往大杯子里倒东西，大杯子怎么都放得下
   大杯子往小杯子里倒东西，有的时候放的下，有的时候就会有溢出
   
2. 低精度向高精度转换

public class HelloWorld {
  
    public static void main(String[] args) {
  
        long l = 50;
        int i = 50;
         
        // int比较小，要放进比较大的long,随便怎么样，都放的进去
        l = i;
       
    }
}

3. 高精度向低精度转换（精度缺失或无法转换）

public class HelloWorld {
  
    public static void main(String[] args) {
  
        byte b = 5;
        int i1 = 10;
        int i2 = 300;
          
        b = (byte) i1;
        //因为i1的值是在byte范围之内，所以即便进行强制转换
        //最后得到的值，也是10
        System.out.println(b);
          
        //因为i2的值是在byte范围之外，所以就会按照byte的长度进行截取
        //i2的值是300，其对应的二进制数是 100101100
        //按照byte的长度8位进行截取后，其值为 00101100 即44
        b =(byte) i2;
        System.out.println(b);
         
        //查看一个整数对应的二进制的方法：
        System.out.println(Integer.toBinaryString(i2));
         
    }
}

4. long类型与float类型的转换（8张小床小于4张大床）
   
   
   由于浮点类型的计算公式是 V=(-1)^s * M * 2^E ，得到的数值范围比long（整数类型）大很多，所以long->float不会发生精度缺失（满足低精度向高精度转换）

命名规则

• 命名规则

1. 要求
   变量命名只能使用字母 数字 $ _
   变量第一个字符 只能使用 字母 $ _
   变量第一个字符 不能使用数字
   注：_ 是下划线，不是-减号或者—— 破折号
2. 命名
   尽量使用完整的单词进行命名，比如name,moveSpeed，而不是使用缩写 n,m。
3. 关键字：不能只使用关键字，但是可以包含关键字
   如：int classnum = 5;（class 是关键字）
4. 关键字列表
   
   

作用域

• 作用域

1.定义：变量处于不同的位置，有不同的名称 ，不同名称的变量，其作用域是不一样的。

2.字段，属性，Field

当一个变量被声明在类下面，变量就叫做字段 或者属性、成员变量、Field

public class HelloWorld {
    int i = 1;
    int j = i;  //其他的属性可以访问i
    public void method1(){
        System.out.println(i); //方法1里可以访问i
    }
    public void method2(){
        System.out.println(i); //方法2里可以访问i
    }
}

3.参数

如果一个变量，是声明在一个方法上的，就叫做参数.
参数的作用域即为该方法内的所有代码。
其他方法不能访问该参数，类里面也不能访问该参数。

public class HelloWorld {
 
    public void method1(int i){ //参数i的作用域即方法method1
        System.out.println(i);
    }
    public void method2(){
 
        System.out.println(i); //method2 不能访问参数i
    }
     
    int j = i;  //类里面也不能访问参数i
}

4.局部变量

声明在方法内的变量，叫做局部变量，其作用域在声明开始的位置，到其所处于的块结束位置。

public class HelloWorld {

   public void method1() {
       int i  = 5;  //其作用范围是从声明的第4行，到其所处于的块结束12行位置
       System.out.println(i);
       {            //子块
           System.out.println(i); //可以访问i
           int j = 6;
           System.out.println(j); //可以访问j
       }
       System.out.println(j); //不能访问j,因为其作用域到第10行就结束了
   }

}

5.扩展

public class Person {
   public String name;
   public static int eyeNum;
   public static void main(String[] args) {

   	     // 访问类变量
   		System.out.println(Person.eyeNum);
   		// 访问实例变量
   		Person p = new Person();
   		System.out.println(p.name);
   		// 为实例变量赋值
   		p.name = "孙悟空";
   		// 为类变量赋值
   		Person.eyeNum = 2;
   		System.out.println(p.name+ "," + Person.eyeNum);
   		Person p2 = new Person();
   		// 类变量不会随着实例变量变化
   		System.out.println(p2.eyeNum);
      
   }
}

final

• final

1.定义：当一个变量被final修饰的时候，该变量只有一次赋值的机会。

2.用法

在声明的时候赋值

public class HelloWorld {
 
    public void method1() {
        final int i = 5;
         
        i = 10; //已经被赋值过了，所以这里会出现编译错误
         
    }
 
}

在声明的时候没有赋值

public class HelloWorld {

   public void method1() {
       final int i;
        
       i = 10; //只是被声明，但是没有被赋值，所以在这里可以进行第一次赋值
        
       i = 11; //已经被赋值过了，所以这里会出现编译错误
        
   }

}

注：关于final修饰类，方法，基本类型变量，引用。（此处暂不做描述）

表达式

• 表达式

步骤 1 : 以;结尾的一段代码，即为一个表达式

public class HelloWorld {
   public static void main(String[] args) {
       //每一句话都是一个表达式
       int i = 5; 
       System.out.println(5);
   }
}

步骤 2 : ;

public class HelloWorld {
   public static void main(String[] args) {
       //一个空;也是一个表达式
       ;
       ;
       ;      
       ;
   }
}

块

• 块

定义：从{ 开始 到对应的} 结束，即一个块。

public class HelloWorld { //类对应的块
    public static void main(String[] args) { //主方法对应的块
        System.out.println("abc");
    }
}

分类

1. 普通代码块
   是最常见的代码块，在方法里用一对“{}”括起来的数据
   
2. 构造代码块
   是在类中直接定义的，用“{}”括起来的代码。每次调用构造方法前执行，都会先执行构造代码块。
   
3. 静态(static)代码块
   他在类中的成员位置，用“{}”括起来的代码。只不过他用了static修饰了，且执行一次(static修饰{}优先执行，之后执行{}，再执行构造方法和方法)
   

代码块的执行顺序：
父类的static代码块---->子类的static代码块---->父类的non-static代码块—>父类的构造方法---->子类的non-static代码块—>子类的构造方法