day03_字面量（常量）丶变量丶基本数据类型丶数据类型转换

字面量（常量）

字面量就是数据在程序中的书写格式。字面量也是常量，在程序执行的过程中，其值不可以发生改变的量。

实例

	/*
		常量：在程序的执行过程中，其值不会发生改变的量（数据）
		
		常量的分类：
		
			字符串常量：	    被双引号所包裹的内容
			
			整数常量：		所有整数
			
			小数常量：		所有小数
			
			字符常量：		被单引号包裹的内容，里面只能存放单个字符
			
			布尔常量：		只有两个值，true(真)，false(假)
								布尔常量单独打印没有意义，为了后面要学习的运算符，打基础
			
			空常量：		null, 数组部分详细讲解
								注意：null空常量不能直接打印
	*/
public class LiteralDemo {
    public static void main(String[] args) {
        // 目标：掌握数据在程序中的书写格式
        // 1、整数
        System.out.println(66);
        System.out.println(-23);

        // 2、小数
        System.out.println(99.5);

        // 3、字符：必须单引号围起来，有且仅能有一个字符
        System.out.println('中');
        System.out.println('0');
        System.out.println('\n'); // \n换行
        System.out.println('\t'); // \t空格
        System.out.println('a');

        // 4、字符串：必须双引号围起来，内容可以随意
        System.out.println("");
        System.out.println("我爱你中国！abc");
        System.out.println("    学习Java使我快乐！~~~");

        // 5、布尔类型：true false
        System.out.println(true);
        System.out.println(false);

        // 6、空类型 null (以后再详细说明！)
    }
}

注意事项：

• 常量除了我们上面介绍的字面值常量还有通过final关键字定义自定义常量。
• 加final修饰后，这个变量的值就不能修改了，一开始赋值多少，就是多少，所以此时的变量名通常称为常量名。
• 常量名通常所有字母都大写，每一个单词之间使用下划线分割，从命名上和变量名区分开来。

变量

概念：变量就是用来存储一个数据的内存区域（可以理解成盒子），且里面存储的数据可以变化。变量的实质就是申请内存，变量的数据类型可以是基本数据类型，也可以是引用数据类型。

变量的三要素：

public class Demo {
    public static void main(String[] args) {
        /*
        变量的声明的语法格式：
               数据类型  变量名;
         */
        int age;

        /*
        变量的赋值的语法格式：
            变量名 = 值;
        注意：
             对变量重新赋值时  前面一定不要加数据类型,否则相当于重新声明一个新的变量会报错
             给变量赋的值类型必须与变量声明的类型一致或兼容 
        */
        age = 18;

        /*
        变量的使用的语法格式：
            通过变量名直接引用,例如：输出变量的值，输出变量中的内容，则不要把变量名用""引起来
         */
        System.out.println(age); // 18

        //变量也可以参与计算
        age = age + 1;
        System.out.println(age); //19
    }
}

public class Demo {
    public static void main(String[] args) {
        // System.out.println(age); 错误:java: 找不到符号
        int age = 18;
    }
}

public class Demo {
    public static void main(String[] args) {
        int age;
        // System.out.println(age); 错误：可能尚未初始化变量age
    }
}

public class Demo {
    public static void main(String[] args) {
        {
            int age = 18;
            System.out.println(age);
        }
        // System.out.println(age); 错误：找不到符号
    }
}

在同一个作用域中不能定义重名的变量

public class Demo {
    public static void main(String[] args) {
       int age= 18;
       //  double age = 18;  错误： 已在方法 main中定义了变量 age
    }
}

什么类型的变量一定是存放什么类型的数据

public class Demo {
    public static void main(String[] args) {
       // int age= "18"; 不兼容的类型: java.lang.String无法转换为int
    }
}

在同一行定义多个同一种数据类型的变量，中间使用逗号隔开。但不建议使用这种方式，降低程序的可读性。

public class Demo {
    public static void main(String[] args) {
        int a = 10, b = 20; // 定义int类型的变量a和b，中间使用逗号隔开
        System.out.println(a);
        System.out.println(b);

        int c,d; // 声明int类型的变量c和d，中间使用逗号隔开
        c = 30;
        d = 40;
        System.out.println(c);
        System.out.println(d);
    }
}

定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，整数太大可能超出int范围。

public class Demo {
    public static void main(String[] args) {
        // long l =121425346346; 过大的整数: 121425346346
        long l =121425346346L;
    }
}

定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。

public class Demo {
    public static void main(String[] args) {
        // float f = 3.14; 不兼容的类型: 从double转换到float可能会有损失
        float f = 3.14F;
    }
}

数据类型

Java是一个强类型语言，Java中的数据必须明确数据类型。不同的数据类型也会在内存中分配不同的内存空间。在Java中的数据类型包括基本数据类型和引用数据类型两种。

基本数据类型如下图所示

基本数据类型详解

整型系列

public class Demo {
    public static void main(String[] args) {
         /*
        byte：字节类型
            占内存：1个字节
            存储范围：-128~127
         */
        byte b;

        /*
        short：短整型类型
                 占内存：2个字节
*                存储范围：-32768~32767
         */
        short s;

        /*
        int：整型
         占内存：4个字节
*        存储范围：-2的31次方 ~ 2的31次方-1
        */
        int i;

        /*
        long：整型
          占内存：8个字节
          存储范围：-2的63次方 ~ 2的63次方-1
         */
        long l;
    }
}

注意事项：

如果给变量赋的值，超过了变量类型的取值范围，则会报错

