02-变量,类型,运算符

1.前置内容

• 什么是内存？

  内存即是一块瞬时状态的存储空间，有一定的容量。

• 内存与硬盘的区别？

  内存造价较高，在计算机硬件资源中比较稀缺。（内存需要省着点用）

  工业上的瓶颈，多数大容量的内存都是由多个内存条组成的。

• 计算机给Java程序多大的内存空间？

  Java虚拟机（Java程序），默认分配的物理内存容量是计算机内存的 1/8。(省着用)

• 计算机存储容量的基本单位

  bit(位) * 8 == 1 Byte(1字节)

  Byte - KB - MB - GB - TB - PB - EB - ZB - YB - BB - NB - DB - CB - XB (1024进位)

2.变量

• 概念：计算机内存中的一块存储空间，是存储数据的基本单元。

​ eg：酒店（内存）中有很多房间（变量），房间类型（变量的数据类型）有单人、双人等，独立不重复的门牌号（变量名/内存地址），每个房间的房客（变量存储的值）也不同。

• 组成：数据类型、变量名、值
• 定义：声明和赋值

​ 1）声明：数据类型 变量名;

​ int money; //开辟整数变量空间

​ ①先声明再赋值

​ ②声明并赋值【常用】

​ 2）赋值：变量名 = 值;

​ money = 100; //将整数值赋给变量

• 注意：Java是强类型语言，变量的类型与值的类型必须一致。

3.数据类型

• 基本数据类型（整型、浮点型、布尔型、字符型）

​ 整数

​

​ * Java中任何一个整数，默认的类型为int，如果整数超过int取值范围，则均报错为过大的整数。

​ * long类型的赋值整数如果超过了int类型取值范围，则需要在数字后加 “L“ 以标记为long类型。

public class TestType {
    public static void main(String[] args) {
        // 创建一个bute类型的变量，测试取值范围
        byte b = -128; // 取值范围 -128~127 共计256个数字
        System.out.println(b);
        
        // 创建一个short类型的变量，测试取值范围
        short s = -32768; // 取值范围 -32768~32767 共计65536个数字
        System.out.println(s);
        
        int i = -2147483648; // 取值范围 -2147483648~2147483647
        System.out.println(i);
        
        System.out.println(Long.MAX_VALUE);// long类型的最大正整数值 9223372036854775807
        long l1 = 9223372036854775807L;
        long l2 = 2147483648L;
        System.out.println(l2); //2147483648
        
        System.out.println(l1 + l2); // 数据溢出，变成负数
    }
}

输出：

-128

-32768

-2147483648

9223372036854775807

2147483648

-9223372034707292161

​ 小数

• Java中任意一个小数默认类型为双精度类型double。

• 如果使用单精度float类型，则需要在数字后面加”F“表示单精度值。

public class TestFloatAndDouble {
    public static void main(String[] args) {
        // 单精度浮点数
        float f = 1.2F; // 追加F表示float类型,不可省略
        System.out.println(f);
        
        // 双进度浮点数
        double d = 1.3;
        System.out.println(d);
        
        // 双精度多种赋值方式
        double d2 = 2000;
        System.out.println(d2);
        double d3 = 2000.0;
        System.out.println(d3);
        double d4 = 2000D; // 追加D表示double类型,可省略
        System.out.println(d4);
        
        // 科学计数法赋值
        double d5 = 1.7E308; // 1.7 * 10^308  ---> Double.MAX_VALUE
        System.out.println(d5);
        System.out.println(Double.MIN_VALUE);
        System.out.println(Double.MAX_VALUE);
    }
}

输出：

1.2

1.3

2000.0

2000.0

2000.0

1.7E308

4.9E-324

1.7976931348623157E308

​ 布尔

​ * 可直接赋值 true/false

​ * 也可赋值一个结果为 true/false 的表达式

​ * 注意：Java中的boolean类型变量不能参与算术运算！

​ 字符

​ * char每一个字符在计算机中都会有一个二进制数字对应

​ * char类型支持转义字符 \ 可转义的有：' " \ \n \t

​ * char类型字符是单引号包裹的单个字符

​ * char类型多种赋值方式：

public class TestChar {
    public static void main(String[] args) {
        char c = 'A'; // 字符：通过字符直接赋值【常用】
        System.out.println(c); // A
        
        char c2 = 66; // 整数：通过10进制数66在字符集中对应的字符赋值
        System.out.println(c2); // B
        
        char c3 = '\u0043'; // 整数：通过16进制43在字符集中对应的字符赋值
        System.out.println(c3); // C
        
        // 中文        
        char c4 = '你';
        System.out.println(c4);
        System.out.println((int)c4); // 将c4的中文强转为整数类型
        
        char c5 = 20320; // char 0~65535
        System.out.println(c5);
        
        System.out.println((int)'我'); // (char)25105
        System.out.println((int)'爱'); // (char)29233
        System.out.println((int)'你'); // (char)20320
        System.out.println((char)25105); // 我
        System.out.println((char)29233); // 爱
        System.out.println((char)20320); // 你
        
        // short 整数2个字节   ----   char 整数2个字节
        short s1 = 20320; // -32768~32767, 有符号数，首位为符号位；当首位为1时，此整数为负数
        char  c7 = 20320; // 0~65535, 无符号数

        // 2个字节 16位
        // short的最大整数： 0111 1111 1111 1111 == 32767 首位符号位必须是0
        // char 的最大整数： 1111 1111 1111 1111 == 65535
        
        // char c8 = -1; // error, char为无符号数
        char c9 = 65; // OK
        
        short s2 = 65;
        //char c10 = s2; // error 不可以，short的取值范围中涵盖负数，编译器无法保证s2中一定是个正整数，报检查的错误
        //System.out.prinln(c10);
    }
}

