2.基础语法

关于 AI
木偶AI正在绞尽脑汁想思路ING···
木偶のAI摘要
DeepSeek-Chat

一. 语法结构

img

1
2
3
4
5
public class Demo{
	public static void main(String[] args) {
		System.out.println("你好，java");
	}
}

说明：

  • Demo ：表示一个类，类名为 Demo，与文件名相同
  • public： 表示一个公有的类
  • public static void main：表示一个主方法，即程序的入口（固定写法）
  • System.out.println("你好，java"); ： 表示输出到屏幕，“；”表示语句结束
  1. Java 语言严格区分大小写；
  2. 每个语句都必须以 “ ；” 结束；
  3. 括号都是成对出现的；
  4. 一个源文件只能有 一个 public类，其他类的数量不限；
  5. 每一个类在编译完成后，都会生成一个 “ .class ” 文件
  6. 如果原文件包含 public 类，则文件名必须与 类名相同；

二. 常用的转义字符

字符 说明 案例 运行结果
\t 制表符 System.out.println(“北京\t 天津\t 上海”); 北京 天津 上海
\n 换行符 System.out.println(“北京\n 天津\n 上海”); 北京天津上海
\ \ System.out.println(“北京\n 天津\t 上海”); 北京\n 天津\t 上海
\” “ System.out.println(“\”北京\””); “北京”
\’ ‘ System.out.println(“\’北京\’”); ‘北京’
\r 回车 System.out.println(“北\r 京”); 京

三. 注释

文档注释

Javadoc 是 Sun 公司提供的一个技术，从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的 API 帮助文档

1
2
3
4
5
/**
 * @author Pupper
 * @version 1.0
 * @......
*/
标签 说明
@author 作者
@version 版本号
@return 函数返回值
@see 引用，查看相关的内容，如类，方法，变量等，必须顶头写
@throws 构造函数或方法会抛出的异常
@param 方法的参数

单行、多行注释

1
2
3
4
// 这是一段注释
/*
这是一段多行注释
*/

四、变量

1
2
3
4
int a;
a = 12;

int b = 3;

  1. 变量：表示内存中的一个存储区域

    1. 不同的变量，类型不同，占用的区域大小也不用

  3. 变量必须先声明，后使用

  4. 变量在同一个作用域内不能重名

五、+ 号的使用

  1. 当左右两边都是 数值 类型时，则做 加法运算
  2. 当左右两边有一方为 字符串 类型时，则做 拼接运算
1
2
3
4
5
6
7
8
9
10
public class demo01{
	public static void main(String[] args) {
		System.out.println(10 + 20);
		System.out.println("10" + 20);
		System.out.println(10 + "20");
	}
}
30
1020
1020

六、数据类型

img

1. 整数（byte、short、int、long）

类型 占用空间（字节） 范围
byte（字节） 1 -128 ~ 127
short（短整型） 2 -215 ~ 215 - 1（-32768 ~ 32767）
int（整型） 4 -231 ~ 231 - 1（-2147483648 ~ 2147483647）
long（长整型） 8 -263 ~ 263 - 1

  1. 一般的整型变量 默认为 int 类型

    1. int a = 10;

  3. long 整型的写法 “ L” 一般为大写

    1. long a = 100L;
    2. 错误写法： int a = 100L;

2. 浮点型（flost、double）

类型 占用空间（字节） 范围
flost（单精度） 4 -3.403E38 ~ 3.403E38
double（双精度） 8 -1.798E308 ~ 1.798E308

  1. 浮点型常量默认为 double 类型

    1. 声明 flost 类型时，需要加 “F”
    2. flost a = 3.14F；

  3. double 的精度大于 flost 的精度，通常采用 double 类型

不要直接使用计算结果为小数的值进行判断，应该是以小数差值的绝对值，在某个精度范围内做判断

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class demo01{
	public static void main(String[] args) {
		double a = 2.7;
		double b = 8.1 / 3;
		if( a == b ){
			System.out.println("相对");
		}else if(Math.abs(a - b) < 0.000001){
			System.out.println("绝对值的差值足够小，可以看做是相等的");
		}else{
			System.out.println(a);
			System.out.println(b);
		}
	}
}

