Java语言基础（变量，数据类型）

怼烎@ 2023-09-26 09:27 35阅读 0赞

**目录**

Java语言基础

一、变量的概念

二、变量的定义和使用

三、数据类型

3.1 概述

3.2 基本数据类型

3.3 引用数据类型

四、类型转换

五、运算符

5.1 算术运算符

5.2 一元运算符(单目运算符)

5.3 赋值运算符

5.4 关系运算符

5.5 逻辑运算符

5.6 三元运算符

六、表达式

七、多种类型混合运算的结果类型

八、控制台输入

## Java语言基础 ##

### 一、变量的概念 ###

> 变量是计算机内存中的一块存储空间，是存储数据的基本单元。
> 
> 要素：
> 
>  *  数据类型，作用是用来定义能够存储的内容的范围。
>  *  变量名，作用是用来定位所要操作的内容。
>  *  值，最终存储的内容。
>  *  隐含要素：地址，

### 二、变量的定义和使用 ###

> 1、先声明，后赋值

public class Test1 {
        public static void main(String[] args) {
            // 先声明
            int num; // int类型，整数，num变量名
    
            // 后赋值，使用=作为赋值符号
            num = 5;
            
            // 打印变量中的值
            System.out.println(num);
        }
    }

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

> 2、声明的同时赋值

public class Test1 {
        public static void main(String[] args) {
            // 声明的同时赋值
            int num1 = 10;
            // 打印变量中的值
            System.out.println(num1);
        }
    }

> 3、多个同类型的变量同时声明并赋值，（不推荐使用）

public class Test1 {
        public static void main(String[] args) {
            // 多个变量同时声明并赋值（不推荐使用）
            int n1 = 3, n2 = 5, n3 = 7, n4 = 9;
            System.out.println(n1);
            System.out.println(n3);
        }
    }

### 三、数据类型 ###

#### 3.1 概述 ####

> Java是强类型语言。
> 
> 类型分为两大类：
> 
>  *  基本数据类型
>     
>      *  整数
>      *  小数
>      *  布尔
>      *  字符
>  *  引用数据类型
>     
>      *  字符串
>      *  数组
>      *  自定义类型和系统定义的类型

#### 3.2 基本数据类型 ####

3.2.1 整数

> byte：byte类型，1字节，-128 ~ 127，-2^7 ~ 2^7-1
> 
> short：short类型，2字节，-32768 ~ 32767，-2^15 ~ 2^15-1
> 
> int：int类型，4字节，-2147483648 ~ 2147483647，-2^31 ~ 2^31-1
> 
> long：long类型，8字节，-2^63 ~ 2^63-1

// 整数类型
    public class Test1 {
        public static void main(String[] args) {
            // byte类型，1字节，-128 ~ 127，-2^7 ~ 2^7-1
            byte num = -128;
            System.out.println(num);
            
            // short类型，2字节，-32768 ~ 32767，-2^15 ~ 2^15-1
            short num2 = 32767;
            System.out.println(num2);
            
            // int类型，4字节，-2147483648 ~ 2147483647，-2^31 ~ 2^31-1
            int num3 = 2147483647;
            System.out.println(num3);
            
            // long类型，8字节，-2^63 ~ 2^63-1
            long num4 = 9223372036854775807L;
            System.out.println(num4);
            
            // 注意：程序中直接使用的整数默认为int类型，
            // 所以当需要写一个长整形时需要在数字的最后加一个字母L(大小写均可)
        }
    }

> 注意：程序中直接使用的整数默认为int类型，所以当需要写一个长整形时需要在数字的最后加一个字母L(大小写均可)

3.2.2 小数（浮点数）

> float：单精度浮点数，4个字节， 负数的范围：-3.4E38~-1.4E-45，正数范围：1.4E-45~3.4E38
> 
> double：双精度浮点数，8个字节，负数的范围：-1.7E308~-4.9E-324，正数范围：4.9E-324~1.7E308

// 小数类型
    public class Test2 {
        public static void main(String[] args) {
            // float，单精度浮点数，4个字节， 负数的范围：-3.4E38~-1.4E-45，正数范围：1.4E-45~3.4E38
            float f1 = 34795.9375678F;
            System.out.println(f1);
            
            // double，双精度浮点数，8个字节，负数的范围：-1.7E308~-4.9E-324，正数范围：4.9E-324~1.7E308
            double d1 = 3.1415926535897932384626;
            System.out.println(d1);
            
            // 浮点数不精确
            System.out.println(1.0-0.9);
            // 注意：小数默认是double，如果要定义一个float，需要在数字最后加上字母F(大小写均可)
        }
    }

