Java语言基础 | 我的日常分享

Java语言基础

发表于2022-01-18更新于2022-01-18字数统计3.9k阅读时长49分

Java语言基础

一、变量的声明、赋值和应用

  • 声明：

    数据类型 变量名;

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

  • 赋值

    变量名 = 值;

    money = 100;

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

1、变量的三种定义方式

  1. 先声明，再赋值（常用）

    数据类型 变量名;

    变量名 = 值;

    1
    2
    int money;
    money = 100;

  2. 声明并赋值（常用）

    数据类型 变量名 = 值;

    1
    int money = 200;

  3. 多个同类型变量的声明与赋值

    数据类型 变量名1,变量名2,变量名3 = 值3,变量名4 = 值4;

    1
    int a,b,c=100,d=200;

2、数据类型

  • java中的变量具有严格的数据类型区分（强类型语言）
  • 在java语言中，任何一个值都有与其对应类型的变量。

image-20210815230435033

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

3、基本数据类型

  • 整数：

    image-20210815230635977

注意：int为整数值的默认类型，如需为long类型赋值较大整数时，需在值后面追加L,否则默认为int类型，如果超过int的最大值则会报错。通常L为大写，小写l容易被误看为数字1。

1
2
3
4
5
6
public class Test{
    public static void main(String[] args){
        long a = 2147483648;
        System.out.println(a);
    }
}

运行结果：

image-20210815231202261

1
2
3
4
5
6
public class Test{
    public static void main(String[] args){
        long a = 2147483648L;//加了L
        System.out.println(a);
    }
}

运行结果：

image-20210815231355360

  • 浮点数（小数）:
image-20210815231654867

注意：与整数类似，double为浮点数的默认类型，如需为float类型赋值时，需在值后面追加F，通常也书写为大写。

1
2
3
4
5
6
public class Test2{
    public static void main(String[] args){
        float a = 3.14;
        System.out.println(a);
    }
}

运行结果：

image-20210815232155148

1
2
3
4
5
6
public class Test2{
    public static void main(String[] args){
        float a = 3.14F;//加个F
        System.out.println(a);
    }
}

运行结果：

image-20210815232307208

科学计数法：

浮点数值采用科学计数法表示：

2E3等价于2*10^3结果为2000.0;3E5等价于3*10^5结果300000.0。

image-20220115213627963

1
2
3
4
5
6
7
8
public class Test3{
    public static void main(String[] args){
        float a = 3E5F;//追加F代表float的意思
        double b = 3E5;
        System.out.println(a);
        System.out.println(b);
    }
}

运行结果：

image-20220115214016145

  • 布尔：

    image-20210815232438536

1
2
3
4
5
6
public class Test3{
    public static void main(String[] args){
        boolean a = true;
        System.out.println(a);
    }
}

运行结果：

image-20210815232654717

Java中的boolean不能参与算术运算。

  • 字符：

    前置知识1：

    • ASCII（American Standard Code for Informatica Interchange）美国信息交换标准代码

    • 基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言

    • ASCII是最通用的信息交换标准，为英文字符设定了统一并且唯一的二进制编码。

      image-20220115220747192

    前置知识2：

    • Unicode（万国码）是计算机科学领域里的一项业界标准，包括字符集、编码方案等。

    • 它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求，（其中包括了ASCCII）。

      部分字符编码：

      image-20220115221242608

      image-20210815232944868

    Unicode中每个字符都对应一个二进制整数，可以使用多种方式赋值。

    • 字符赋值：char c1='A';（通过''描述为字符赋值）
    • 整数赋值：char c2=65;（通过十进制数65在字符集中对应的字符赋值）
    • 进制赋值：char c3='\u0041';（通过十六进制数41在字符集中所对应的字符赋值）

    案例1：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Test4{
        public static void main(String[] args){
    		char c = 'a';
            System.out.println(c);
            int a = c;
    		System.out.println(a);
    		long b = a;
            System.out.println(b);
        }
    }

    运行结果：

    image-20220116095425429

    案例2：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class Test5{
    	public static void main(String[] args){
    		char c1 = 'a';//字符赋值
    		System.out.println(c1);
    		char c2 = 97 ;//整数赋值
    		System.out.println(c2);
    		char c3 = '\u0061';//进制赋值 61十进制是97
    		System.out.println(c3);
    	}
    }

    运行结果：

    image-20220116100332702

    后置知识–转义字符：

    案例1：在程序中输出一个单引号字符。

    1
    2
    3
    4
    5
    public class Test6{
    	public static void main(String[] args){
    		char c = ''';//编译错误
    	}
    }

    运行结果：

    image-20220116100759517

    为了解决这个问题，java采用了转义字符来表示字符和一些特殊符号。

    image-20210815233102627

    案例2：解决方案-使用转义字符

    1
    2
    3
    4
    5
    6
    7
    public class Test6{
    	public static void main(String[] args){
    		//char c = ''';//编译错误
    		char c1 = '\'';
    		System.out.println(c1);
    	}
    }

    运行结果：编译运行成功

    image-20220116101107975

    案例3：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    public class Test6{
    	public static void main(String[] args){
    		//char c = ''';//编译错误
    		char c1 = '\'';
    		System.out.println(c1);
    	}
    }
    class Test7{
    		public static void main(String[] args){
    		System.out.println('\"');//双引号字符
    		System.out.println("\"");//双引号字符串
    		System.out.println('\\');//反斜杠字符
    		System.out.println("\\");//反斜杠字符串
    		System.out.println("\u0041");//输出字符串a
    		System.out.println("u0041");//输出字符串u0041
    		System.out.println("Hello\tworld!");//在Hello与world！之间使用制表位
    	}
    }

    运行结果：

    image-20220116101903962

