Java 基础
1. 变量与数据类型
在 Java 中，变量用于存储数据，每个变量都有类型。Java 的数据类型分为两类：
- 基本数据类型（如
int,double,char,boolean） - 引用数据类型（如
String, 数组, 对象）
示例：
public class Main {
public static void main(String[] args) {
// 基本数据类型
int age = 25; // 整数类型
double price = 19.99; // 双精度浮点数类型
char grade = 'A'; // 字符类型
boolean isStudent = true; // 布尔类型
// 引用数据类型
String name = "Alice"; // 字符串类型
int[] scores = {90, 85, 88}; // 数组
}
}
在这个例子中，age 是 int 类型的变量，price 是 double 类型的变量，name 是 String 类型的变量，scores 是一个整型数组。
2. 运算符与表达式
Java 提供了多种运算符，包括：
- 算术运算符（如
+,-,*,/） - 关系运算符（如
==,!=,<,>） - 逻辑运算符（如
&&,||,!）
示例：
public class Main {
public static void main(String[] args) {
int a = 10;
int b = 20;
int sum = a + b; // 加法运算符
boolean isEqual = (a == b); // 关系运算符：检查是否相等
boolean isGreater = (a > b); // 关系运算符：检查是否大于
boolean result = (a > 5 && b < 30); // 逻辑运算符 AND
System.out.println("sum: " + sum); // 输出：sum: 30
System.out.println("isEqual: " + isEqual); // 输出：isEqual: false
System.out.println("result: " + result); // 输出：result: true
}
}
3. 控制流程
Java 提供多种控制流程语句来管理程序的执行顺序，常见的有：
- if-else 语句
- switch 语句
- 循环（
for,while,do-while）
示例：
public class Main {
public static void main(String[] args) {
int score = 85;
// if-else 语句
if (score >= 90) {
System.out.println("Grade: A");
} else if (score >= 80) {
System.out.println("Grade: B");
} else {
System.out.println("Grade: C");
}
// switch 语句
char grade = 'B';
switch (grade) {
case 'A':
System.out.println("Excellent");
break;
case 'B':
System.out.println("Good");
break;
case 'C':
System.out.println("Average");
break;
default:
System.out.println("Invalid grade");
}
// for 循环
for (int i = 0; i < 5; i++) {
System.out.println("i: " + i);
}
// while 循环
int count = 0;
while (count < 3) {
System.out.println("count: " + count);
count++;
}
}
}
在上面的例子中，我们展示了 if-else，switch 以及 for 和 while 循环的使用。
4. 数组
数组是存储同一类型元素的集合。Java 中的数组是引用类型，支持各种基本数据类型和引用类型。
示例：
public class Main {
public static void main(String[] args) {
// 定义一个整型数组
int[] numbers = {10, 20, 30, 40, 50};
// 访问数组元素
System.out.println("First element: " + numbers[0]); // 输出：10
// 修改数组元素
numbers[1] = 25;
System.out.println("Second element after update: " + numbers[1]); // 输出：25
// 遍历数组
for (int i = 0; i < numbers.length; i++) {
System.out.println("Element at index " + i + ": " + numbers[i]);
}
}
}
这个例子展示了如何定义数组、访问和修改数组元素、以及遍历数组。
总结：
- 变量与数据类型：Java 支持多种数据类型，基本类型包括
int，double，char等，引用类型如String和数组。 - 运算符与表达式：运算符用于操作变量和表达式，常见的有算术、关系和逻辑运算符。
- 控制流程：通过
if-else，switch，循环等语句来控制程序的执行流程。 - 数组：数组是存储相同类型元素的集合，可以通过索引访问或修改元素。
面向对象
面向对象编程（OOP）是 Java 编程的核心概念之一，包含对象与类、继承与多态、访问权限控制、接口等。
1. 对象与类
在 Java 中，类 是对象的蓝图，对象 是类的实例。类包含属性（字段）和行为（方法）。
示例：
// 定义一个类
class Person {
// 属性（字段）
String name;
int age;
// 构造方法（用于创建对象时初始化）
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 方法（行为）
public void introduce() {
System.out.println("Hi, my name is " + name + " and I am " + age + " years old.");
}
}
public class Main {
public static void main(String[] args) {
// 创建对象
Person person1 = new Person("Alice", 25);
Person person2 = new Person("Bob", 30);
// 调用方法
person1.introduce(); // 输出：Hi, my name is Alice and I am 25 years old.
person2.introduce(); // 输出：Hi, my name is Bob and I am 30 years old.
}
}
在这个例子中，Person 是一个类，person1 和 person2 是它的对象。类中定义了属性（name 和 age）和方法（introduce）。
2. 继承与多态
继承 是指一个类可以继承另一个类的属性和方法。多态 允许子类根据自身需要重写父类的方法。
示例：
// 父类
class Animal {
// 方法
public void sound() {
System.out.println("The animal makes a sound.");
}
}
// 子类
class Dog extends Animal {
// 重写父类的方法
@Override
public void sound() {
System.out.println("The dog barks.");
}
}
public class Main {
public static void main(String[] args) {
// 创建父类对象
Animal myAnimal = new Animal();
// 创建子类对象
Dog myDog = new Dog();
// 调用方法
myAnimal.sound(); // 输出：The animal makes a sound.
myDog.sound(); // 输出：The dog barks.
// 多态：父类引用指向子类对象
Animal anotherDog = new Dog();
anotherDog.sound(); // 输出：The dog barks.
}
}
在这个例子中，Dog 继承了 Animal，并重写了 sound() 方法。多态体现在父类引用（anotherDog）调用子类方法时依然调用了子类的实现。
3. 访问权限
Java 提供了四种访问修饰符来控制类、方法和属性的访问权限：
- public：可以被任何类访问
- private：只能在所属类内访问
- protected：同包内以及子类可以访问
- 默认（无修饰符）：同包内可访问
示例：
class Car {
// public 变量可以从任何地方访问
public String brand;
// private 变量只能在类内部访问
private int speed;
// 构造方法
public Car(String brand, int speed) {
this.brand = brand;
this.speed = speed;
}
// public 方法
public void showDetails() {
System.out.println("Brand: " + brand + ", Speed: " + speed);
}
// private 方法
private void increaseSpeed() {
speed += 10;
}
// 通过 public 方法访问 private 方法
public void accelerate() {
increaseSpeed();
System.out.println("Speed after acceleration: " + speed);
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car("Toyota", 100);
car.showDetails(); // 输出：Brand: Toyota, Speed: 100
car.accelerate(); // 输出：Speed after acceleration: 110
// 无法直接访问 private 成员：car.speed = 120; (会报错)
}
}
在这个例子中，speed 是 private 的，因此不能在 Main 类中直接访问，但我们可以通过 public 方法 accelerate() 来修改它。
4. 接口
接口 定义了一组方法，但不提供实现。类可以实现接口，并提供这些方法的具体实现。接口用于定义类的行为规范，并支持多重继承。
示例：
// 定义接口
interface Flyable {
void fly(); // 抽象方法，没有实现
}
// 定义另一个接口
interface Swimmable {
void swim();
}
// 类实现接口
class Bird implements Flyable {
@Override
public void fly() {
System.out.println("The bird is flying.");
}
}
// 类实现多个接口
class Duck implements Flyable, Swimmable {
@Override
public void fly() {
System.out.println("The duck is flying.");
}
@Override
public void swim() {
System.out.println("The duck is swimming.");
}
}
public class Main {
public static void main(String[] args) {
Flyable bird = new Bird();
bird.fly(); // 输出：The bird is flying.
Duck duck = new Duck();
duck.fly(); // 输出：The duck is flying.
duck.swim(); // 输出：The duck is swimming.
}
}
在这个例子中，Flyable 和 Swimmable 是接口，Bird 类实现了 Flyable 接口，Duck 类实现了多个接口。通过接口，我们可以定义类的行为规范。
总结：
- 对象与类：类是对象的蓝图，对象是类的实例，类包含属性和方法。
- 继承与多态：子类可以继承父类的属性和方法，并通过多态实现不同的行为。
- 访问权限：
public、private、protected控制类、方法、属性的访问权限。 - 接口：接口定义行为规范，类可以实现接口并提供方法的具体实现。
常用类和集合
1. String 类
String 是 Java 中表示字符串的类。它是不可变的，这意味着一旦创建，字符串对象不能修改。
示例：
public class Main {
public static void main(String[] args) {
// 创建字符串
String str1 = "Hello";
String str2 = "World";
// 字符串拼接
String result = str1 + " " + str2;
System.out.println(result); // 输出：Hello World
// 获取字符串长度
System.out.println("Length: " + result.length()); // 输出：Length: 11
// 获取字符
System.out.println("Character at index 1: " + result.charAt(1)); // 输出：Character at index 1: e
// 字符串比较
System.out.println(str1.equals(str2)); // 输出：false
// 字符串包含
System.out.println(result.contains("Hello")); // 输出：true
// 转换大小写
System.out.println(result.toUpperCase()); // 输出：HELLO WORLD
}
}
在这个例子中，我们展示了 String 类的一些常用操作，如拼接、获取字符、比较、查找子字符串等。
2. Arrays 类
Arrays 是 Java 提供的用于操作数组的实用类，提供了很多静态方法用于排序、查找、填充等。
示例：
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
// 创建数组
int[] numbers = {5, 3, 8, 1, 2};
// 数组排序
Arrays.sort(numbers);
System.out.println("Sorted array: " + Arrays.toString(numbers)); // 输出：Sorted array: [1, 2, 3, 5, 8]
// 查找元素（需要排序后才能使用binarySearch）
int index = Arrays.binarySearch(numbers, 3);
System.out.println("Index of 3: " + index); // 输出：Index of 3: 2
// 填充数组
int[] filledArray = new int[5];
Arrays.fill(filledArray, 7);
System.out.println("Filled array: " + Arrays.toString(filledArray)); // 输出：Filled array: [7, 7, 7, 7, 7]
}
}
Arrays 类可以帮助我们进行数组的排序、查找元素、填充数组等操作。
3. Math 类
Math 类提供了一些数学函数和常量，如幂、平方根、三角函数等。
示例：
public class Main {
public static void main(String[] args) {
// 计算平方根
System.out.println("Square root of 25: " + Math.sqrt(25)); // 输出：Square root of 25: 5.0
// 计算次方
System.out.println("2 raised to power 3: " + Math.pow(2, 3)); // 输出：2 raised to power 3: 8.0
// 获取最大最小值
System.out.println("Max of 10 and 20: " + Math.max(10, 20)); // 输出：Max of 10 and 20: 20
System.out.println("Min of 10 and 20: " + Math.min(10, 20)); // 输出：Min of 10 and 20: 10
// 生成随机数（0到1之间）
System.out.println("Random number: " + Math.random()); // 输出：Random number: 0.XXX
}
}
Math 类提供了许多静态方法用于数学运算，如平方根、次方、最大最小值和生成随机数。
4. Random 类
Random 类用于生成伪随机数，比 Math.random() 更强大。
示例：
import java.util.Random;
public class Main {
public static void main(String[] args) {
// 创建Random对象
Random random = new Random();
// 生成随机整数
int randomInt = random.nextInt(100); // 生成0到99之间的随机整数
System.out.println("Random integer: " + randomInt);
// 生成随机浮点数
float randomFloat = random.nextFloat(); // 生成0到1之间的随机浮点数
System.out.println("Random float: " + randomFloat);
// 生成随机布尔值
boolean randomBoolean = random.nextBoolean();
System.out.println("Random boolean: " + randomBoolean);
}
}
Random 类支持生成多种类型的随机值，如整数、浮点数和布尔值。
5. ArrayList 类
ArrayList 是动态数组，大小可动态增长。它属于 Java 集合框架的一部分。
示例：
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
// 创建ArrayList
ArrayList<String> names = new ArrayList<>();
// 添加元素
names.add("Alice");
names.add("Bob");
names.add("Charlie");
// 获取元素
System.out.println("First name: " + names.get(0)); // 输出：First name: Alice
// 遍历ArrayList
for (String name : names) {
System.out.println("Name: " + name);
}
// 删除元素
names.remove("Bob");
System.out.println("After removal: " + names); // 输出：After removal: [Alice, Charlie]
// 检查是否包含某个元素
System.out.println("Contains Alice: " + names.contains("Alice")); // 输出：Contains Alice: true
// 获取大小
System.out.println("Size: " + names.size()); // 输出：Size: 2
}
}
ArrayList 提供了添加、删除、访问和遍历元素的方法，并且可以动态扩展数组大小。
6. HashMap 类
HashMap 是键值对（key-value）数据结构，允许快速查找、插入和删除操作。
示例：
import java.util.HashMap;
public class Main {
public static void main(String[] args) {
// 创建HashMap
HashMap<String, Integer> ages = new HashMap<>();
// 添加键值对
ages.put("Alice", 25);
ages.put("Bob", 30);
ages.put("Charlie", 35);
// 获取值
System.out.println("Alice's age: " + ages.get("Alice")); // 输出：Alice's age: 25
// 检查是否包含某个键
System.out.println("Contains key 'Bob': " + ages.containsKey("Bob")); // 输出：Contains key 'Bob': true
// 删除键值对
ages.remove("Charlie");
System.out.println("After removal: " + ages); // 输出：After removal: {Alice=25, Bob=30}
// 遍历HashMap
for (String key : ages.keySet()) {
System.out.println(key + ": " + ages.get(key));
}
// 获取大小
System.out.println("Size: " + ages.size()); // 输出：Size: 2
}
}
HashMap 可以通过键来快速查找对应的值，并且支持高效的添加、删除、和遍历操作。
总结：
- String：不可变的字符串类，支持字符串操作。
- Arrays：提供数组操作的实用类，包括排序、查找、填充等。
- Math：包含常用数学运算方法。
- Random：用于生成伪随机数。
- ArrayList：动态数组，支持自动调整大小。
- HashMap：键值对数据结构，用于高效查找和存储数据。