public class Demo {
    public static void main(String[] args) {
        byte b = 1111; // 报错
        short s = 2323222;// 报错
        int i = 545454545454545;// 报错
    }
}

整数类型默认的数据类型是int ，也就是说，我们随便写一个整数就是整数类型，?声明long类型数值的时候 要在数值的末尾+l/L

public class Demo {
    public static void main(String[] args) {
      long l =4546554656565; //报错
      long i =4546554656565L; //正确
    }
}

给byte和short赋值的时候，如果赋的值在 byte 或者 short的范围内 ，可以直接赋值，这是JVM的常量优化机制

public class Demo {
    public static void main(String[] args) {
        byte b = 123; //正确
        b = 555;// 错误
        short s = 1123; //正确
        s = 55511;// 错误
    }
}

浮点型系列?

public class Demo {
    public static void main(String[] args) {
     /*
        float：单精度浮点型
            占内存：4个字节
            精度：科学记数法的小数点后6~7位
         */
        float f;
        /*
        double：双精度浮点型
                占内存：8个字节
                精度：科学记数法的小数点后15~16位
         */
        double d;
    }
}

注意事项：

• 小数底层存储方式与 整数不同 ?符号位 指数位 ?尾数位，因此浮点类型的存储范围远远大于整数系列
• 小数不能精确的表示一个值，如果想要精确的表示一个值?后面会学到 bigdecimal
• 浮点类型 默认的数据类型是 double，?声明float类型的数据 要在数值的末尾 + f/F

public class Demo {
    public static void main(String[] args) {
        float f = 3.14; //错误
        double d = 3.14; // 正确
    }
}

单字符类型：char

public class Demo {
    public static void main(String[] args) {
      /*
       char 类型
            占内存：2个字节
            有且只能存储一个字符
       */
        char c;
    }
}

字符常量的几种表示方式

public class Demo {
    public static void main(String[] args) {
        //一个字符
        char c1 = 'a';
        char c2 = '爱';

        //转义字符
        char c3 = '\t';
        char c4 = '\n';

        // Unicode编码值的十六进制型
        char c5 = '\u5c1a';

        //直接给char类型变量赋值十进制的0~65535之间的Unicode编码值
        char c6 = 23578;
    }
}

布尔型详解?

在 Java 语言中布尔类型的值只包括 true 和 false，没有其他值，不包括 1 和 0，布尔类型的数据在开发中主要使用在逻辑判断方面

public class Demo01Test {
    public static void main(String[] args) {
        boolean b = true;
        System.out.println(b);
        b = false;
        System.out.println(b);
    }
}

基本数据类型转换

在Java程序中，不同的基本数据类型的值经常需要进行相互转换。Java语言所提供的七种数值类型之间可以相互转换，基本数据类型转换有两种转换方式：自动类型转换和强制类型转换。boolean类型不参与数据类型转换。

自动转换

• 将取值范围小的类型自动提升为取值范围大的类型的过程就是自动类型转换

数据类型的转换关系（取值范围从小到大），如图所示：

下面这些情况都会发生自动类型转换

当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时，

public class Demo {
    public static void main(String[] args) {
        int i = 'A';//char自动升级为int
        double d = 10;//int自动升级为double
    }
}

当存储范围小的数据类型与存储范围大的数据类型一起混合运算时，会按照其中最大的类型运算

public class Demo {
    public static void main(String[] args) {
        int i = 1;
        byte b = 1;
        double d = 1.0;
        double sum = i + b + d;//混合运算，升级为double
    }
}

当byte,short,char数据类型进行算术运算时，按照都先把byte,short,char提升为int类型在进行运算

public class Demo {
    public static void main(String[] args) {
        byte b1 = 1;
        byte b2 = 2;
        byte b3 = b1 + b2; //编译报错，b1 + b2自动升级为in
        int i = b1 + b2;
        
        char c1 = '0';
        char c2 = 'A';
        char c3 = c1 + c2; //编译报错，c1 + c2自动升级为int
        int j = c1 + c2;
    }
}

强制类型转换

• 将取值范围大的类型强制转换成取值范围小的类型的过程就是强制类型转换。 比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。
• 转换格式： 数据类型 变量名 = （数据类型）被强转数据值；
• 强制类型有风险，可能会损失精度或溢出

下面这些情况都会发生自动类型转换

当把存储范围大的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围小的变量时，需要强制类型转换

public class Demo {
    public static void main(String[] args) {
        double d = 1.2;
        int num = (int) d;//损失精度
        System.out.println(num);// 1

        int i = 200;
        byte b = (byte) i;//溢出
        System.out.println(b); // -56
    }
}

当某个值想要提升数据类型时，也可以使用强制类型转换。这个情况的强制类型转换是没有风险的。

public class Demo {
    public static void main(String[] args) {
        int i = 1;
        int j = 2;
        double shang = (double) i / j;
        System.out.println(shang); //0.5
    }
}

总结：

基本数据类型之间是存在固定的转换规则的，现总结出以下 6 条规则，无论是哪个程序， 将这 6 个规则套用进去，问题迎刃而解：

1. 八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以进行转换；
2. 如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋值给 byte,short,char 类型的变量；
3. 小容量向大容量转换称为自动类型转换，容量从小到大的排序为：byte < short(char) < int < long < float < double，其中 short 和 char 都占用两个字节，但是 char 可以表示更大的正整数；
4. 大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但 运行时可能出现精度损失，谨慎使用；
5. byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；
6. 多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；