这篇文章只限于想快速了解Java的小伙伴，当然也适合学过一段时间的复盘，做的不好还请你们多多担待，希望在以后的日子里可以跟你们一起进步。
目录
一、准备工具
1.安装JDK
从Oracle官方安装需要的版本，推荐JDK8或者11,安装步骤默认就行，安装的路径可以根据自己选择
2.配置环境变量->为了通过修改PATH变量，允许用户从命令行直接运行Java相关工具，如java, javac等，而不需要指定完整的路径。
步骤：右击此电脑->属性->高级系统设置->环境变量->系统变量做修改
增加JAVA_HOME指定bin目录，双击Path变量，增加%JAVA_HOME\bin%
2.在dos命令终端(win+R输入cmd回车)中输入java -version和javac -version来检查Java和Javac的版本信息
3.安装一款开发工具
这里建议新手小白刚开始学习Java时安装一些偏文本编辑器的，如Sublime Text、Notepad++等
因为偏重量级的开发工具比较智能有代码提示功能，这是不利于打基础的。
2. 基础语法
Hello World: 最简单的Java程序,也是所有程序员入门的第一个程序。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, world!");
}
}这里大家只需要知道类的定义格式为 public class 类名
main()方法是程序的主入口就行，Java代码都是在这里面执行的
System.out.println()；Java的在控制端打印内容的语句
注释：单行注释 // 注释内容 多行注释 /* 注释内容*/
3. 数据类型与变量
这个类我是后面才想起来的，回来补一下，因为经常用到
Scanner
Scanner 类是 Java 提供的一个用于获取用户输入的便捷工具,需要导包，
在头部写import java.util.Scanner
import java.util.Scanner; // 导入Scanner类
public class ScannerExample {
public static void main(String[] args) {
// 创建一个Scanner对象，关联到标准输入(System.in)
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您的姓名：");
String name = scanner.nextLine(); // 读取一行字符串输入
System.out.println("请输入您的年龄：");
int age = scanner.nextInt(); // 读取一个整数输入
System.out.println("请输入您的身高（米）：");
double height = scanner.nextDouble(); // 读取一个浮点数输入
// 输出用户输入的信息
System.out.println("您好, " + name + "。您今年" + age + "岁，身高为" + height + "米。");
}
}基本数据类型
整型
byte a = 1; // 1字节，8位有符号整数（-128~127）
short b = 2; // 2字节，16位有符号整数（-32768~32767）
int c = 3; // 4字节，32位有符号整数（-2^31~2^31-1）
long d = 4L; // 8字节，64位有符号整数（-2^63~2^63-1）
浮点型
float e = 5.0f; // 4字节，32位单精度浮点数（IEEE 754标准）
double f = 6.0; // 8字节，64位双精度浮点数（IEEE 754标准）
字符型
char g = 'A'; // 2字节，16位Unicode字符（\u0000~\uffff）
布尔型
boolean h = true; // 官方未明确字节数，JVM通常用1字节或4字节存储
注意：
- 布尔类型在不同JVM实现中占用空间可能不同
- 长整型（long）和浮点型（float）需分别用
L和f后缀显式声明
出基本类型外还有引用数据类型，如数组，对象，集合等
类型转换示例：
double d = 3.14;
int i = (int)d; // 显式强制转换，结果为3
类型大的向小的转换需要进行强制类型转换
小的转大的有自动转换功能
四、基本运算符
| 运算符类型 | 示例 | 说明 |
|---|---|---|
| 算术运算符 | +, -, *, /, % | 数学计算 |
| 赋值运算符 | =, +=, -= | 给变量赋值 |
| 关系运算符 | >, <, ==, != | 判断两个值之间的关系 |
| 逻辑运算符 | &&, ` | |
| 自增/自减运算符 | ++, -- | 变量自增或自减 |
public class Main {
public static void main(String[] args) {
// ================== 算术运算符 ==================
int a = 10, b = 3;
System.out.println("算术运算符：");
System.out.println("a + b = " + (a + b)); // 加法
System.out.println("a - b = " + (a - b)); // 减法
System.out.println("a * b = " + (a * b)); // 乘法
System.out.println("a / b = " + (a / b)); // 除法（取商）
System.out.println("a % b = " + (a % b)); // 取余数
// ================== 赋值运算符 ==================
System.out.println("\n赋值运算符：");
int c = 5; // 基本赋值
c += 2; // 等价于 c = c + 2
System.out.println("c += 2 后的值：" + c);
c -= 1; // 等价于 c = c - 1
System.out.println("c -= 1 后的值：" + c);
c *= 3; // 等价于 c = c * 3
System.out.println("c *= 3 后的值：" + c);
// ================== 关系/比较运算符 ==================
System.out.println("\n关系/比较运算符（返回 boolean 值）：");
System.out.println("a > b ? " + (a > b)); // 大于
System.out.println("a < b ? " + (a < b)); // 小于
System.out.println("a == b ? " + (a == b)); // 等于
System.out.println("a != b ? " + (a != b)); // 不等于
System.out.println("a >= b ? " + (a >= b)); // 大于等于
System.out.println("a <= b ? " + (a <= b)); // 小于等于
// ================== 逻辑运算符 ==================
System.out.println("\n逻辑运算符（操作 boolean 类型）：");
boolean x = true, y = false;
System.out.println("x && y = " + (x && y)); // 与（AND）
System.out.println("x || y = " + (x || y)); // 或（OR）
System.out.println("!x = " + (!x)); // 非（NOT）
// ================== 自增/自减运算符 ==================
System.out.println("\n自增/自减运算符：");
int d = 5;
System.out.println("d++ = " + (d++)); // 后自增：先使用再加1 → 输出 5
System.out.println("现在 d = " + d); // 此时 d 已变成 6
System.out.println("++d = " + (++d)); // 前自增：先加1再使用 → 输出 7
int e = 10;
System.out.println("e-- = " + (e--)); // 后自减：先使用再减1 → 输出 10
System.out.println("现在 e = " + e); // 此时 e = 9
System.out.println("--e = " + (--e)); // 前自减：先减1再使用 → 输出 8
}
}5、break和continue
| 关键字 | 功能描述 |
|---|---|
break | 终止最近的封闭循环或switch语句 |
continue | 跳过当前循环体的剩余部分，立即开始下一次循环 |
// ================== Break 和 Continue 示例 ==================
System.out.println("\nBreak 和 Continue 示例:");
for (int m = 0; m < 10; m++) {
if (m == 3) {
continue; // 跳过本次循环剩余部分，直接进入下一次循环
}
if (m == 7) {
break; // 终止循环
}
System.out.println("当前的m值是: " + m);
}6、选择结构语句
| 语句类型 | 简洁描述 |
|---|---|
| If | 根据条件执行代码块。 |
| If-Else | 条件为真时执行一段代码，为假时执行另一段代码。 |
| If-Else If-Else | 多条件分支，依次判断直至满足某一条件或执行默认代码。 |
| Switch | 根据变量值匹配case执行相应代码块，支持默认处理（default）。 |
public class Mainde {
public static void main(String[] args) {
// 示例变量
int number = 15;
String dayOfWeek = "Wednesday";
// ================== if-else 选择语句 ==================
System.out.println("=== If-Else 选择语句 ===");
if (number > 10) {
System.out.println("Number is greater than 10.");
} else if (number < 10) {
System.out.println("Number is less than 10.");
} else {
System.out.println("Number is equal to 10.");
}
// ================== switch 选择语句 ==================
System.out.println("\n=== Switch 选择语句 ===");
switch (dayOfWeek) {
case "Monday":
System.out.println("Today is Monday.");
break;
case "Tuesday":
System.out.println("Today is Tuesday.");
break;
case "Wednesday":
System.out.println("Today is Wednesday.");
break;
default:
System.out.println("Looking forward to the weekend.");
}
// 另一个 switch 示例，演示使用整数
System.out.println("\n=== Switch with Integer ===");
int month = 8;
switch (month) {
case 1: case 2: case 3:
System.out.println("第一季度");
break;
case 4: case 5: case 6:
System.out.println("第二季度");
break;
case 7: case 8: case 9:
System.out.println("第三季度");
break;
case 10: case 11: case 12:
System.out.println("第四季度");
break;
default:
System.out.println("无效的月份");
}
// ================== 演示 case 穿透（fall-through）==================
System.out.println("\n=== 演示 case 穿透（fall-through）===");
int grade = 85;
switch (grade / 10) {
case 10:
case 9:
System.out.println("优秀");
// 没有 break，会穿透到下一个 case
case 8:
System.out.println("良好");
// 没有 break，继续穿透
case 7:
System.out.println("中等");
break;
case 6:
System.out.println("及格");
break;
default:
System.out.println("不及格");
}
/*
* 上面的例子中：
* grade = 85 → grade / 10 = 8
* 所以进入 case 8:
* 但由于没有 break，会继续执行 case 7: 的内容。
* 输出结果为：
* 良好
* 中等
*/
}
}switch语句中的穿透就不做详细介绍了，代码上有
7、循环结构语句
| 语句类型 | 描述 | 特点 |
|---|---|---|
| For | 执行已知次数的循环 | 初始化、条件判断、更新表达式 |
| While | 当条件为真时执行循环 | 先判断后执行 |
| Do-While | 至少执行一次循环，直到条件为假 | 先执行后判断 |
| 增强型 For | 遍历数组或集合 | 简化遍历操作 |
public class Maindemo2 {
public static void main(String[] args) {
// ================== For 循环 ==================
System.out.println("For 循环示例:");
for (int i = 0; i < 5; i++) { // 初始化; 条件判断; 更新表达式
System.out.println("当前的i值是: " + i);
}
// ================== While 循环 ==================
System.out.println("\nWhile 循环示例:");
int j = 0;
while (j < 3) { // 当条件为true时执行循环体
System.out.println("当前的j值是: " + j);
j++; // 必须更新循环变量，否则会导致无限循环
}
// ================== Do-While 循环 ==================
System.out.println("\nDo-While 循环示例:");
int k = 0;
do {
System.out.println("当前的k值是: " + k);
k++;
} while (k < 2); // 先执行一次循环体，然后检查条件
// ================== 增强型 For 循环（适用于数组和集合） ==================
System.out.println("\n增强型 For 循环示例:");
int[] numbers = {1, 2, 3, 4, 5};
for (int num : numbers) { // 遍历数组中的每个元素
System.out.println("数组中的元素: " + num);
}
}
}8、面向对象三大特性
这个部分很重要，建议有时间的小伙伴好好学这部分
简单说一下类和对象：
类就是一个类型，抽象的类型，比如人类、动物、学生、老师，把具有相同特性的事物称为一个类
对象就是具有属性和行为的，它是实体的，什么意思？就是学生类中某一名学生，老师类中某一名老师就分别属于他们对应类的一个对象也叫实例。我习惯叫对象，相信大家也是，方便理解。
| 特性 | 描述 | 关键点 |
|---|---|---|
| 封装 | 将数据和方法绑定在一起，并隐藏内部实现细节。 | 访问控制（如：private, public, protected），类的概念 |
| 继承 | 允许一个类继承另一个类的属性和方法，促进代码复用。 | extends关键字，父类与子类关系 |
| 多态 | 同一接口可以有多种形式，通过方法重载或覆盖实现不同行为。 | 方法重写（@Override），动态绑定，接口或抽象类的实现 |
简单来说：
封装->就是创建一个具有相同共性的类
继承->就是儿子跟爸爸的关系，他们有很多类似的地方可以封装成另一个类，只支持单继承
多态-> 类的多种形态，比如狗类和猫类它们都是动物类，子类引用指向父类对象
这里会涉及到一些构造函数，方法重载，重写和接口，抽象类，因为是快速入门我就不写这方面的大家有时间自己去了解一下，因为我觉得速成的话，这些够用了
// 封装演示：定义一个类，使用private修饰成员变量，并提供公共方法来访问这些变量
class Animal {
// 使用 private 修饰符进行封装，外部不能直接访问
private String name;
private int age;
// 构造函数
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
// 提供getter和setter方法，以安全的方式访问私有成员变量
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 0) { // 简单的数据验证
this.age = age;
}
}
// 定义一个普通方法
public void makeSound() {
System.out.println("Some generic animal sound");
}
}
// 继承演示：定义一个子类继承自Animal类
class Dog extends Animal {
// 子类构造器需要调用父类构造器
public Dog(String name, int age) {
super(name, age); // 调用父类的构造函数
}
// 方法重写（覆盖），展示多态性
@Override
public void makeSound() {
System.out.println(getName() + " barks");
}
}
// 另一个子类
class Cat extends Animal {
public Cat(String name, int age) {
super(name, age);
}
@Override
public void makeSound() {
System.out.println(getName() + " meows");
}
}
public class Main {
public static void main(String[] args) {
// 封装演示：通过getter和setter方法访问和修改私有成员变量
Animal myAnimal = new Animal("Generic Animal", 5);
System.out.println("Animal's name: " + myAnimal.getName());
myAnimal.setAge(6);
System.out.println("Animal's age: " + myAnimal.getAge());
// 继承演示：创建Dog和Cat对象
Dog myDog = new Dog("Buddy", 4);
Cat myCat = new Cat("Whiskers", 3);
// 多态演示：使用父类类型的引用来引用子类对象
Animal dogAsAnimal = myDog;
Animal catAsAnimal = myCat;
// 调用各自的方法，实际调用的是子类中重写的方法
dogAsAnimal.makeSound(); // 输出 Buddy barks
catAsAnimal.makeSound(); // 输出 Whiskers meows
// 直接调用子类对象的方法也是可以的
myDog.makeSound(); // 输出 Buddy barks
myCat.makeSound(); // 输出 Whiskers meows
}
}九、异常
一、什么是异常？
在程序运行过程中发生的错误或意外情况称为“异常”（Exception）。我们需要进行相应处理，避免程序崩溃。
二、异常分类（常见异常类型）
| 异常类型 | 说明 | 示例 |
|---|---|---|
Error | 系统级错误，通常不处理 | OutOfMemoryError, StackOverflowError |
Exception | 可检查异常（编译时异常） | IOException, SQLException |
RuntimeException | 运行时异常（非检查异常） | NullPointerException, ArrayIndexOutOfBoundsException |
第二个和第三个是需要掌握的，也是后续很常见的
给大家演示一下：
public class ExceptionDemo {
public static void main(String[] args) {
try {
// 尝试执行可能会出错的代码
int result = divide(10, 0); // 分母为0，会抛出 ArithmeticException
System.out.println("结果是：" + result);
} catch (ArithmeticException e) {
// 捕获特定异常
System.out.println("发生算术异常: " + e.getMessage());
} catch (Exception e) {
// 捕获其他通用异常
System.out.println("发生了异常: " + e.getMessage());
} finally {
// 不管有没有异常都会执行
System.out.println("finally块始终执行");
}
try {
// 主动抛出异常
validateAge(-5);
} catch (IllegalArgumentException e) {
System.out.println("非法年龄异常: " + e.getMessage());
}
}
// 方法中使用 throws 声明可能抛出的异常
public static int divide(int a, int b) throws ArithmeticException {
return a / b;
}
// 验证年龄是否合法
public static void validateAge(int age) {
if (age < 0) {
// 抛出自定义异常信息
throw new IllegalArgumentException("年龄不能为负数");
}
}
}总结：
| 关键字 | 作用 |
|---|---|
try | 包含可能会发生异常的代码块 |
catch | 捕获并处理异常 |
finally | 不管是否发生异常都执行（如关闭资源） |
throw | 手动抛出一个异常对象 |
throws | 声明方法可能抛出的异常类型 |
十、引用数据类型
一、数组(Array)
数组是一种数据结构，用于存储固定大小的同类型元素集合。
数组特点：
固定大小：一旦创建后，数组的大小不可改变。
索引访问：通过索引访问数组元素，索引从0开始。
public class ArrayExample {
public static void main(String[] args) {
// 创建一个整型数组
int[] numbers = new int[5]; // 定义了一个可以存储5个整数的数组
// 初始化数组元素
for (int i = 0; i < numbers.length; i++) { // length属性获取数组长度
numbers[i] = i * 10; // 给每个元素赋值
}
// 遍历并打印数组元素
System.out.println("数组元素为：");
for (int num : numbers) { // 增强for循环遍历数组
System.out.print(num + " ");
}
}
}二、字符串（String）
在Java中，String是一个类，表示文本数据.
字符串特点：
不可变性：每次对字符串进行操作都会生成一个新的字符串对象。
丰富的API支持：提供了大量的方法来操作字符串，如查找、替换、分割等。
public class StringExample {
public static void main(String[] args) {
// 创建字符串
String greeting = "Hello, World!";
// 获取字符串长度
System.out.println("字符串长度: " + greeting.length());
// 查找子串的位置
System.out.println("子串World的位置: " + greeting.indexOf("World"));
// 拼接字符串
String result = greeting.concat(" Welcome to Java!");
System.out.println("拼接后的字符串: " + result);
// 替换字符串中的字符
String replacedResult = result.replace("!", ".");
System.out.println("替换后的字符串: " + replacedResult);
// 转换为大写
System.out.println("转换为大写的字符串: " + greeting.toUpperCase());
}
}三、集合
集合框架的核心接口
List：有序集合，允许重复元素。
Set：不包含重复元素的集合。
Queue：通常用于实现队列数据结构，支持先进先出(FIFO)的操作。这个不用勉强，后面数据结构会讲
Map：存储键值对的集合，不允许有重复的键。
速成阶段大家只需要掌握List
import java.util.*;
public class CollectionExample {
public static void main(String[] args) {
// ================== List 示例 ==================
System.out.println("List 示例:");
List<String> list = new ArrayList<>();
list.add("Apple"); // 添加元素到列表末尾
list.add("Banana");
list.add("Apple"); // List允许重复元素
System.out.println("原始列表: " + list);
System.out.println("索引1处的元素: " + list.get(1)); // 通过索引访问元素
}
}
原始列表: [Apple, Banana, Apple]
索引1处的元素: Banana十一、IO流(Input/Output Streams)
那什么是流，就想象成水管子就行，我就是这么抽象，然后数据就相当于水。IO就是取和存，
这里有人不理解，I不是相当于Input往里的存吗，其实这里的IO是相对外部资源的，外部资源要展示在程序中就要通过输入即Input，而程序要对外部资源进行数据传输就要输出出去即Output。
这些外部资源可以是文件、网络连接等
package com.whm.io;
import java.io.*;
public class Test {
public static void main(String[] args) {
//字符流
//输入输出流创建和读取文件
File f = new File("D://whm.txt");//文件路径
FileWriter fw = null;
try {
fw = new FileWriter(f);
fw.write("你好，你成功读出");//向文件写入东西
} catch (IOException e) {//这个异常前面跟大家说过，应该还记得吧！！！
e.getStackTrace();
} finally {
try {
fw.close();//关闭流，水管嘛，不管浪费资源
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//读出文件内容
try {
FileReader fr = new FileReader("D://whm.txt");
char []arr=new char[220];
int length;
while ((length = fr.read(arr)) != -1) {
System.out.println(new String(arr, 0, length));
}
}catch (IOException e){
e.getStackTrace();
}
}
}
大家可以看到如果文件不存在，我的D盘根据路径自动创建的文件：
十二、线程
这里了解一下线程是什么，怎么创建，怎么运行就行
至于同步、锁、线程池这些速成之后再去了解，因为速成是为了建立一个大概的脉络
| 概念 | 说明 |
|---|---|
Thread 类 | Java中表示线程的基本类 |
start() 方法 | 启动一个新线程，JVM会调用该线程的 run() 方法 |
run() 方法 | 线程要执行的任务逻辑，通常通过重写或使用 Lambda 表达式定义 |
sleep() 方法 | 让当前线程暂停一段时间（单位为毫秒），用于模拟耗时任务 |
| 线程名 | 可以通过构造器设置线程名称，便于调试和日志输出 |
线程是程序执行流的最小单元。多线程允许同时执行多个任务，从而提高程序的响应速度和效率。
线程状态：包括新建、就绪、运行、阻塞、等待、超时等待和终止等状态。
class MyThread extends Thread {
@Override
public void run() {
for (int i = 1; i <= 3; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
public class Main {
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
t1.start(); // 启动线程1
t2.start(); // 启动线程2
}
}输出结果：
Thread-0: 1
Thread-1: 1
Thread-0: 2
Thread-1: 2
Thread-0: 3
Thread-1: 3十三、网络编程
这里了解一下Socket套接字就可以，然后就可以从头细学了，因为后面的JavaWeb中也会用到Socket，所有大家从头下学到这的时候要认真学这部分基础
Socket编程是网络通信的基础，它允许不同计算机之间通过网络进行数据交换->也就是类似微信聊天
掌握两个核心:
- ServerSocket：监听来自客户端的连接请求。嗯每个服务器至少有一个对象（实例）
- Socket：客户端或服务器端的通信端点。客户端使用
Socket连接到服务器，服务器则接受来自客户端的Socket连接。
前面学习的IO流在这就体现出来了，可以通过IO流进行相互传输数据
运行的时候一定要先运行服务器端监听端口，再运行客户端进行连接
服务器端：
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Socketdemo {
public static void main(String[] args) throws IOException {
int port = 12345; // 服务器监听的端口号
ServerSocket serverSocket = new ServerSocket(port);
System.out.println("服务器启动，等待连接...");
try (Socket clientSocket = serverSocket.accept()) { // 等待客户端连接
System.out.println("客户端已连接: " + clientSocket.getInetAddress());
// 获取输入流读取客户端发送的消息
BufferedReader in = new BufferedReader(new
InputStreamReader(clientSocket.getInputStream()));
String inputLine;
while ((inputLine = in.readLine()) != null && !inputLine.equals("bye")) {
System.out.println("收到客户端消息: " + inputLine);
}
// 获取输出流向客户端发送消息
PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
out.println("Goodbye, thanks for connecting.");
} catch (IOException e) {
e.printStackTrace();
}
}
}客户端：
import java.io.*;
import java.net.Socket;
public class SimpleClient {
public static void main(String[] args) throws IOException {
String hostname = "localhost"; // 服务器地址
int port = 12345; // 连接的端口号
try (Socket socket = new Socket(hostname, port)) {
// 发送消息给服务器
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello from client!");
// 接收服务器响应
BufferedReader in = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
String response;
while ((response = in.readLine()) != null) {
System.out.println("收到服务器响应: " + response);
break; // 假设只接收一条消息后退出
}
// 发送结束信号
out.println("bye");
} catch (IOException e) {
e.printStackTrace();
}
}
}如果做的不好有改进的地方，希望大家给点建议，谢谢支持！！！
速成阶段的路线基本就是基础语法->面向对象->集合框架->IO->多线程->网络编程
中间还有很多内容等着小伙伴们学，这个只时候大家大概了解JavaSE。熟话说要学习一个知识点得先大概了解它的整体框架，然后再慢慢的深入，祝每一位小伙伴都可以把Java学的很好，也多指点指点我，谢谢你们！
扫一扫
1943
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