4、引用数据类型

  1. 字符串

    类型 取值范围 字符编码
    String 任何双引号“”之间的字面值 Unicode字符序列
    • String类型的字面取值：
      • String str1 = "你好";
      • String str2 = "Hello";
      • String str3 = "Java PHP Python C C++ C# HTML";

    案例1：

    1
    2
    3
    4
    5
    6
    7
    public class TestString{
    	public static void main(String[] args){
    		String s1 = "Hello";
    		System.out.println(s1);
    		System.out.println("你好");
    	}
    }

    运行结果：

    image-20220116103002840

5、类型转换

  1. 自动类型转换

    • 两种类型相互兼容
    • 目标类型大于源类型（等号=左边类型大于右边类型）
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    public class TestAutoConvert{
    	public static void main(String[] args){
    		//整数->整数
    		short s = 123;
    		int i = s;//将原类型short值存入到目标类型int变量中（自动类型转换）
    		System.out.println(i);
    		
    		byte b = 50;
    		short s2 = b;//自动类型转换，byte类型自动转换为short类型
    		System.out.println(s2);
    		
    		//小数->小数
    		float f = 100.2F;
    		double d = f;//自动类型转换，float转换为double类型。
    		System.out.println(d);
    		
    		//整数->小数
    		int i2 = 98;
    		double d2 = i2;
    		System.out.println(d2);
    		
    		//字符->整数
    		char c1 = 'a';
    		int i3 = c1;
    		System.out.println(i3);
    				
    		//字符->小数
    		char c2 = 'a';
    		double d3 = c2;
    		System.out.println(d3);
    		
    		//boolean类型无法与任何类型进行自动类型转换
    	}
    }

    运行结果：

    image-20220116221645568

    问题：为什么byte(1字节)不能自动类型转换为char（2字节）.

    1
    2
    3
    byte b4 = 65;
    char c2 = b4;
    System.out.println(c2);

    在强制类型转换案例6中做了解释。

    运行结果：

    image-20220116222417582

  2. 强制类型转换

    • 两种类型相互兼容
    • 目标类型小于源类型
    1
    2
    3
    4
    5
    6
    7
    8
    public class Test5{
        public static void main(String[] args){
    		short s = 123;
    		//byte b = s;//自动转化失败，编译错误
    		byte c = (byte)s;//需要用强制类型转换
    		System.out.println(c);
        }
    }

    运行结果：

    image-20210815234338981

image-20210815234448490

案例1：长度足够，数据完整，输出正常。

1
2
3
4
5
6
7
public class TestForceConvert{
	public static void main(String[] args){
		short s1 = 126;
		byte b1 = (byte)s1;
		System.out.println(b1);
	}
}

运行结果：

image-20220116230427340

分析：

image-20220116231424200

强制类型转换将short转换为byte，short占用2字节，而byte占用1字节，于是将上图中高位进行截断，也就是红线左侧部分舍去，将绿色框框内的二进制赋值给byte类型变量中。而short类型的实际值126没有超过byte类型变量的取值范围，所以数据是完整的，输出正常。

案例2：长度不够，数据不完整，输出不正常。

1
2
3
4
5
6
7
public class TestForceConvert{
	public static void main(String[] args){
		short s1 = 257;
		byte b1 = (byte)s1;
		System.out.println(b1);
	}
}