> 注意：
> 
>  *  小数默认是double，如果要定义一个float，需要在数字最后加上字母F(大小写均可)
>  *  浮点数运算不精确
>  *  float比long范围要更大

3.2.3 布尔

> boolean：布尔类型，boolean，两个值，真true或假false，1个字节

// 布尔类型
    public class Test3 {
        public static void main(String[] args) {
            // 布尔类型，boolean，两个值，真true或假false，1个字节
            boolean b = true;
            b = false;
            b = 5 > 3; // 用表达式赋值
            System.out.println(b);
            // 注意：boolean类型不能参与运算，不能转换成其他类型
        }
    }

> 注意：boolean类型不能参与运算，不能转换成其他类型

3.2.4 字符

> 字符编码，字符集：
> 
> ASCII：美国标准信息交换码，1个字节，低位表示数字字母符号，高位表示制表符。
> 
> GB2312：简体中文，使用2字节，使用高位的一部分表示。
> 
> GBK：简体中文，范围比GB2312广，使用2字节，使用高位中绝大部分表示。
> 
> GB18030，包含更广泛的中文，还包含少数民族的文字。
> 
> Unicode：万国码，使用2字节表示，Java中的字符使用此方式。
> 
> UTF-8：统一传输格式，使用1个字节表示英文，使用3-4个字节表示其他国家文字。

> 注意：乱码出现的原因是输入的字符编码与输出的编码不一致导致的。

// 字符类型
    public class Test4 {
        public static void main(String[] args) {
            // 字符类型，2个字节，万国码，使用单引号表示，可以作为数字表示，范围为0~65535
            char ch = 'A';
            int n = 'A';
            char ch1 = 65; // 字符A
            System.out.println(ch);
            
            char ch2 = '中';
            // \\u表示万国码
            char ch3 = '\u4f01';
            System.out.println(ch3);
        }
    }

> 转义字符：
> 
> `\n` 换行
> 
> `\t` 一个制表符
> 
> `\\` 表示一个`\`
> 
> `\'` 表示单引号
> 
> `\"` 表示双引号

// 字符类型
    public class Test4 {
        public static void main(String[] args) {
            // 转义字符，
            char ch5 = '\n'; // 换行
            System.out.print(ch5);
            char ch4 = '\'';
            System.out.println(ch4);
            char ch6 = '\t';
            char ch7 = 'a';
            System.out.print(ch6);
            System.out.print(ch7);
        }
    }

#### 3.3 引用数据类型 ####

> 所有的非基本数据类型的称为引用数据类型。例如：字符串、数组、自定义类型等。
> 
> 字符串类型是系统自带的类型，可以由多个字符组成，使用双引号来引用。

// 字符串类型
    public class Test5 {
        public static void main(String[] args) {
            // 字符串，可以由多个字符组成，使用双引号，内容长度可以为0或者多个
            String str = "Hello    world";
            char ch = 'n';
            System.out.println(str);
        }
    }

### 四、类型转换 ###

> 1、自动类型转换
> 
>  *  类型兼容
>  *  目标类型范围要大于源类型
> 
> 2、强制类型转换
> 
>  *  类型兼容
>  *  目标类型范围要小于源类型

// 自动类型转换
    public class Test6 {
        public static void main(String[] args) {
            // 整数的类型转换
            
            short sh = 234;
            // 将sh变量中的值赋值给变量n
            int n = sh; // 自动类型转换
            System.out.println(n);
            
            byte b = 120;
            short s1 = b;
            
            long l = n;
            
            char ch = 'B';
            int n1 = ch;        
        }
    }

// 强制类型转换
    public class Test7 {
        public static void main(String[] args) {
            // 整数的类型转换
            
            int n = -129;
    
            // 强制类型转换，如果该值能够存入对应的类型，则无损存入，
            // 如果超出范围，则会进入一个环，超出最大值变为最小值，超出最小值变为最大值
            byte b = (byte)n; // 结果为127
            
            System.out.println(b);
        }
    }

> 整数和小数之间的转换：

