温馨提醒：概念固然重要，但通过概念下面的例子更容易理解并运用哦

1. 基础语法

1.1 变量与数据类型

int age = 25;  // 年龄
double price = 19.99;  // 价格
String name = "John";  // 姓名

eg.

public class Main {public static void main(String[] args) {int age = 25;  // 年龄double price = 19.99;  // 价格String name = "John";  // 姓名//不会自带换行需要手动添加换行的输出方法System.out.print("hello word!\n");//自带换行的输出方法（两者区别是print和println）System.out.println(age);System.out.println(price);System.out.println(name);}
}
/*output：
* hello word!
* 25
* 19.99
* John
*/

1.2 条件语句

if (condition) {// 代码块
} else if (anotherCondition) {// 另一个代码块
} else {// 备用代码块
}

eg.

public class Main {public static void main(String[] args){String name="鸽鸽";//判断他的名字是不是墨墨，不是if(name.equals("墨墨")){System.out.println("他不是");}//判断他的名字是不是玉玉，不是else if(name.equals("玉玉")){System.out.println("她不是");}//其他的所有情况else{System.out.println("哎哟你干嘛~");}}
}
/*
* output:
* 哎哟你干嘛~
* */

1.3 循环结构

for (int i = 0; i < 5; i++) {// 代码块
}while (condition) {// 代码块
}do {// 代码块
} while (condition);

eg.

public class Main {public static void main(String[] args) {//for循环示例for(int i=0;i<3;i++){System.out.println(i);}/** output：* 0* 1* 2* *///while循环示例int num=3;//先判断符合条件再循环while(num>0){System.out.println(num);num--;}/** output：* 3* 2* 1* *///do-while循环示例int count=3;//先循环再判断是否符合条件//所以do-while会至少执行do{System.out.println(count);count--;}while(count>0);/** output：* 3* 2* 1* */}}

2. 面向对象

2.1 类与对象

class Car {String model;  // 模型int year;  // 年份// 构造函数(用于初始化)public Car(String model, int year) {this.model = model;this.year = year;}void start() {// 启动汽车的代码System.out.printf("汽车 %s 启动了！%n", model);}//获取汽车信息void get_car_mess(){//print和println是无法格式化字符串的//所以下面用的是printfSystem.out.printf("汽车的模型是：%S\n",model);System.out.printf("汽车的出厂日期是：%d\n",year);}}public class Main {public static void main(String[] args) {Car myCar = new Car("Toyota", 2022);//也可以对单个类中的变量进行初始化//eg.myCar.model = "Toyota";myCar.start();myCar.get_car_mess();}}/*output:
* 汽车 Toyota 启动了！
* 汽车的模型是：TOYOTA
* 汽车的出厂日期是：2022* */

2.2 继承与多态

// 父类 Animalclass Animal {protected String name;//构造函数public Animal(String name) {this.name = name;}public void makeSound() {System.out.println("动物发出声音");}}// 子类 Dog 继承自 Animalclass Dog extends Animal {//构造函数public Dog(String name) {//super的作用：当子类的构造函数被调用时，它首先需要调用父类的构造函数super(name);}//重写 makeSound 函数@Overridepublic void makeSound() {System.out.println("汪汪汪！");}//子类的特定函数（这种不能直接多态调用而需要先向下转换）public void fetch() {System.out.println("狗狗会捡球");}}// 子类 Cat 继承自 Animalclass Cat extends Animal {public Cat(String name) {//super的作用：当子类的构造函数被调用时，它首先需要调用父类的构造函数super(name);}//重写 makeSound 函数@Overridepublic void makeSound() {System.out.println("喵喵喵！");}//子类的特定函数（这种不能直接多态调用而需要先向下转换）public void scratch() {System.out.println("猫猫会抓东西");}}public class Main {public static void main(String[] args) {// 使用多态调用可以在不同子类中重写的方法Animal animal1 = new Dog("小黑");Animal animal2 = new Cat("小白");//makeSound已经被重写了animal1.makeSound();// 输出："汪汪汪！"animal2.makeSound();// 输出："喵喵喵！"//错误范例// 无法调用子类特定的方法// animal1.fetch();   // 编译错误：无法找到 fetch() 方法// animal2.scratch(); // 编译错误：无法找到 scratch() 方法//在多态性下，通过父类类型的引用变量如 animal1，是无法直接访问子类特有的非重写变量的。// 可以使用向下转型可以调用子类特定的方法（即非重写变量）if (animal1 instanceof Dog) {//检查 animal1 是否是 Dog 类的实例Dog dog1 = (Dog) animal1;dog1.fetch();   // 输出："狗狗会捡球"}if (animal2 instanceof Cat) {//检查 animal2 是否是 Cat 类的实例Cat cat1 = (Cat) animal2;cat1.scratch(); // 输出："猫猫会抓东西"}}}

3. 集合框架

3.1 列表（List）

• 添加元素：使用 add() 方法将元素添加到列表
• 获取元素：使用 get() 方法获取列表中指定位置的元素
• 修改元素：使用 set() 方法修改列表中指定位置的元素
• 删除元素：使用 remove() 方法删除列表中指定位置或指定元素的元素
• 判断列表是否包含元素：使用 contains() 方法判断列表中是否包含指定元素
• 获取列表的大小：使用 size() 方法获取列表的元素个数

//可以使用不同的包，这里只举例一种
import java.util.ArrayList;import java.util.List;public class Main {public static void main(String[] args) {// 创建列表List<String> myList = new ArrayList<>();List<Integer> int_myList = new ArrayList<>();// 添加元素myList.add("项目1");myList.add("项目2");myList.add("项目3");int_myList.add(1);int_myList.add(0);// 获取元素// 列表从0开始String firstItem = myList.get(0);System.out.println("第一个元素: " + firstItem);// 修改元素myList.set(1, "新项目2");// 删除元素myList.remove(0);//如果内容和索引都是数字的情况//默认为索引//应该先转换一下此时指的就是删除内容int_myList.remove(Integer.valueOf(0));// 判断列表是否包含元素boolean containsItem = myList.contains("项目3");System.out.println("列表是否包含 '项目3': " + containsItem);// 获取列表的大小int size = myList.size();System.out.println("列表大小: " + size);}}

3.2集（Set）

• 添加元素：使用 add() 方法将元素添加到集
• 删除元素：使用 remove() 方法删除set集中指定元素
• 判断集是否包含元素：使用 contains() 方法判断集中是否包含指定元素
• 获取集的大小：使用 size() 方法获取集中的元素个数

//这里举例的set的接口是没有自动排序功能//TreeSet才有自动排序的功能import java.util.HashSet;import java.util.Set;public class Main {public static void main(String[] args) {// 创建一个集Set<Integer> mySet = new HashSet<>();// 添加元素到集mySet.add(1);mySet.add(2);// 判断集是否包含指定元素boolean contains = mySet.contains(1);// 删除set集中的元素（填入的是元素本身内容而非索引）mySet.remove(2);// 获取集的大小int size = mySet.size();// 清空集mySet.clear();}}

3.3 映射（Map)

• 添加键值对：使用 put() 方法将键值对添加到映射中
• 获取值：使用 get() 方法根据键获取对应的值
• 删除键值对：使用 remove() 方法删除映射中指定键的键值对
• 判断映射是否包含键或值：使用 containsKey() 和 containsValue() 方法判断映射中是否包含指定键或值
• 获取映射的大小：使用 size() 方法获取映射中键值对的个数

import java.util.HashMap;import java.util.Map;public class Main {public static void main(String[] args) {// 创建一个映射Map<String, Integer> myMap = new HashMap<>();// 添加键值对到映射myMap.put("键1", 1);myMap.put("键2", 2);// 获取映射中的值int value = myMap.get("键1");System.out.println(value);//output:1// 判断映射是否包含指定键或值boolean containsKey = myMap.containsKey("键2");boolean containsValue = myMap.containsValue(2);System.out.println(containsKey);//output:trueSystem.out.println(containsValue);//output:true// 删除映射中的键值对myMap.remove("键1");// 获取映射的大小int size = myMap.size();System.out.println(size);//output:1// 清空映射myMap.clear();}}

3.4队列（Queue）

• 入队：使用 offer() 方法将元素添加到队尾
• 出队：使用 poll() 方法移除并返回队首元素
• 获取队首元素：使用 peek() 方法获取队首元素，但不将其移除
• 判断队列是否为空：使用 isEmpty() 方法判断队列是否为空
• 获取队列的大小：使用 size() 方法获取队列中的元素个数

import java.util.LinkedList;import java.util.Queue;public class Main {public static void main(String[] args) {// 创建一个队列Queue<String> myQueue = new LinkedList<>();// 入队myQueue.offer("元素1");myQueue.offer("元素2");// 获取队首元素String frontElement = myQueue.peek();System.out.println(frontElement);//output:元素1// 出队String dequeuedElement = myQueue.poll();System.out.println(dequeuedElement);//output:元素1// 判断队列是否为空boolean isEmpty = myQueue.isEmpty();System.out.println(isEmpty);//output:false// 获取队列的大小int size = myQueue.size();System.out.println(size);//output:1}}

3.5 堆栈（Stack）

• 压栈：使用 push() 方法将元素推入栈顶
• 弹栈：使用 pop() 方法弹出栈顶元素并返回
• 获取栈顶元素：使用 peek() 方法获取栈顶元素，但不弹出
• 判断栈是否为空：使用 isEmpty() 方法判断栈是否为空
• 获取栈的大小：使用 size() 方法获取栈中的元素个数

import java.util.Stack;public class Main {public static void main(String[] args) {// 创建一个堆栈Stack<String> myStack = new Stack<>();// 压栈myStack.push("元素1");myStack.push("元素2");// 获取栈顶元素String topElement = myStack.peek();System.out.println(topElement);//output:元素2// 弹栈(返回值是弹出元素内容)//如果栈为空则抛出异常String poppedElement = myStack.pop();System.out.println(poppedElement);//output:元素2// 判断栈是否为空boolean isEmpty = myStack.isEmpty();System.out.println(isEmpty);//output:false// 获取栈的大小int size = myStack.size();System.out.println(size);//output:1}}

3.6 集合遍历

//其他的集合遍历方法是一样的
List<String> myList = new ArrayList<>();
myList.add("项目1");
myList.add("项目2");
for (String item : myList) {System.out.println(item);
}

4. 异常处理

try {// 可能引发异常的代码
} catch (ExceptionType1 e1) {// 处理异常类型1
} catch (ExceptionType2 e2) {// 处理异常类型2
} finally {// 无论是否发生异常都会执行的代码
}

eg.

public class Main {public static void main(String[] args) {try {int result = divide(10, 0);System.out.println("结果: " + result);} catch (ArithmeticException e) {System.out.println("算术异常: " + e.getMessage());} catch (NullPointerException e) {System.out.println("空指针异常: " + e.getMessage());} finally {System.out.println("无论是否发生异常，此处的代码都会执行");}}// 这里抛出异常，封装原始的算术异常，并提供自定义的异常消息，使异常的信息更具体和有意义public static int divide(int numerator, int denominator) {try {return numerator / denominator;} catch (ArithmeticException e) {throw new ArithmeticException("除数不能为0");}}}

5. 多线程

5.1. 继承Thread类的方式创建线程：（萌新入门建议先用这个）

• 创建一个继承自Thread类的新类，并重写run()方法来定义线程的执行逻辑。
• 线程类可以直接通过new操作符实例化并调用start()方法启动线程。
• 优点：方便简洁，可以直接访问类的成员变量。
• 缺点：线程类继承自Thread类，不方便继承其他类。

//自定义继承自 Thread 的线程类
class MyThread extends Thread {//重写 Thread 类的 run 方法，定义线程的具体任务逻辑public void run() {for (int i = 0; i < 5; i++) {System.out.println("Thread is running: " + i);}}
}public class Main {public static void main(String[] args) {// 创建两个 MyThread 实例作为线程MyThread thread1 = new MyThread();MyThread thread2 = new MyThread();// 启动线程thread1.start(); // 启动第一个线程thread2.start(); // 启动第二个线程}
}

5.2. 实现Runnable接口的方式创建线程：

• 创建一个实现了Runnable接口的类，并实现run()方法来定义线程的执行逻辑。
• 创建Thread对象，并将实现了Runnable接口的对象作为参数传递给构造函数。
• 通过Thread对象调用start()方法启动线程。
• 优点：灵活性高，可以实现其他接口或继承其他类。
• 缺点：无法直接访问类的成员变量，需要通过构造函数传递参数。

// 自定义实现 Runnable 接口的类
class MyRunnable implements Runnable {// run 方法内定义了具体的任务逻辑public void run() {for (int i = 0; i < 5; i++) {System.out.println("Thread is running: " + i);}}
}public class Main {public static void main(String[] args) {// 创建两个线程，并将 MyRunnable 实例作为任务Thread thread1 = new Thread(new MyRunnable()); // 创建第一个线程，并将 MyRunnable 实例作为任务Thread thread2 = new Thread(new MyRunnable()); // 创建第二个线程，并将 MyRunnable 实例作为任务// 启动线程thread1.start(); // 启动第一个线程thread2.start(); // 启动第二个线程}
}

线程池

• 使用线程池可以提供更好的线程管理和复用机制。
• 避免频繁创建和销毁线程的开销。
• Executor框架和ThreadPoolExecutor类提供了线程池的实现。

import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;// 实现 Runnable 接口定义自己的任务类class MyTask implements Runnable {public void run() {for (int i = 0; i < 5; i++) {System.out.println("Task is running: " + i);}}}public class Main {public static void main(String[] args) {// 创建线程池，指定最大线程数为 2ExecutorService executor = Executors.newFixedThreadPool(2);// 提交任务到线程池中执行executor.execute(new MyTask()); // 提交第一个任务executor.execute(new MyTask()); // 提交第二个任务// 关闭线程池executor.shutdown(); // 关闭线程池，不接受新的任务提交}}

6. I/O 操作

6.1 文件读写

Java 提供了丰富的 I/O 操作功能，下面是一个文件读写的基本示例：

import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;public class Main {public static void main(String[] args) {// 文件读取try (BufferedReader br = new BufferedReader(new FileReader("input.txt"))) {String line;while ((line = br.readLine()) != null) {// 逐行读取文件内容，并打印输出System.out.println(line);}} catch (IOException e) {e.printStackTrace();}// 文件写入try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {String content = "Hello, Java I/O!";// 将content写入文件bw.write(content);} catch (IOException e) {e.printStackTrace();}}}

看到这里，恭喜你已经掌握Java的基础入门知识了，有所遗忘记得来这里温习一下，继续努力吧！