// 运行结果
绝对值的差值足够小，可以看做是相等的

3. 字符类型（char）

char 表示单个字符，多个字符时使用 String 类型

ASCII 码 ：a ： 97 A： 65

1
2
3
char a = 'a';
char b = '\t';
char c = '汉';

  1. 字符常量是用 单引号（’’）括起来的单个字符

    1. 不能使用 双引号（””），所有使用双引号的都表示字符串

  3. 可以直接给 char 赋一个整数，输出时会按照 unicode 编码 输出字符

4. 布尔型（boolean）

  1. boolean 类型 的数据只有 true 和 false
  2. 在运算符中，true 相当于 1， false 相当于 0

七. 基本类型转换

1. 自动类型转换

自动类型转换： 当 java 程序在进行赋值或运算时，精度小的类型自动转换为精度大的数据类型。

img

自动类型转换细节：

  1. 多种类型的数据混合运算时，系统会将所有数据转换成容量最大的数据类型，然后进行计算。
  2. 把精度大的数据类型赋值给精度小的数据类型时，会报错
  3. byte 、short 和 char 之间不能进行数据转换
  4. byte、short、char 三者在计算时，首先转换为 int 类型
  5. boolean 不参与转换
  6. 自动提升原则：表达式结果的类型自动提升为 操作数中最大的类型

2. 强制类型转换

强制类型转换： 将容量大的数据类型转换为容量小的数据类型

使用时需要加上 强制类型转换符（），可能会造成数据 精度降低 或 溢出

1
2
3
4
5
6
7
8
// 精度降低
int i = (int)1.9;
System.out.println(i);		// 1

// 数据溢出
int j = 130;
byte b1 = (byte)j;
System.out.println(b1);		// -126
  1. 强转符号只对最近的操作数有效，可以使用小括号提升优先级
  2. char 类型可以保存 int 的常量值，不能保存 int 的变量值，需要强转
  3. byte 和 short 类型在进行运算时，当做 int 类型处理
1
2
3
4
5
int x = (int)10*3.5 + 6*1.5;
int y = (int)(10*3.5 + 6*1.5);

System.out.println(x);	// 报错，flost 转 int 需要强转
System.out.println(y);	// 44

八. 基本数据类型和 String 类型的转换

1. 基本类型转 String 类型

格式： 基本数据类型 + “”;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class StringToBasic {
    public static void main(String[] args){
        int n1 = 100;
        float f1 = 1.1F;
        double d1 = 4.1;
        boolean b1 = true;

        String s1 = n1 + "";
        String s2 = f1 + "";
        String s3 = d1 + "";
        String s4 = b1 + "";

        System.out.println(s1+s2+s3+s4);	// 1001.14.1true
    }
}

2. String 类型 转 基本数据类型

String 类型转基本类型，需要 包装类调用 parse 方法 即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class demo01{
	public static void main(String[] args) {
		String s1 = "123";
		String s2 = "3.14";
		String s3 = "true";

		int n1 = Integer.parseInt(s1);
		float f1 = Float.parseFloat(s2);
		boolean c1 = Boolean.parseBoolean(s3);

		System.out.println(n1);		// 123
		System.out.println(f1);		// 3.14
		System.out.println(c1);		// true
	}
}

九、运算符

1. 算术运算符

运算符 说明 案例 结果
% 取余 11%9 2
++x 自增：先运算后取值 a = 2;b = ++a; a = 3, b = 3
x++ 自增：先取值后运算 a = 2;b = ++a; a = 3, b = 2
—x 自减： 先运算后取值 a = 2; b = —a; a = 1; b = 1
x— 自减： 先取值后运算 a = 2; b = a—; a = 1; b = 2

2. 关系运算符