• 引用数据类型 （字符串、数组、对象）

​ 字符串

​ * 任何””之间的内容都是字符串，包括空格。

4.类型转换

• 自动类型转换

​ 1）两种类型互相兼容

​ 2）目标类型大于源类型

• 强制类型转换

​ 1）两种类型互相兼容

​ 2）目标类型小于源类型

​ 3）强转规则：

​ * 整数长度足够，数据完整

​ * 整数长度不够，数据截断

​ * 小数强转整数，数据截断

​ * 字符整数互转，数据完整

​ * boolean类型不能与其他类型进行转换

public class TestConvert {
    public static void main(String[] args) {
        /* 自动类型转换 */
        short s = 123;
        int i = s; //OK
        System.out.println(i);
        
        float f = 3.5F;
        double d = f; //OK
        System.out.println(d);
        
        byte b = 10;
        double d2 = b;//OK
        System.out.println(d2);
        
        float d3 = 100.0F;
        //long l = d3; // ERROR：不兼容的类型，整数无法保留小数的精度
        //System.out.println(l);
        
        System.out.println("------------------------------");
        
        /* 强制类型转换 */
        short s1 = 123;
        byte b1 = (byte)s1;
        System.out.println(b1);//123
        
        float d4 = 100.9F;
        long ll = (long)d4;
        System.out.println(ll);//100
    }
}
public class TestConvert2 {
    public static void main(String[] args) {
        short s = 257;
        byte b = (byte)s;
        System.out.println(b); // 强转 256->0 257->1


        // short 2个字节 16位
        // 257: 0000 0001 0000 0001  --> short
        // 257: ---- ---- 0000 0001  --> byte
        
        short s2 = 128;
        byte b2 = (byte)s2;
        System.out.println(b2); // 强转 128-> -128
    }
}

5.运算符

• 算术运算符：加+ 减- 乘* 除/ 模%
• 一元运算符：自增++ 自减–

​ * 前自增/减：先运算，再取值；

​ * 后自增/减：先取值，再运算；

• 赋值运算符：赋值= 求和赋+= 求差赋-= 求积赋*= 求商赋/= 求余赋%=
• 关系运算符：大于> 小于< 大于等于>= 小于等于<= 等于== 不等于!=
• 逻辑运算符：与&& 或|| 非!
• 三元运算符：布尔表达式 ? 结果1 : 结果2

​ * 布尔表达式为真，取值结果1；为假，取值结果2

public class TestOperation {
    public static void main(String[] args) {
        double score = 100.0;
        
        //1. 逻辑判断
        System.out.println(score == 100.0 ? "真棒！" : "加油！");
        
        //2. 作为变量赋值的表达式
        String result = score == 100.0 ? "真棒！！" : "加油！！";
        System.out.println(result);
        
        //3. 赋值，判断
        int i = score == 100.0 ? 1 : 2;
        System.out.println(i);
    }
}

|| 在线思维导图工具：www.processon.com

|| 免费版可以创建9个

6.自动类型提升

自动类型提升优先级：double >> float >> long >> int << short/byte

• 两个操作数中有一个为优先级中的类型，计算结果提升为优先级中对应类型
• 【特殊】任何类型与String相加(+)时，实为拼接，结果自动提升为String

public class TestTypeUp {
    public static void main(String[] args) {        
        int num1 = 123;
        int num2 = 567;
        String str = "abc";

        // 【坑】两个操作数为数值时，相加；两个操作数中有一个为String时，拼接。
        String newStr = num1 + num2 + str; 
        
        System.out.println(newStr);
    }
}

输出：

690abc

7.控制台输入

• 导入：java.util.Scanner

​ 导包语法：import 包名.类名;

​ 功能：将外部class文件功能引入到自身文件中

​ 位置：jdk1.8.0_121\jre\lib\rt.jar 压缩包中

• 声明：Scanner 类型的变量
• 接收：（输入类型）

​ .nextInt(); // 获得整数

​ .nextDouble(); // 获得小数

​ .next(); // 获得字符串

​ .next().charAt(0); // 获得字符串的第一个字符

【注意】如果输入了不匹配的数据，则会产生 java.util.InputMismatchException 异常。

// package xxx.xxx;  包的声明，要求写在源文件的首行

// import 关键字的引入，写在package之后
// 1.引入JDK提供的一个扫描仪的工具
import java.util.Scanner;

public class TestScanner {
    public static void main(String[] args) {
        // 2. 声明 Scanner
        Scanner input = new Scanner(System.in); // 引用数据类型的声明方式
        
        System.out.print("请输入一个值：");
        // 3. 使用：基于Scanner类型的变量名 .nextInt();
        // 可以在控制台接收一个整数的值，并保存在变量中
        int i = input.nextInt();
        
        System.out.println("您输入的值为：" + i);
    }
}