day02

在程序执行的过程中，其值不可以发生改变的量就是常量。

常量的分类：

• 自定义常量：通过final关键字定义
• 字面值常量：如下图所示

代码示例

public class Demo01Const {
    public static void main(String[] args) {
        // 字符串常量
        System.out.println("ABC");
        System.out.println(""); // 字符串两个双引号中间的内容为空
        System.out.println("XYZ");

        // 整数常量
        System.out.println(30);
        System.out.println(-500);

        // 浮点数常量（小数）
        System.out.println(3.14);
        System.out.println(-2.5);

        // 字符常量
        System.out.println('A');
        System.out.println('6');
        // System.out.println(''); // 两个单引号中间必须有且仅有一个字符，没有不行。
        // System.out.println('AB'); // 两个单引号中间必须有且仅有一个字符，有两个不行。

        // 布尔常量
        System.out.println(true);
        System.out.println(false);

        // 空常量。空常量不能直接用来打印输出。
        // System.out.println(null);
    }
}

变量：在程序执行的过程中，其值可以发生改变的量。用来存储数据，代表内存的一块存储区域，这块内存中的值是可以改变的。

变量的作用

• 用于在内存中保存数，通过变量名，我们可以实现数据和内存的复用。

声明变量语法如下:

• 数据类型  变量名称

变量的赋值语法如下:

• 变量名称 =  值 

声明和赋值变量同时进行,语法如下:

• 数据类型  变量名  =  初始化值 

代码示例