关系运算符的运算结果 为 true 和 false

运算符 说明 案例 结果
instanceof 检查是否是类的对象 “hsp” instanceof String true

3. 逻辑运算符

短路 和 逻辑 的区别：

  • 短路：当第一个条件已经能够确定结果时，后边的语句将不再执行，代码执行效率高；
  • 逻辑： 不论第一个条件是否能确定结果，后边的语句会全部执行，代码执行效率低；
运算符 说明 规则
& 逻辑： 与 全真为真，一假全假
&& 短路： 与 全真为真，一假全假
\ 逻辑： 或 一真为真，全假为假
\ \ 短路： 或 一真为真，全假为假
！ 逻辑： 取反 非真即假
^ 逻辑： 异或 不同为真，相同为假
a b a&b a&&b a\ b a\ \ b !a a^b
true true true true true true false false
true false false false true true false true
false true false false true true true true
false false false false false false true false

4. 赋值运算符

符合运算符：

运算符 说明
+= a += b，等价于 a = a + b；
-= a -= b，等价于 a = a - b；
*= a = b，等价于 a = a b；
/= a /= b，等价于 a = a / b；
%= a %= b，等价于 a = a % b；

复合赋值运算符在使用时，底层会进行强制类型转换

如：

byte a = 10;

a += 5; 相当于 a = (byte)(a + 5)

5. 三元运算符

语法：

条件表达式 ？ 表达式 1 ： 表达式 2

说明：

  1. 如果条件表达式结果为 true，运算后的结果是 表达式 1；
  2. 如果条件表达式结果为 false， 运算后的结果是 表达式 2；
1
2
3
4
5
6
7
8
public class Demo {
    public static void main (String[] args){
        int a = 10;
        int b = 99;
        int result = a > b ? a++ : b--;
        System.out.println(result);		// 99
    }
}

十、标识符命名规范

命名包含：字母、数字、下划线，不能以字母开头

规范：

  • 包名： 多个单词组成时，所有字母都小写；
  • 类名、接口名： 多个单词组成时，所有单词的首字母大写；
  • 变量名、方法名： 首个单词的首字母小写，剩下的首字母都大写；
  • 常量： 所有字母都大写，单词之间以下划线连接；

十一、键盘输入语句

Scanner ： 用于获取键盘输入语句

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 引入 scanner
import java.util.Scanner;

public class demo01{
	public static void main(String[] args) {
		// 创建 scanner 对象
		Scanner myScanner = new Scanner(System.in);

		// 使用相关关键字，接收用户输入
		System.out.println("请输入姓名：");
		String name = myScanner.next();		// 接收用户输入

		System.out.println("请输入年龄：");
		int age = myScanner.nextInt();

		System.out.println("请输入身高：");
		double height = myScanner.nextDouble();

		System.out.println("姓名：" + name + "，年龄：" + age + ", 身高：" + height);

	}
}

十二、 位运算

符号 说明 规则 案例
>> 向右位移 低位溢出，符号位不变，用符号位补溢出的高位 img
<< 向左位移 符号位不变，低为补 0 img
>>> 算术右移 低位溢出，高位补 0 img
~ 按位取反 1 变 0,0 变 1 img
& 按位与 全为 1，结果为 1，否则为 0 img
\ 按位或 一为 1，结果为 1，否则为 0 img
^ 按位异或 1、0 各一个，结果为 1，否则为 0 img

https://player.bilibili.com/player.html?bvid=BV1fh411y7R8&p=100&page=100&t=229.5

原码、反码、补码

  1. 二进制的最高位（最左边的位数）是符号位： 0 表示正数，1 表示负数
  2. 正数的原码、反码、补码都一样；
  3. 负数的反码 = 原码符号位不变，其他位取反；
  4. 负数的补码 = 反码 +1， 负数的反码 = 负数的补码 +1
  5. 0 的反码、补码都是 0
  6. 计算机在运算时，都是以补码的方式运算的
  7. 查看运算结果时，要看他的原码