// 类型转换
    public class Test8 {
        public static void main(String[] args) {
            // 整数和小数的转换
            // 将整数放入到小数中，自动类型转换
            long l = 3472393742942342347L;
            float f = l;
            System.out.println(f);
            
            // 将小数放入到整数中，强制类型转换
            double d = 3.54;
            int n = (int) d;
            System.out.println(n);
        }
    }

### 五、运算符 ###

#### 5.1 算术运算符 ####

> 加、减、乘、除、余
> 
> 注意：整数除以整数，结果仍是整数。余数可以使用小数、负数之类进行求余。

// 算术运算符
    public class Test9 {
        public static void main(String[] args) {
            // +
            int n = 5 + 3 + 2; // 将5+3的结果赋值到n中
            System.out.println(n);
            // 注意：+还可以用来做字符串拼接
            String str = "hello";
            String str1 = "world";
            String str2 = str + str1;
            System.out.println(str2);
            System.out.println("hello, " + "world" + "!!!");
            System.out.println(str + "，tom");
            System.out.println(str + n); // 所有的类型与字符串相加，都是拼接
            
            // -
            int n1 = 10 - 4;
            System.out.println(n1);
            
            // *
            int n2 = 6 * 6 * 6;
            System.out.println(n2);
            
            // /
            // 注意：在Java中整数除以整数，结果仍是整数
            int n3 = 5 / 2; // 除
            System.out.println(n3); // 结果为2
            
            // 求余  %，优先级与乘除一样
            int n4 = 10 % 3;
            System.out.println(n4);
            double d1 = 4.8 % 2.2;
            System.out.println(d1);
            int n5 = -10 % 3;
            System.out.println(n5);
            int n6 = 10 % -3;
            System.out.println(n6);
            int n7 = -10 % -3;
            System.out.println(n7);
        }
    }

#### 5.2 一元运算符(单目运算符) ####

> 指只需要一个变量就可以使用。
> 
> \++：自增1
> 
> \--：自减1

// 单目运算符
    public class Test10 {
        public static void main(String[] args) {
            // ++，自增1
            int n1 = 5;
            n1++;
            System.out.println(n1);
            
            int n2 = 5;
            ++n2;
            System.out.println(n2);
            
            // --，自减1
            int n3 = 5;
            n3--;
            System.out.println(n3);
            
            int n4 = 5;
            --n4;
            System.out.println(n4);
            
            int m1 = 5;
            // ++ 如果在后面，先将值拿出用来参与运算，后自增1
            int m2 = m1++ + 5;
            // ++ 如果在前面，先自增1，后将结果拿出用来参与运算
    //      int m2 = ++m1 + 5;
            System.out.println(m2);
            System.out.println(m1);
            
            int m3 = 5;
            // m4 = 5 + 6 + 7;
    //      int m4 = m3++ + m3++ + m3++;
            // m4 = 5 + 6 + 5 + 6 + 5;
    //      int m4 = m3++ + m3-- + m3++ + m3-- + m3++;
            // m4 = 5 + 6 + 6 + 6 + 5;
            int m4 = m3++ + m3-- + (++m3 + m3--) + m3++;
            System.out.println(m4);
            System.out.println(m3);
        }
    }

#### 5.3 赋值运算符 ####

> 先运算，后赋值

// 赋值运算符
    public class Test11 {
        public static void main(String[] args) {
            // =
            int n = 5;
            n += 6; // 等同于n = n + 6;
            System.out.println(n);
            int m = 6;
            m++; // 自增1，相当于m = m + 1;
            m+=2; // 自增2
            
            int m1 = 4;
            m1 -= 5; // 自减5，相当于m1 = m1 - 5;
            
            int m2 = 6;
            m2 *= 3; // 相当于m2 = m2 * 3;
            
            int m3 = 3;
            m3 /= 2; // 相当于m3 = m3 / 3;
            System.out.println(m3);
            
            int m4 = 6;
            m4 %= 4; // 相当于m4 = m4 % 4;
            System.out.println(m4);
            
            // b++和b+=1会隐式类型转换，而b=b+1需要强制类型转换
            byte b = 127;
            // b++; 与 b += 1; b = b + 1;
            b++;
            System.out.println(b);
        }
    }

> 经典面试题：
> 
> byte b = 1;
> 
> b++;与b = b + 1;区别？
> 
> 答：b++和b+=1会隐式类型转换，而b=b+1需要强制类型转换，否则会报错。

#### 5.4 关系运算符 ####

