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

目录

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