目录
实例变量：在类中声明的变量，属于类的实例。每个对象都有自己的实例变量。
类变量（静态变量）：使用 static 关键字声明，属于类而不是实例。所有对象共享同一个类变量。
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);
}
}