> 注意：
> 
>  *  ==等于，不等于是!=
>  *  boolean b3 = 10 > n2 > 5; // 代码错误，不能连续比较

// 关系运算符
    public class Test12 {
        public static void main(String[] args) {
            // >、<、>=、<=与数学中一样
            boolean b = 5 >= 3;
            System.out.println(b);
            
            int n = 5;
            boolean b1 = n == 5; // 等于
            System.out.println(b1);
            boolean b2 = n != 5; // 不等于
            System.out.println(b2);
            
            int n2 = 7;
            
        
            // 注意：==等于，不等于是!=，
            //      boolean b3 = 10 > n2 > 5; // 不能连续比较
        }
    }

#### 5.5 逻辑运算符 ####

// 逻辑运算符
    public class Test13 {
        public static void main(String[] args) {
            // and
            int n = 7;
            boolean b = n > 5 && n < 10; // 并且，两个条件同时成立
            System.out.println(b);
            
    //      boolean b1 = n > 5;
    //      boolean b2 = n < 10;
    //      boolean b3 = b1 && b2;
            
            boolean b1 = n > 5 || n < 7; // 或者，两个条件有一个成立即可
            
            // 注意：&& 和 || 有短路的特征。
            // 如果前面一个表达式能表示整个结果，那么后面的表达式不会执行判断
            // & 和 | 计算结果与&&和||相同，但是无论如何都会计算两边的表达式的结果
            
            int n1 = 5;
            boolean b2 = n1 > 3 || n1 / 0 == 3; // 只用|,会计算两边，代码会报错，使用||，代码不会报错，后面的不会计算
            System.out.println(b2);
            
            boolean b3 = !(n1 > 3);
            System.out.println(b3);
            
            // 用来进行算术运算
            int n2 = 5 & 3;
            System.out.println(n2);
        }
    }

> 经典面试题：
> 
> &&和&（|| 和 |）区别？
> 
> 答：
> 
> && 和 || 有短路的特征。 如果前面一个表达式能表示整个结果，那么后面的表达式不会执行判断 & 和 | 计算结果与&&和||相同，但是无论如何都会计算两边的表达式的结果
> 
> &&和||只能作为逻辑运算，而&和|还可以作为算术运算。

#### 5.6 三元运算符 ####

> 语法：布尔表达式?结果1:结果2
> 
> 当布尔表达式为true时，返回结果1，否则返回结果2

// 三目（三元）运算符
    public class Test14 {
        public static void main(String[] args) {
            // ? : 
            // 布尔表达式?结果1:结果2
            // 当布尔表达式为true时，返回结果1，否则返回结果2
            int hp = 250;
            String str = hp > 200 ? "撤退" : "越塔强杀"; 
            System.out.println(str);
            
            int n = hp < 100 ? 3 : 2;
            System.out.println(n);
        }
    }

### 六、表达式 ###

> 表达式：用运算连接的变量或者是字面值，能够计算出一个结果，但是不是一行独立的代码。
> 
> 例如：n > 5 、 a + b

### 七、多种类型混合运算的结果类型 ###

>  *  当基本数据参与运算时，结果为最大范围的变量类型，
>  *  如果多个操作数都是byte或者short类型，结果为int
> 
> 注意：也会遵循四则混合运算的顺序。求余优先级等同于乘除。
> 
> 如果有字符串用+参与，那么结果是字符串。

// 混合运算
    public class Test15 {
        public static void main(String[] args) {
            double d = 5 / 2; // 2.0
            System.out.println(d);
            
            System.out.println("结果为：" + 5 + 2); // 结果为：52
            
            System.out.println("hello, " + 'A' + 1); // hello, A1
        }
    }

### 八、控制台输入 ###

> 接收控制台输入：

import java.util.Scanner;
    
    // 控制台输入
    public class Test16 {
        public static void main(String[] args) {
            // 创建一个控制台扫描对象，用来接收控制台的输入
            Scanner input = new Scanner(System.in);
            
            System.out.println("请输入一个字符串：");
            // nextLine()上面不能有接收整数
            // next()不识别空格
            String str = input.nextLine(); 
            System.out.println(str);
            
            System.out.println("请输入第一个整数：");
            // 接收输入的整数
            int n1 = input.nextInt();
            System.out.println("请输入第二个整数：");
            int n2 = input.nextInt();
            System.out.println("结果为：" + (n1 + n2));
        }
    }