//变量概念: 在程序的执行过程中,其值可以在一定范围内发生改变的量
public class Demo01Variable {
    public static void main(String[] args) {
        // 声明变量并赋值 数据类型 变量名 = 数据值;
        int age = 18;
        System.out.println(age);

        
        double money;
        money = 55.5;
        System.out.println(money);

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

使用变量注意事项

• Java中每个变量必须先声明，后使用。如果没有声明，会报“找不到符号”错误
• 在使用之前必须初始化，如果没有初始化，会报“未初始化”错误。变量的声明只是单纯的声明，不会在内存中开辟空间。变量的赋值才会开辟空间。
• 使用变量名来访问这块区域的数据
• 变量的作用域：从定义变量的一行开始，一直到直接所属的大括号结束为止。变量只有在其作用域内才有效。如果超过作用域，也会报“找不到符号”错误 。
• 同一个作用域内，不能定义重名的变量
• 可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。
• 变量右侧的数据值不能超过左侧类型的范围。
• 变量只要第一次声明的时候需要指明数据类型，再次使用这个变量的时候，前面不能再次出现数据类型，否则相当于重新声明一个新的变量。违反了同一个作用域内，不能定义重名的变量。会报错

代码示例

public class Demo02VariableNotice {
    public static void main(String[] args) {
        //变量的声明,并且赋值
        int myAge = 12;
        //变量的使用,输出变量中保存的值
        System.out.println(myAge);//12

        //编译错误：使用myNumber之前并未定义过myNumber
        //System.out.println(myNumber);

        //变量的声明
        int myNumber;

        //编译错误：使用myNumber之前并未赋值过myNumber
        //System.out.println(myNumber);

        //变量的赋值
        myNumber = 1001;
        // myNumber = 13242353454646457; 右侧超出了int数据范围，错误！
        {
            int age = 60;
            System.out.println(age); // 60
        }
        // System.out.println(age); // 已经超出了大括号的范围，超出了作用域，变量不能再使用了

        //不可以在同一个作用域内定义同名的变量
        //int myAge = 22;

        // 同时创建了三个全都是int类型的变量
        int a, b, c;
        // 各自分别赋值
        a = 10;
        b = 20;
        c = 30;
        System.out.println(a); // 10
        System.out.println(b); // 20
        System.out.println(c); // 30

        // 同时创建三个int变量，并且同时各自赋值
        int x = 100, y = 200, z = 300;
        System.out.println(x); // 100
        System.out.println(y); // 200
        System.out.println(z); // 300
        
    }
}

数据类型作用就是决定程序运行阶段给该变量分配多大的内存空间。 这就是数据类型的主要作用。那么 java 中的数据类型都包括哪些呢？实际上 Java 中的数据类型就包括两大类，一类是基本数据类型，另一类是引用数据类型，例如：类 抽象类 接口 枚举 …. …

其中，基本数据类型又包括 4 类 8 种：

• 第 1 类：整数型（不带小数的数字）：byte,short,int,long
• 第 2 类：浮点型（带小数的数字）：float,double
• 第 3 类：字符型（文字，单个字符）：char
• 第 4 类：布尔型（真和假）：boolean

如下图所示：     

整数类型：byte、short、int、long

• Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
• java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’
• java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long       

代码示例

public class Demo {
    public static void main(String[] args) {
        //1. 整型：byte(1字节=8bit)  short(2字节)  int(4字节)  long(8字节)
        //① byte范围：-128 ~ 127
        //
        byte b1 = 12;
        byte b2 = -128;
        //b2 = 128;//编译不通过
        System.out.println(b1);
        System.out.println(b2);
        // ② 声明long型变量，必须以"l"或"L"结尾
        // ③ 通常，定义整型变量时，使用int型。
        short s = 128;
        int i = 1234;
        long l = 3414234324L;
        

    }
}

整数型数据在 java 中有 4 种表示方式，分别是十进制、八进制、十六进制、二进制。不同进制之间可以按照一定的规则相互转换。要注意的是二进制写法是在 Java7 中引入的，对于 Java7 之前的版本不支持该语法。默认为十进制，以 0 开始表示八进制，以 0x 开始表示十六进制，以 0b 开始表示二进制。进制的换算，如下图所示

代码示例

class BinaryTest {
    public static void main(String[] args) {
        
        int num1 = 0b110;
        int num2 = 110;
        int num3 = 0127;
        int num4 = 0x110A;
        // 最后输出都是以十进制表示
        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
        System.out.println("num3 = " + num3);
        System.out.println("num4 = " + num4);

    }
}

浮点类型：float、double 

与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作 系统的影响。浮点型数据实际上在内存中存储的时候大部分情况下都是存储了数据的近似值，为什么呢？这是因为在现实世界中存在无穷的数据，例如：3.333333333333333333..，数据是无穷的，但是内存是有限的，所以只能存储近似值，float 单精度占 4 个字节，double 双精度占 8 个字节，相对来说 double 精度要高一些。由于浮点型数据存储的是近似值，不能精确表示一个值。所以一般判断两个浮点型数据是否相等的操作很少。.浮点数：底层存储方式与 整数不同 ,分为符号位丶指数位 丶尾数位。浮点型常量有两种表示形式：

• 十进制数形式：如：5.12 
• 科学计数法形式:如：5100E-2

float:单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。 double:双精度，精度是float的两倍。通常采用此类型。 Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’。 浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

代码示例

public class Demo {
    public static void main(String[] args) {
        //2. 浮点型：float(4字节)  double(8字节)
        //① 浮点型，表示带小数点的数值，默认情况下，定义浮点型变量时，使用double型。
        //② float表示数值的范围比long还大
        double d = 5100E2;//科学计数法
        System.out.println(d);//510000.0
        //③ 定义float类型变量时，变量要以"f"或"F"结尾
        float f = 12.3F;
        System.out.println(f);//12.3
    }
}

字符类型：char

• 字符型 char 在 Java 语言中占用 2 个字节，char 类型的字面量必须使用半角的单引号括起来，取值范围为[0-65535]，char 和 short 都占用 2 个字节，但是 char 可以取到更大的正整数， 因为 char 类型没有负数。
• Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字 母，一个汉字，或其他书面语的一个字符。char类型是可以进行运算的。因为它都对应有Unicode码。我们可以根据对应的Unicode码运算

字符型常量的三种表现形式：

• 字符常量是用单引号(‘ ’)括起来的单个字符。例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';
• Java中还允许使用转义字符‘’来将其后的字符转变为特殊字符型常量。 例如：char c3 = ‘n’; // 'n'表示换行符
• 直接使用 Unicode 值来表示字符型常量：‘uXXXX’。其中，XXXX代表 一个十六进制整数。如：u000a 表示 n。

代码示例

public class Demo {
    public static void main(String[] args) {
        //3. 字符型：char (1字符=2字节)
        //① 定义char型变量，通常使用一对'',内部只能写一个字符
        char c1 = 'a';
        //编译不通过
        //c1 = 'AB';
        char c2 = '1';
        // 1.声明一个字符
        char c3 = '中';
        char c4 = 'ス';
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        //2.转义字符
        char c5 = 'n';//换行符
        c5 = 't';//制表符
        System.out.print("hello" + c5);
        System.out.println("world");
        // 3.直接使用 Unicode 值来表示字符型常量
        char c6 = 'u0043';
        System.out.println(c6);// c
        // 字符可以计算，因为有对应的Unicode值
        System.out.println(c6 + 1);//68

    }
}

布尔类型：boolean

• boolean 类型用来判断逻辑条件，一般用于程序流程控制。
• boolean类型数据只允许取值true和false，无null。
• 不可以使用0或非 0 的整数替代false和true，这点和C语言不同。

代码示例

public class Demo {
    public static void main(String[] args) {
        //4.布尔型：boolean
        //① 只能取两个值之一：true 、 false
        //② 常常在条件判断、循环结构中使用
        boolean b = true;
        System.out.println(b);//true
        boolean isMarried = false;
        if (isMarried) {
            System.out.println("你就不能参加"单身"party了！\n很遗憾");
        } else {
            System.out.println("你可以多谈谈女朋友！");//你可以多谈谈女朋友！
        }
    }
}

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

自动类型转换

容量小的类型自动转换为容量大的数据类型。数据类型按容 量大小排序如下图所示：             

代码示例

public class Demo1Conversion {
    
    public static void main(String[] args) {
        int a = 10;            // int 4个字节
        double b = a;        // double 8个字节
        System.out.println(b); //10.0
    }
}

强制类型转换

• 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：( )，但可能造成精度降低或溢出,格外要注意。
• 转换格式：数据类型 变量名 = （数据类型）被转数据值；
• 通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。
• 浮点类型转为整数类型会丢失小数

代码示例

public class Demo02DataType {
    public static void main(String[] args) {
        // 左边是int类型，右边是long类型，不一样
        // long --> int，不是从小到大
        // 不能发生自动类型转换！
        // 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
        int num = (int) 100L;
        System.out.println(num);
        
        // long强制转换成为int类型
        int num2 = (int) 6000000000L;
        System.out.println(num2); // 1705032704
        
        // double --> int，强制类型转换
        int num3 = (int) 3.99;
        System.out.println(num3); // 3，这并不是四舍五入，所有的小数位都会被舍弃掉
        
        char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
        System.out.println(zifu1 + 1); // 66，也就是大写字母A被当做65进行处理
        // 计算机的底层会用一个数字（二进制）来代表字符A，就是65
        // 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
        
        byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
        byte num5 = 50;
        // byte + byte --> int + int --> int
        int result1 = num4 + num5;
        System.out.println(result1); // 90
        
        short num6 = 60;
        // byte + short --> int + int --> int
        // int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
        short result2 = (short) (num4 + num6);
        System.out.println(result2); // 100
    }
}

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

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