【Java】第三章 变量

1 什么是变量

用来命名一个数据的标示符

• year这个标识符就是一个变量，它表明1949这个值

int year = 1949;

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

2 基本变量类型

(1) 整型

public class HelloWorld{
    public static void main(String[] args){
        byte b = 1;
        short s = 200;
        int i = 300;
        long l = 400;
        /*若是试图给byte类型的变量赋予超出其范围的值，就会产生编译错误*/
        byte b2 = 200;
    }
}

(2) 字符型

• char类型用于存放一个字符，值用单引号'表示 (双引号表示字符串)
• 其长度和short同样，也是16位的
• 只能存放一个字符，超过一个字符就会产生编译错误

public class HelloWorld{
    public static void main(String[] args){
        char c = '中';
        //char 只能存放一个字符，超过一个字符就会产生编译错误
        char c2 = '中国'; //报错
        char c3 = 'ab'; //报错
    }
}

(3) 浮点型

• 默认的小数值是double类型的
  因此float f=54.321会出现编译错误，由于54.321的默认类型是double，其类型长度为64，超过了float的长度32
• 在数字后面加一个字母f，直接把该数字声明成float类型，float f2 = 54.321f，这样就不会出错了

public class HelloWorld{
    public static void main(String[] args){
        double d = 123.45;
        //该行会出现编译错误，由于54.321是double型的
        float f = 54.321;
        float f2 = 54.321f;
    }
}

(4) 布尔型

public class HelloWorld {
    public static void main(String[] args) {
        boolean b1 = true;
        boolean b2 = false;
        // 虽然布尔型真正存放的数据是0(false) 1(true)
        // 可是，不能直接使用0 1 进行赋值
        boolean b3 = 1;
    }
}

(5) String类型

• String类型其实并不是基本类型，可是它是如此普遍的被使用，经常被误觉得是一种基本类型
• String类型是Immutable，一旦建立就不可以被改变

3 字面值

(1) 整数字面值

• 当以L结尾的时候，一个整数字面值是long类型，不然就是int类型
• byte,short,int和long的值均可以经过int类型的字面值来建立

public class HelloWorld {
    public static void main(String[] args) {
        long val = 26L; //以L结尾的字面值表示long型
        int decVal = 26; //默认就是int型
        int hexVal = 0x1a; //16进制
        int oxVal = 032; //8进制
        int binVal = 0b11010; //2进制
        System.out.println(oxVal);
    }
}

(2) 浮点数字面值

• 当以F结尾的时候，就表示一个float类型的浮点数，不然就是double类型
• 浮点数还能够用E或者e表示（科学计数法）
  e2表示10的二次方，即100，1.234e2 = 1.234x100

(3) 字符和字符串字面值

• 字符的字面值放在单引号中
• 字符串的字面值放在双引号中
• 表示转义，好比须要表示制表符，回车换行，双引号等就须要用 \t \r \n \" 的方式进行

public class HelloWorld {
    public static void main(String[] args) {
        String name = "盖伦";
        char a= 'c';
 
        //如下是转义字符
        char tab = '\t'; //制表符
        char carriageReturn = '\r'; //回车
        char newLine = '\n'; //换行
        char doubleQuote = '\"'; //双引号
        char singleQuote = '\''; //单引号
        char backslash = '\\'; //反斜杠
         
    }
}

4 类型转换

(1) 转换规则

• 精度高的数据类型就像容量大的杯子，能够放更大的数据
• 精度低的数据类型就像容量小的杯子，只能放更小的数据
• 小杯子往大杯子里倒东西，大杯子怎么都放得下
• 大杯子往小杯子里倒东西，有的时候放的下，有的时候就会有溢出

public class HelloWorld {
    public static void main(String[] args) {

        char c = 'A';
        short s = 80;
         
        //虽然short和char都是16位的，长度是同样的
        //可是彼此之间，依然须要进行强制转换
        c = (char) s;
        //直接进行转换，会出现编译错误
        s = c;
         
    }
}

(2) 低精度向高精度转换

• 把i的值赋给l，首先l和i彼此的类型是不同的，那么可否转换就取决于彼此的精度
• L的精度，比i的精度要高
• 低精度向高精度转换，正常

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

(3) 高精度向低精度转换

把int类型的数据转成为byte类型的数据，是有风险的

• 有的时候是能够转换的，好比 b = i1 (i1=10);
• 有的时候不能够转换 好比 b= i2 (i2=300) 由于放不下了

强制转换的意思就是，转是能够转的，可是不对转换以后的值负责

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));
         
    }
}

5 命名规则

(1) 命名规则

• 变量命名只能使用字母 数字 $ _
• 变量第一个字符 只能使用 字母 $ _
• 变量第一个字符 不能使用数字
• _ 是下划线，不是-减号或者—— 破折号

(2) 使用完整的单词命名，而非缩写

在命名的时候，尽可能使用完整的单词进行命名，好比name,moveSpeed，而不是使用缩写 n,m

(3) 关键字列表

(4) 不能只使用关键字，可是能够包含关键字

(5) 中文也是能够用来命名变量的

6 做用域

(1) 字段，属性，Field

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

• 好比变量i，就是一个属性

从变量声明的位置开始，整个类均可以访问获得，因此其做用域就是从其声明的位置开始的整个类

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
    }
}

(2) 参数

若是一个变量，是声明在一个方法上的，就叫作参数

• 参数的做用域即为该方法内的全部代码
• 其余方法不能访问该参数
• 类里面也不能访问该参数

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
}

(3) 局部变量

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

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行就结束了
    }
 
}

7 final

当一个变量被final修饰的时候，该变量只有一次赋值的机会

(1) 在声明的时候赋值

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

}

(2) 在声明的时候没有赋值

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

(3) final 修饰其余

final 除了修饰变量，还能够修饰类，修饰方法

8 表达式

(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) {
        //一个空;也是一个表达式
        ;
        ;
        ;       
        ;
    }
}

9 块

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

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