运行结果：输出结果为1

image-20220116232408675

分析：

image-20220116232336502

byte类型只能存1字节数据，于是short类型中高位的数据被截断，仅仅只有绿色框中的数据被存入byte类型变量中，而short类型中的高位恰好存储有数据，于是byte中存入的数据不完整，造成了输出不正常，byte类型变量存入的二进制数据为0000 0001，转成十进制正好为1。

案例3：高位截断造成符号位改变。

1
2
3
4
5
6
7
public class TestForceConvert{
	public static void main(String[] args){
		short s1 = 130;
		byte b1 = (byte)s1;
		System.out.println(b1);
	}
}

运行结果：

image-20220116233216279

分析：

image-20220116233048525

short类型大小2字节，最高位第16位代表符号位，而byte类型大小1字节，最高位第8位代表符号位，而short类型大小1字节，最高位第8位为符号位，short变量130的二进制第8位为1，高位截断，仅仅将绿色框框的值给了byte类型变量，于是byte类型变量第8位为1，所以为负数-126。

案例4：小数强制类型转换为整数

直接去掉小数部分，保留整数部分。

1
2
3
4
5
6
7
8
9
10
public class TestForceConvert{
	public static void main(String[] args){
		double d1 = 2.99;
		double d2 = 2.44;
		int i1 = (int)d1;
		int i2 = (int)d2;
		System.out.println(i1);
		System.out.println(i2);
	}
}

运行结果：

image-20220117215753699

案例5：字符转换为整数自动类型转换，整数强制类型转换为字符。

1
2
3
4
5
6
7
8
9
10
11
public class TestForceConvert{
	public static void main(String[] args){
		char c1 = 'a';
		int i1 = c1;//自动类型转换
		System.out.println(i1);

		int i2 = 65;
		char c2 = (char)i2;//强制类型转换
		System.out.println(c2);
	}
}

运行结果：

image-20220117220952820

案例6：字符与整数转换的注意事项。

char类型是Unicode编码，取值范围是0~65535，要大于0，如果要保证正常显示字符，赋给插入类型的整数变量需要大于等于0。如果小于0输入的全为?号。

1
2
3
4
5
6
7
8
9
10
11
public class TestForceConvert{
	public static void main(String[] args){
		short s1 = 65;
		char c1 = (char)s1;
		System.out.println(c1);//打印正常值

		short s2 = -2;
		char c2 = (char)s2;
		System.out.println(c2);//打印正常值
	}
}

运行结果：

image-20220117224126441

从案例6中可以看出，char的取值范围为0~65535，这就可以解释为什么char c = 65;是可以自动类型转换，而int/byte/short num=65;char c=num;会报错，必须手动进行强制类型转换才行，这是因为char类型与int/byte/short类型的取值范围不兼容，虽然说byte大小1字节比char2字节小，但是int/byte/short的取值返回都包括负数，而char类型不能为取值范围没有负数，这个就是自动类型转换的两个条件1. 两个类型要兼容 2.目标类型大于源类型 中的两个类型不兼容，因为取值返回不一致。

特别地，boolean取值true与false，不可与其他类型转换。

二、运算符与表达式

1、算术运算符

image-20210816152738875

案例1 ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Test{
	public static void main(String[] args) {
		int a = 10;
		int b = 3;
		System.out.println(a/b);

		double c = 10.0;
		int d = 3;
		System.out.println(c/d);
		//取余
		System.out.println(10 % 3);
		System.out.println(10.3 % 3);
		System.out.println(10.3F % 3);
	}
}

运行结果：

image-20220117230652037

如果都为整数相除为3，其中有一个为小数则计算结果为小数，这与后面要讲的自动类型提升有关。

案例2：一元运算符

1
2
3
4
5
6
7
8
9
10
public class Test6{
    public static void main(String[] args){
		int a = 10;
		System.out.println(a++);//先打印当前，再自增
		System.out.println(a);
		int b = 20;
		System.out.println(++b);//先自增，再打印值
		System.out.println(b);
    }
}

运行结果：

image-20210816154310342

如果仅仅执行++或--，++i与i++或--i与i--没有区别。如下示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
class Test1{
	public static void main(String[] args) {
		int a=0;
		a++;
		++a;//a++与++a无区别
		System.out.println(a);

		int b = 10;
		b--;
		--b;//b--与--b无区别
		System.out.println(b++);
	}
}

运行结果：

image-20220117231600312

2、赋值运算符

