目录
idea中文插件
第一个 Java 程序
Java数据类型，常量与变量
1. 数据类型
1.1 基本数据类型
1.2 引用数据类型
2. 常量
2.1 特性
2.2 定义常量
编辑
3. 变量
3.1 变量的定义与初始化
3.2 变量的类型
局部变量：在方法内声明的变量，仅在方法内可见。
实例变量：在类中声明的变量，属于类的实例。每个对象都有自己的实例变量。
类变量（静态变量）：使用 static 关键字声明，属于类而不是实例。所有对象共享同一个类变量。
4. 数据类型转换
4.1 自动转换（隐式转换）
4.2 强制转换（显式转换）
4.3 类型转换的注意事项
4.4 String 与基本数据类型之间的转换
5. Java 包装类
5.1 包装类的特点
5.2 自动装箱与拆箱
5.3 常用方法
Java运算符
1. 算术运算符
2. 关系运算符
3. 逻辑运算符
4. 位运算符（自生自灭吧，不写案例了）
5. 赋值运算符
6. 三元运算符
Java选择结构
1. if 语句
2. if-else 语句
3. if-else if-else 语句
4. switch 语句
Java循环结构
1. for 循环
2. while 循环
3. do-while 循环
Java一维数组
1. 数组的声明与初始化
2. 数组的特点
3. 数组的常用操作
Java方法
1. 方法的定义
2. 方法的示例
3. 方法的特点
4. 方法重载示例
5. 方法的调用
案例：学生成绩系统 输入学生成绩 计算分数
idea中文插件
重启软件
舒服了
第一个 Java 程序
jdk 只要加到环境变量里面 就有了
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}- 类的定义：每个 Java 程序都必须有一个类，这里的
HelloWorld是类名。 - 主方法：
main方法是程序的入口点，Java 程序从这里开始执行。快捷键 psvm - 输出语句：使用
System.out.println()输出内容到控制台。 快捷键 sout
Java数据类型，常量与变量
1. 数据类型
1.1 基本数据类型
基本数据类型用于存储简单的值。Java 定义了 8 种基本数据类型：
| 类型 | 大小 | 默认值 | 说明 |
| byte | 8 位 | 0 | 存储整数，范围 -128 到 127。 |
| short | 16 位 | 0 | 存储整数，范围 -32,768 到 32,767。 |
| int | 32 位 | 0 | 存储整数，范围 -2,147,483,648 到 2,147,483,647。 |
| long | 64 位 | 0L | 存储大整数，使用 L 后缀。 |
| float | 32 位 | 0.0f | 存储单精度浮点数，使用 f 后缀。 |
| double | 64 位 | 0.0 | 存储双精度浮点数。 |
| char | 16 位 | '\u0000' | 存储单个字符（Unicode 字符）。 |
| boolean | 1 位（取决于 JVM） | false | 只有两个值：true 或 false。 |
使用示例：
public class Main {
public static void main(String[] args) {
int count = 10; // 整数类型
double price = 19.99; // 双精度浮点数
char initial = 'A'; // 字符
boolean isAvailable = true; // 布尔值
byte a = 129; // 报错这就是存储范围的意义
System.out.println(count);
System.out.println(price);
System.out.println(initial);
System.out.println(isAvailable);
}
}1.2 引用数据类型
引用数据类型用于存储对象的引用。包括类、接口、数组等。
- 类：如
String、ArrayList、Scanner等自定义类的实例。 - 接口：用于定义方法的协议。
- 数组：用于存储多个同类型的值。
-
String name = "Alice"; // 字符串类型 int[] numbers = {1, 2, 3}; // 整数数组
2. 常量
常量是在程序运行期间值不变的量。Java 使用 final 关键字来定义常量。
2.1 特性
- 不可变性：常量一旦被赋值，不能再次修改。
- 命名习惯：常量名通常使用全大写字母，单词之间用下划线分隔，以便于识别。
2.2 定义常量
使用示例：
final double PI = 3.14159; // 圆周率常量
final int MAX_USERS = 100; // 最大用户数常量
尝试修改常量将导致编译错误
// PI = 3.14; // 这行代码会导致错误，因为 PI 是常量
3. 变量
变量是可以存储值并在程序运行期间修改的量。每个变量都有特定的数据类型。
3.1 变量的定义与初始化
定义变量需要指定类型和名称，初始化可以在声明时或稍后进行。
使用示例：
public class Main {
public static void main(String[] args) {
int age; // 声明变量
age = 25; // 初始化变量
String greeting = "Hello"; // 声明并初始化变量
System.out.println(age);
System.out.println(greeting);
}
}3.2 变量的类型
局部变量：在方法内声明的变量，仅在方法内可见。
void display() {
int localVar = 5; // 局部变量
System.out.println(localVar);
}
实例变量：在类中声明的变量，属于类的实例。每个对象都有自己的实例变量。
public class Person {
String name; // 实例变量
public Person(String name) {
this.name = name; // 通过构造函数初始化实例变量
}
}
类变量（静态变量）：使用 static 关键字声明，属于类而不是实例。所有对象共享同一个类变量。
public class Counter {
static int count = 0; // 类变量
public Counter() {
count++; // 每创建一个对象，count 加 1
}
}
4. 数据类型转换
分为两种主要类型：自动转换（隐式转换）和 强制转换（显式转换）。
4.1 自动转换（隐式转换）
当将一种类型的值赋给另一种类型的变量时，如果目标类型的范围大于源类型，Java 会自动进行转换，无需强制指定。这种转换通常发生在基本数据类型之间。
从 int 到 long
int num = 100;
long longNum = num; // 自动转换
从 float 到 double
float floatNum = 5.5f;
double doubleNum = floatNum; // 自动转换
从 char 到 int
char character = 'A';
int asciiValue = character; // 自动转换，得到 ASCII 值 65
4.2 强制转换（显式转换）
当将一种类型的值赋给另一种类型的变量时，如果目标类型的范围小于源类型，Java 要求使用强制转换。强制转换可能会导致数据丢失或精度降低，因此需要谨慎使用。
从 double 到 int
double doubleNum = 9.78;
int intNum = (int) doubleNum; // 强制转换，结果为 9，丢失小数部分
从 long 到 int
long longValue = 100000L;
int intValue = (int) longValue; // 强制转换，可能导致溢出
从 float 到 int
float floatValue = 12.34f;
int intValue = (int) floatValue; // 强制转换，结果为 12
4.3 类型转换的注意事项
- 数据丢失：在强制转换时，尤其是从较大类型到较小类型，可能会导致数据丢失。例如，从
double转换为int时，小数部分会被丢弃。 - 溢出：在转换时，如果数值超出目标类型的范围，会导致溢出。例如，将一个很大的
long值强制转换为int，结果可能会出现意外值。 - 对象类型的转换：对于引用数据类型，可以通过
instanceof关键字进行类型检查，确保安全转换。 -
Object obj = "Hello, World!"; if (obj instanceof String) { String str = (String) obj; // 强制类型转换 }
4.4 String 与基本数据类型之间的转换
String 转基本数据类型：使用包装类的静态方法。
String numberStr = "123";
int number = Integer.parseInt(numberStr); // 转换为 int
double decimal = Double.parseDouble("3.14"); // 转换为 double基本数据类型转 String：使用 String.valueOf() 或 String 的构造函数。
int num = 456;
String numStr = String.valueOf(num); // 转换为 String
5. Java 包装类
在 Java 中，基本数据类型（如 int、char、boolean 等）通常被称为原始类型，它们是非对象类型。为了能够将基本类型视为对象，并提供一些额外的功能，Java 提供了相应的包装类。每种基本数据类型都有一个对应的包装类，这些类都位于 java.lang 包中。
前面是基本数据类型 后面是包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean5.1 包装类的特点
- 对象：包装类是对象，具有方法和属性，可以用来处理基本数据类型的值。
- 不可变性：包装类的对象一旦创建，其值不能被改变。例如，
Integer对象的值不可变。不是不能修改 是修改之后 不在原来的内存地址了。 - 提供有用的方法：包装类提供了许多有用的方法，如解析字符串、比较大小、转换为其他数据类型等。
5.2 自动装箱与拆箱
Java 5 引入了自动装箱（Auto-boxing）和自动拆箱（Auto-unboxing）特性，允许基本类型与包装类之间的自动转换。
自动装箱：将基本类型自动转换为对应的包装类。
int primitiveInt = 10;
Integer wrappedInt = primitiveInt; // 自动装箱
自动拆箱：将包装类自动转换为对应的基本类型。
Integer wrappedInt = new Integer(20);
int primitiveInt = wrappedInt; // 自动拆箱
5.3 常用方法
每个包装类都提供了一些常用的方法：
Integer
int intValue = Integer.parseInt("123"); // 字符串转整数
String strValue = Integer.toString(456); // 整数转字符串
Double
double doubleValue = Double.parseDouble("3.14"); // 字符串转双精度浮点数
Boolean
boolean boolValue = Boolean.parseBoolean("true"); // 字符串转布尔值
Java运算符
运算符提供了多种方式来处理数据和控制程序的流。
1. 算术运算符
+：加法，例如a + b-：减法，例如a - b*：乘法，例如a * b/：除法，例如a / b（整除会舍去小数部分）%：取余（模），例如a % b-
public class Main { public static void main(String[] args) { int a = 10; int b = 3; // 加法 int sum = a + b; System.out.println("a + b = " + sum); // 输出 13 // 减法 int difference = a - b; System.out.println("a - b = " + difference); // 输出 7 // 乘法 int product = a * b; System.out.println("a * b = " + product); // 输出 30 // 除法 int quotient = a / b; System.out.println("a / b = " + quotient); // 输出 3 // 取余 int remainder = a % b; System.out.println("a % b = " + remainder); // 输出 1 } }
2. 关系运算符
==：等于，例如a == b!=：不等于，例如a != b>：大于，例如a > b<：小于，例如a < b>=：大于等于，例如a >= b<=：小于等于，例如a <= b-
public class Main { public static void main(String[] args) { int a = 10; int b = 20; // 等于运算符 boolean isEqual = (a == b); System.out.println("a == b: " + isEqual); // 输出 false // 不等于运算符 boolean isNotEqual = (a != b); System.out.println("a != b: " + isNotEqual); // 输出 true // 大于运算符 boolean isGreater = (a > b); System.out.println("a > b: " + isGreater); // 输出 false // 小于运算符 boolean isLess = (a < b); System.out.println("a < b: " + isLess); // 输出 true // 大于等于运算符 boolean isGreaterOrEqual = (a >= b); System.out.println("a >= b: " + isGreaterOrEqual); // 输出 false // 小于等于运算符 boolean isLessOrEqual = (a <= b); System.out.println("a <= b: " + isLessOrEqual); // 输出 true } }
3. 逻辑运算符
&&：逻辑与（AND），例如a && b||：逻辑或（OR），例如a || b!：逻辑非（NOT），例如!a-
public class Main { public static void main(String[] args) { boolean a = true; boolean b = false; // 逻辑与运算符 boolean andResult = a && b; System.out.println("a && b: " + andResult); // 输出 false // 逻辑或运算符 boolean orResult = a || b; System.out.println("a || b: " + orResult); // 输出 true // 逻辑非运算符 boolean notA = !a; System.out.println("!a: " + notA); // 输出 false boolean notB = !b; System.out.println("!b: " + notB); // 输出 true } }
4. 位运算符（自生自灭吧，不写案例了）
&：按位与，例如a & b|：按位或，例如a | b^：按位异或，例如a ^ b~：按位取反，例如~a<<：左移，例如a << 2>>：右移，例如a >> 2>>>：无符号右移，例如a >>> 2
5. 赋值运算符
=：赋值，例如a = 5+=：加法赋值，例如a += 3（相当于a = a + 3）-=：减法赋值，例如a -= 2*=：乘法赋值，例如a *= 4/=：除法赋值，例如a /= 2%=：取余赋值，例如a %= 3&=：按位与赋值，例如a &= b|=：按位或赋值，例如a |= b^=：按位异或赋值，例如a ^= b<<=：左移赋值，例如a <<= 2>>=：右移赋值，例如a >>= 2>>>=：无符号右移赋值，例如a >>>= 2-
public class Main { public static void main(String[] args) { int a = 5; // 基本赋值 int b = 3; // 基本赋值 // 加法赋值 a += 3; // 相当于 a = a + 3 System.out.println("a += 3: " + a); // 输出 8 // 减法赋值 a -= 2; // 相当于 a = a - 2 System.out.println("a -= 2: " + a); // 输出 6 // 乘法赋值 a *= 4; // 相当于 a = a * 4 System.out.println("a *= 4: " + a); // 输出 24 // 除法赋值 a /= 2; // 相当于 a = a / 2 System.out.println("a /= 2: " + a); // 输出 12 // 取余赋值 a %= 5; // 相当于 a = a % 5 System.out.println("a %= 5: " + a); // 输出 2 // 按位与赋值 a &= b; // 相当于 a = a & b System.out.println("a &= b: " + a); // 输出 2 (0000 0010) // 按位或赋值 a |= b; // 相当于 a = a | b System.out.println("a |= b: " + a); // 输出 3 (0000 0011) // 按位异或赋值 a ^= b; // 相当于 a = a ^ b System.out.println("a ^= b: " + a); // 输出 0 (0000 0000) // 左移赋值 a = 5; // 重置 a a <<= 2; // 相当于 a = a << 2 System.out.println("a <<= 2: " + a); // 输出 20 (0001 0100) // 右移赋值 a >>= 2; // 相当于 a = a >> 2 System.out.println("a >>= 2: " + a); // 输出 5 (0000 0101) // 无符号右移赋值 a >>>= 2; // 相当于 a = a >>> 2 System.out.println("a >>>= 2: " + a); // 输出 1 (0000 0001) } }
6. 三元运算符
- (条件) ? 表达式1 : 表达式2
-
public class Main { public static void main(String[] args) { int a = 10; int b = 20; // 使用三元运算符判断哪个数更大 int max = (a > b) ? a : b; System.out.println("最大值: " + max); // 输出 20 // 判断是否为偶数 String result = (a % 2 == 0) ? "偶数" : "奇数"; System.out.println(a + " 是 " + result); // 输出 "10 是 偶数" // 判断是否大于 15 String comparison = (a > 15) ? "大于 15" : "不大于 15"; System.out.println(a + " " + comparison); // 输出 "10 不大于 15" } }
Java选择结构
1. if 语句
用于在条件为 true 时执行代码块。
public class Main {
public static void main(String[] args) {
int score = 85;
if (score >= 60) {
System.out.println("及格");
}
}
}2. if-else 语句
用于在条件为 true 时执行一块代码，如果条件为 false 则执行另一块代码。
public class Main {
public static void main(String[] args) {
int score = 50;
if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
}
}3. if-else if-else 语句
用于处理多个条件。
public class Main {
public static void main(String[] args) {
int score = 75;
if (score >= 90) {
System.out.println("优秀");
} else if (score >= 75) {
System.out.println("良好");
} else if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
}
}4. switch 语句
用于根据一个表达式的值执行不同的代码块，通常用于处理多个可能的常量值。
public class Main {
public static void main(String[] args) {
int day = 3;
String dayName;
switch (day) {
case 1:
dayName = "星期一";
break;
case 2:
dayName = "星期二";
break;
case 3:
dayName = "星期三";
break;
case 4:
dayName = "星期四";
break;
case 5:
dayName = "星期五";
break;
case 6:
dayName = "星期六";
break;
case 7:
dayName = "星期日";
break;
default:
dayName = "无效的输入";
break;
}
System.out.println("今天是: " + dayName);
}
}Java循环结构
1. for 循环
for 循环用于当已知循环次数时的情况。它的语法如下：
for (初始化; 条件; 更新) {
// 循环体
}
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println("第 " + i + " 次循环");
}
}2. while 循环
while 循环用于当循环次数不确定时的情况，循环在条件为 true 时执行。
public static void main(String[] args) {
int i = 1;
while (i <= 5) {
System.out.println("第 " + i + " 次循环");
i++;
}
}3. do-while 循环
do-while 循环与 while 循环类似，但至少执行一次循环体，因为条件是在循环体之后进行判断的。
public static void main(String[] args) {
int i = 1;
do {
System.out.println("第 " + i + " 次循环");
i++;
} while (i <= 5);
}Java一维数组
一维数组是存储相同类型数据的一种数据结构。它是一种线性数据结构，可以通过索引访问数组中的每个元素。
1. 数组的声明与初始化
可以在声明数组时初始化它，也可以单独声明和初始化。
public class Main {
public static void main(String[] args) {
// 声明并初始化数组
int[] numbers = {1, 2, 3, 4, 5};
//运用活一点
long[] numbers1 = {1, 2, 3, 4, 5};
String[] numbers2 = {String.valueOf(1), String.valueOf(2), String.valueOf(3), "4", "5"};
// 或者先声明再初始化
int[] moreNumbers = new int[5]; // 声明一个长度为 5 的数组
moreNumbers[0] = 10;
moreNumbers[1] = 20;
moreNumbers[2] = 30;
moreNumbers[3] = 40;
moreNumbers[4] = 50;
// 输出数组元素
System.out.println("numbers 数组:");
for (int i = 0; i < numbers.length; i++) {
System.out.println("Index " + i + ": " + numbers[i]);
}
System.out.println("\nmoreNumbers 数组:");
for (int i = 0; i < moreNumbers.length; i++) {
System.out.println("Index " + i + ": " + moreNumbers[i]);
}
}
}2. 数组的特点
- 固定大小：一旦创建，数组的大小不可更改。
- 索引访问：可以通过索引访问数组的元素，索引从
0开始。 - 相同类型：数组中所有元素的数据类型必须相同。
3. 数组的常用操作
- 获取数组长度：使用
array.length可以获取数组的长度。 - 遍历数组：可以使用
for循环或增强的for-each循环来遍历数组。 -
public class Main { public static void main(String[] args) { int[] numbers = {1, 2, 3, 4, 5}; System.out.println("使用 for-each 循环遍历数组:"); for (int number : numbers) { System.out.println(number); } } }
Java方法
方法是 Java 中执行特定任务的代码块，可以重用代码，提高程序的可读性和可维护性。方法可以接受参数，并返回结果。
1. 方法的定义
返回类型 方法名(参数类型 参数名1, 参数类型 参数名2, ...) {
// 方法体
}2. 方法的示例
public class Main {
// 定义一个方法，计算两个整数的和
public static int add(int a, int b) {
return a + b; // 返回结果
}
// 定义一个方法，打印问候信息
public static void greet(String name) {
System.out.println("你好, " + name + "!");
}
public static void main(String[] args) {
// 调用方法
int sum = add(5, 10); // 调用 add 方法
System.out.println("和: " + sum); // 输出和
greet("Alice"); // 调用 greet 方法
}
}3. 方法的特点
- 返回类型：方法可以有返回值，也可以没有（使用
void关键字）。 - 参数：方法可以接受零个或多个参数，参数可以是基本数据类型或对象类型。
- 方法重载：可以在同一个类中定义多个同名但参数不同的方法，这称为方法重载。
4. 方法重载示例
// 重载的方法：计算两个整数的和
public static int add(int a, int b) {
return a + b;
}
// 重载的方法：计算三个整数的和
public static int add(int a, int b, int c) {
return a + b + c;
}
public static void main(String[] args) {
System.out.println("两个数的和: " + add(5, 10)); // 输出 15
System.out.println("三个数的和: " + add(5, 10, 15)); // 输出 30
}5. 方法的调用
- 在同一类中调用：可以直接使用方法名调用。
- 在其他类中调用：需要创建该类的对象，或者如果方法是
static的，可以直接使用类名调用。
案例：学生成绩系统 输入学生成绩 计算分数
import java.util.Scanner;
public class Main {
// 定义常量
static final int MAX_STUDENTS = 5; // 最大学生数量
// 方法：添加成绩
public static void addGrades(double[] grades) {
Scanner scanner = new Scanner(System.in);
for (int i = 0; i < grades.length; i++) {
System.out.print("请输入第 " + (i + 1) + " 个学生的成绩: ");
grades[i] = scanner.nextDouble();
}
}
// 方法：计算总分
public static double calculateTotal(double[] grades) {
double total = 0;
for (double grade : grades) {
total += grade; // 累加成绩
}
return total;
}
// 方法：计算平均分
public static double calculateAverage(double total, int count) {
return total / count; // 计算平均分
}
// 方法：输出成绩等级
public static void printGrades(double[] grades) {
System.out.println("\n学生成绩及等级:");
for (double grade : grades) {
String level;
if (grade >= 90) {
level = "优秀";
} else if (grade >= 75) {
level = "良好";
} else if (grade >= 60) {
level = "及格";
} else {
level = "不及格";
}
System.out.println("成绩: " + grade + " - 等级: " + level);
}
}
public static void main(String[] args) {
double[] grades = new double[MAX_STUDENTS]; // 创建存储成绩的数组
// 添加成绩
addGrades(grades);
// 计算总分和平均分
double total = calculateTotal(grades);
double average = calculateAverage(total, MAX_STUDENTS);
// 输出总分和平均分
System.out.println("\n总分: " + total);
System.out.println("平均分: " + average);
// 输出成绩等级
printGrades(grades);
}
}