image-20210816155049326 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Test2{
    public static void main(String[] args) {
        int a = 10;
        a += 5;//等效与a=a+5;
        System.out.println(a);

        int b = 20;
        b -= 6;//等效与b=b-6;
        System.out.println(b);
        
        int c = 40;
        c %= 3;//等效与c=c%3;
        System.out.println(c);

        int d = 40;
        d /= 3;//等效与d=d/3;
        System.out.println(d);
    }
}

运行结果：

image-20220118163723495

3、关系运算符

image-20210816155147364 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test3{
    public static void main(String[] args) {
        int a = 4;
        int b = 9;

        System.out.println(a>b);
        System.out.println(a<b);

        System.out.println(a>=b);
        System.out.println(a<=b);
        
        System.out.println(a == b);
        System.out.println(a != b);
    }
}

运行结果：

image-20220118164229306

4、逻辑运算符

image-20210816155332783 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test4{
    public static void main(String[] args) {
        int javaScore = 100;
        int webScore = 99;

        //分别判断二者是否为满分
        System.out.println(javaScore == 100);
        System.out.println(webScore == 100);

        //一次性判断二者是否为满分
        System.out.println(javaScore == 100 && webScore == 100);

        //一次性判断二者中是否有一个满分
        System.out.println(javaScore == 100 || webScore == 100);

        boolean result = javaScore == 100;
        //java成绩是满分吗？
        System.out.println(result);
        //java成绩不是满分吗？
        System.out.println(!result);

    }
}

运行结果：

image-20220118215008556

5、三元运算符

image-20210816155412796 
1
2
3
4
5
6
public class Test7{
    public static void main(String[] args){
		String s = 4 > 3 ? "是的" : "不是";
		System.out.println(s);
    }
}

运行结果：

image-20210816155808871

6、表达式

  • 使用运算符连接的变量或字面值，并可以得到一个最终结果。

  • 例如：

image-20210816160008116

7、自动类型提升

  • 进行算数运算时：
    • 两个操作数有一个为double，计算结果提升为double
    • 如果操作数没有double，有一个为float，计算结果提升为float
    • 如果操作数没有float，有一个为long，计算结果提升为long
    • 如果操作数没有long，有一个为int，计算结果提升为int
    • 如果操作数中没有int，均为short或byte，或一个short与一个byte，计算结果仍旧提升为int，这是因为short与byte本身字节大小较小，相加很容易超过自身的范围。
  • 特殊：任何类型与String相加（+），实则为拼接，其结果自动提升为String

8、与String拼接的类型提升

1
2
3
4
5
6
7
8
9
public class Test1{
    public static void main(String[] args) {
        int javaScore = 98;
        String str = "java的成绩是" + javaScore;

        System.out.println(str);
        System.out.println("java的成绩是" + javaScore);
    }
}

运行结果：

image-20220118221222252

三、控制台输入

  • 程序运行中，可在控制台（终端）手动录入数据，再让程序继续运行。
  • 导包语法：import 包名.类名;//将外部class文件的功能引入到自身文件中。
image-20210816162301644 image-20210816162319129

在rt.jar/java/util/Scanner下。

  • 使用顺序：

    • 导入 java.util.Scanner

    • 声明Scanner类型变量

    • 使用Scanner类中对应的方法（区分类型）：

      .nextInt() 获取整数

      .nextDouble()获取小数

      .next()获取字符串

      .next().charAt(0)获取单个字符（接受一个字符串，获取字符串的第0个字符。）

    • 注意：如果输入了不匹配的数据，则会产生java.util.InputMismastchException异常

案例1：如何使用？

1
2
3
4
5
6
7
8
9
10
11
import java.util.Scanner;//1.引入外部文件
public class Test8{
    public static void main(String[] args){
			//2.声明Scanner类型的变量
			Scanner input = new Scanner(System.in);
			//写一个提示
			System.out.println("请输入一个整数");
			int i = input.nextInt();//3.使用.nextInt 控制台获取一个整数
			System.out.println("您输入的值为："+i);
    }
}

运行结果：

GIF

案例2：获取小数、字符串、字符

1
2
3
4
5
6
7
8
9
10
11
12
13
class Test9{
    public static void main(String[] args){
			Scanner input = new Scanner(System.in);
			//写一个提示
			System.out.println("请输入：");
			double a = input.nextDouble();//获取小数
			System.out.println("您输入的值为："+a);
			String b = input.next();//获取字符串
			System.out.println("您输入的值为："+b);
			char c = input.next().charAt(0);//获取字符
			System.out.println("您输入的值为："+c);
    }
}

运行结果：

image-20220118224817547