在C++完结已经过去一个多月了，目前我也正在学习算法，然而博客却更新的少之又少，接下来，我将继续更新技术博客，接下来的大一暑假Linux专栏也会开始持续更新，在此之前，先来总结一下Java的基础，同时也是为了应付期末考，我将结合我的理解，从C++学完的视角来进行快速过java期末考！作为过渡篇开始！在话不多说，让我们直接开始一篇的教学吧！
一、Java是什么
Java 是一门面向对象、跨平台的编程语言，它的“跨平台”靠的是 JVM（Java 虚拟机） —— 你写的 .java 源码编译成 .class 字节码，JVM 负责把字节码翻译成当前操作系统能执行的指令。所以“一次编写，到处运行”不是吹的。
第一个程序：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Java!");
}
}
其中public class类名必须与文件名一致，然后再到main函数，这里再Idea（java编译器环境）中可以输入“main”回车-即可生成 public static void main(String[] args){}；
System.out.println 是打印并换行，这里可以输入“sout”回车-即可生成。
注意：JDK、JRE、JVM 的关系（JDK 包含 JRE，JRE 包含 JVM）。
main 方法的写法（String[] args 能否换成 String args[]？可以，但推荐前者）。
注释：单行 //、多行 /* /、文档注释 /* */。
二、数据类型与变量–一切数据的“容器”
2.1考试只需要记住这六种就行了
byte：一字节长度；short：二字节长度；
int：四字节长度；long：八字节长度；
float：四字节长度；double：八字节长度
注意一个特殊符号：boolean：只存放true/false；如同C语言当中的bool，区别是用于判断正误的，常在if或者while中使用：用于接收一个条件式如：1>2,此时不成立，返回false推出；反之如此。
int age = 20;
double price = 99.9;
char grade = 'A';
boolean isPass = true;
String name = "张三"; // String 是引用类型
2.2类型转换
自动类型转换（小→大）：int -> long -> float -> double
强制类型转换（大→小）：可能丢失精度（不推荐）
byte a=2；
int b=(int)a;//显示强制类型转换；
三、运算符讲解：（重点）
3.1算数运算符
-
-
- / %
前三个和数学一样；
整数除法结果为整数（截断），5/2；结果为2（取结果，不取余数）
取模 % 结果符号与被除数相同，1234%10；结果为4（不取结果，取余数）
注意：在编程中需要用变量接收：int a=1234%10;
- / %
-
3.2 赋值运算符
= += -= *= /= %=
a += 3 等价于 a = a + 3（但隐式强转，byte b=1; b+=1; 没问题，因为 += 自动强转）。
3.3 关系运算符
== != > < >= <=，结果 boolean。
3.4 逻辑运算符
&& || !（短路特性：&& 左假右不执行，|| 左真右不执行）。
&&（并且的意思，两个都要满足）||（或者的意思，其中一个满足即可）！（否则，常与=一起用，为不等于）
3.5 位运算符（了解）
& | ^ ~ << >> >>>，考试不深究，但知道 ^ 异或可交换两个数。
3.6 三元运算符
int max = (a > b) ? a : b;//意思是如果a>b？（如果成立则赋值a）a：（不成立则赋值b）
注意：只有位运算要了解，其他必须掌握！
符号注意点！
区分好标识符，关键字，保留字等，
标识符：不已数字开头，不能是public，class,int,这类特定含义的关键字，严格区分大小写；
四、分支与循环
这里提一嘴即可，C语言与其一模一样
if-else
if (score >= 90) {
System.out.println("优秀");
} else if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
switch
switch (day) {
case 1:
System.out.println("周一");
break;
case 2:
System.out.println("周二");
break;
default:
System.out.println("其他");
}
别忘了break，否则会穿透（到下一个case或者default）；
for循环
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
while循环
int i = 0;
while (i < 10) {
System.out.println(i);
i++;
}
do-while
int i = 0;
do {
System.out.println(i);
i++;
} while (i < 10);
注意：break 与 continue
break：跳出当前循环。
continue：跳过本次循环剩余部分，进入下一次循环。
考点：循环嵌套（打印九九乘法表、菱形等）。
死循环写法：for(;😉 或 while(true)
五、Java输入输出-与用户交互
System.out.print()（不换行）、System.out.println()（换行）、System.out.printf()（格式化输出）。
输入：（重要！！！）
导包（相当于C语言当中的头文件）：import java.util.Scanner//最前面开始导
看清楚下面注释即可；
import java.util.Scanner; // 必须导包
Scanner sc = new Scanner(System.in);
System.out.print("请输入姓名：");
String name = sc.nextLine(); // 读取一行字符串
System.out.print("请输入年龄：");
int age = sc.nextInt(); // 读取整数
System.out.print("请输入成绩：");
double score = sc.nextDouble();
sc.close(); // 养成关闭习惯（非必须但良好）
了解：nextInt() 后调用 nextLine() 会读取到换行符，需要额外处理（加一个 sc.nextLine() 吃掉换行）
输入多个数据可用空格或回车分隔。
六、方法使用（方法就是函数，在JAVA里称方法）
6.1定义
[修饰符] 返回值类型 方法名(参数列表) {
// 方法体
return 返回值;
}
无返回值（void）
public static void sayHello(String name) {
System.out.println("Hello, " + name);
}
有返回值（int）
public static int add(int a, int b) {
return a + b;
}
6.2方法重载（Overload）
同一个类中，方法名相同，参数列表不同（类型、个数、顺序）。
public static int add(int a, int b) { return a+b; }
public static double add(double a, double b) { return a+b; }
public static int add(int a, int b, int c) { return a+b+c; }
注意：返回值类型不同不能构成重载。
6.3 递归
方法调用自身，必须有终止条件
// 阶乘
public static int factorial(int n) {
if (n == 1) return 1;
return n * factorial(n - 1);
}
递归效率低，但思想重要。
6.4 参数传递
// 交换两个数（错误示范）
public static void swap(int a, int b) { int tmp=a; a=b; b=tmp; } // 不会影响外部
// 若要交换，可用数组或对象包装。
七、调试（与考试无关，跳过，对JAVA感兴趣，向往这方向走的联系我）
八、数组的定义与使用
8.1数组声明
int[] arr; // 推荐
int arr2[];
8.2初始化
// 动态初始化（指定长度，默认值）
int[] arr = new int[5]; // 元素全为0
// 静态初始化（直接赋值）
int[] arr2 = {1, 2, 3, 4, 5};
int[] arr3 = new int[]{1, 2, 3};
8.3长度与遍历
int len = arr.length; // 属性，不是方法
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 增强 for（foreach）//这里不用管，是进阶的深度刨析方法
for (int num : arr) {
System.out.println(num);
}
8.4多维数组（可跳过）
int[][] matrix = new int[3][4]; // 3行4列
// 或
int[][] matrix2 = {{1,2},{3,4},{5,6}};
// 遍历
for (int i = 0; i < matrix2.length; i++) {
for (int j = 0; j < matrix2[i].length; j++) {
System.out.print(matrix2[i][j] + " ");
}
System.out.println();
}
重点注意：数组下标从0开始，越界（一个数组有10个元素，若访问int a[10]）报错:[]内指下标，越界访问！
数组是对象，声明时只是引用，必须 new 分配空间。
接下来难度升级，需要结合ai理解，如果没上过课或者没学过相关内容会炸！有C++基础的很舒服，需要结合课堂和其他内容相互理解，和idea一边操作，一边学习也可以，找我要资料也行！死记硬背根本不明白
九、类和对象
类：模板（蓝图），定义属性和行为。
对象：类的实例（具体实体）。
9.1定义类
public class Student {
// 属性（成员变量）
String name;
int age;
String grade;
// 方法（行为）
public void study() {
System.out.println(name + " 正在学习");
}
public void showInfo() {
System.out.println("姓名：" + name + "，年龄：" + age);
}
}
9.2创建对象和调用
Student s = new Student(); // new 分配内存，调用构造方法
s.name = "小明";
s.age = 18;
s.study();
9.3构造方法（Constructor）（主要用于方便实例化类对象）
与类同名，无返回值（连 void 都不写）。
若未定义，系统提供默认无参构造。
可重载。
public class Student {
String name;
int age;
// 无参构造
public Student() {}
// 有参构造
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
this 代表当前对象，用于区分成员变量和局部变量。
9.49.5 内存分析（简化）
栈：存储局部变量和引用。
堆：存储对象实例（成员变量在堆中）。
方法区：存储类信息、静态变量。
十、类和对象（二）—— 封装、static、代码块
10.1 封装（Encapsulation）
使用 private 修饰属性，提供 public 的 getter/setter 方法。
public class Person {
private String name;
private int age;
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;
else System.out.println("年龄不合法");
}
}
10.2 static 关键字
静态变量：属于类，所有对象共享，类名直接访问。
静态方法：只能访问静态成员，不能使用 this。
静态代码块：类加载时执行一次，用于初始化静态资源。
public class MyClass {
static int count = 0; // 静态变量
public static void showCount() {
System.out.println(count);
}
static {
System.out.println("静态代码块执行");
count = 100;
}
}
10.3 代码块
实例代码块：每次创建对象前执行（优先于构造方法）。
静态代码块：类加载时执行一次。
10.4 包（package）（相当于C语言当中的头文件，但区别是类包含，有着本质不同，可以结合理解）但一般不考
组织类，避免命名冲突。使用 import 导入其他包的类。
十一、继承–代码复用（父类和子类要搞清楚）
继承概念
继承(inheritance)机制：是⾯向对象程序设计使代码可以复⽤的最重要的⼿段，它允许程序员在保持原有类特性的基础上进⾏扩展，增加新功能，这样产⽣新的类，称派⽣类。继承呈现了⾯向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复⽤。
例如：狗和猫都是动物，那么我们就可以将共性的内容进⾏抽取，然后采⽤继承的思想来达到共⽤
class 子类 extends 父类 { ... }
如果两个类出现一部分相同，则可以封装成一个父类animal进行继承使用，减少了代码浪费
图片来源：比特就业课课件，切勿转载
// Animal.java
public class Animal{
String name;
int age;
public void eat(){
System.out.println(name + "正在吃饭");
}
public void sleep(){
System.out.println(name + "正在睡觉");
}
}
// Dog.java
public class Dog extends Animal{
void bark(){
System.out.println(name + "汪汪汪~~~");
}
}
// Cat.Java
public class Cat extends Animal{
void mew(){
System.out.println(name + "喵喵喵~~~");
}
}
// TestExtend.java
public class TestExtend {
public static void main(String[] args) {
Dog dog = new Dog();
// dog类中并没有定义任何成员变量，name和age属性肯定是从⽗类Animal中继承下来的
System.out.println(dog.name);
System.out.println(dog.age);
// dog访问的eat()和sleep()⽅法也是从Animal中继承下来的
dog.eat();
dog.sleep();
dog.bark();
}
}
从上述代码我们可以看到Dog类和Cat类的部分代码重复使⽤了Animal中的代码。
子类能继承什么？
继承 public 和 protected 成员（包括属性和方法）。
同包下继承默认访问权限成员。
不能继承 private 成员，但可通过 getter 访问。
super 关键字
访问父类成员：super.属性、super.方法()。
调用父类构造：super(参数) 必须放在子类构造方法第一行。
class Animal {
String name;
public Animal(String name) { this.name = name; }
public void eat() { System.out.println(name + " 吃东西"); }
}
class Dog extends Animal {
String breed;
public Dog(String name, String breed) {
super(name); // 必须调用父类构造
this.breed = breed;
}
public void bark() {
System.out.println(name + " 汪汪叫");
}
}
方法重写（Override）
子类重新定义父类的方法（方法名、参数、返回值相同，访问权限不能更严格）。
作用：用来调整对应子类能输出不同的函数，表明了事物的独特性
@Override // 注解，建议写
public void eat() {
System.out.println(name + " 吃狗粮");
}
注意：重写 vs 重载：重载在同一个类，重写在子类。
final 关键字
修饰类：不可被继承。
修饰方法：不可被重写。
修饰变量：常量（不可变）。
十二、多态 —— 同一个方法，不同行为
12.1 多态的前提
有继承关系。
子类重写父类方法。
父类引用指向子类对象（向上转型）。
Animal a = new Dog("小黑", "金毛");
a.eat(); // 实际执行 Dog 的 eat()，输出“小黑 吃狗粮”
12.2 编译时类型 vs 运行时类型
编译看左边（Animal 类中有 eat 方法才能编译）。
运行看右边（实际调用 Dog 的 eat）。
12.3 向下转型（强制转换）
Dog d = (Dog) a; // 需确保 a 实际是 Dog 类型
d.bark();
多态的用处
参数多态：方法接收父类引用，可传入任何子类对象。
提高代码扩展性（开闭原则）。
12.4考点
多态与继承组合的题目，判断输出结果（注意方法调用顺序）（结合学习通和ai！！！很难，要么找我要资料!!!）。
十三、抽象类和接口 —— 规范与契约
13.1 抽象类（abstract）
含抽象方法的类必须声明为 abstract。
抽象方法只有声明，没有实现（public abstract void method();）。
抽象类不能实例化，但可以定义构造方法供子类调用。
abstract class Shape {
public abstract double area(); // 抽象方法
public void info() {
System.out.println("这是一个形状");
}
}
class Circle extends Shape {
double radius;
public Circle(double r) { radius = r; }
@Override
public double area() { return Math.PI * radius * radius; }
}
13.2接口（interface）
所有方法默认为 public abstract（JDK8 前）。
所有属性默认为 public static final（常量）。
实现用 implements，一个类可实现多个接口。
interface Drawable {
void draw(); // 默认为 public abstract
}
interface Movable {
void move(int x, int y);
}
class Car implements Drawable, Movable {
@Override
public void draw() { System.out.println("画汽车"); }
@Override
public void move(int x, int y) { System.out.println("移动到 (" + x + "," + y + ")"); }
}
13.3抽象类 vs 接口
抽象类有状态（属性），接口只能有常量。
抽象类可有具体方法，接口在 JDK8 后可用 default 和 static 方法。
类单继承，多实现。
13.4 常用接口示例
Comparable（排序）、Runnable（多线程）、Serializable（序列化）。
十四、字符串·String 类 —— 最常用的引用类型
14.1 String 的特点
不可变性（一旦创建，内容不可变，任何修改都会产生新对象）。
底层是 char[]（JDK9 后为 byte[]）。
14.2 创建方式
String s1 = "hello"; // 字面量，存在字符串常量池
String s2 = new String("hello"); // new 对象，在堆中
14.3 常用方法（必考！！！）
String str = "Hello World";
int len = str.length(); // 长度
char c = str.charAt(0); // 'H'
int idx = str.indexOf("World"); // 6
String sub = str.substring(6); // "World"
String lower = str.toLowerCase(); // "hello world"
String upper = str.toUpperCase(); // "HELLO WORLD"
String[] parts = str.split(" "); // ["Hello","World"]
boolean b = str.startsWith("He"); // true
boolean b2 = str.contains("Wo"); // true
String trimmed = " abc ".trim(); // "abc"
记忆表格
| 方法调用 | 返回值类型 | 功能含义 | 示例结果 | 考试高频考点 |
|---|---|---|---|---|
| str.length() | int | 获取字符串字符总长度（空格、符号都算） | 11 | 区分：数组length属性，字符串length()方法 |
| str.charAt(下标) | char | 获取指定下标位置的单个字符 | str.charAt(0) → ‘H’ | 下标越界会抛异常 |
| str.indexOf(“子串”) | int | 查找子串首次出现的起始下标，找不到返回 -1 | indexOf(“World”) → 6 | 常考判断是否包含、截取字符串 |
| str.substring(start) | String | 从 start 下标开始，截取到字符串末尾 | substring(6) → “World” | 左闭区间 [start, 末尾] |
| str.substring(start,end) | String | 截取 [start,end) 区间字符（包含 start，不包含 end） | substring(0,5) → “Hello” | 期末必考区间规则 |
| str.toLowerCase() | String | 全部字母转小写，原字符串不变 | “hello world” | String 不可变，必须用变量接收结果 |
| str.toUpperCase() | String | 全部字母转大写 | “HELLO WORLD” | 验证码、校验场景常考 |
| str.split(“分割符”) | String[] | 按指定符号切割字符串，返回字符串数组 | split(" ") → [“Hello”,“World”] | 空格、逗号分割是大题常客 |
| str.startsWith(“前缀”) | boolean | 判断字符串是否以指定内容开头 | startsWith(“He”) → true | 布尔返回值，if 判断常用 |
| str.contains(“子串”) | boolean | 判断字符串是否包含指定子串 | contains(“Wo”) → true | 模糊匹配判断 |
| " abc ".trim() | String | 去除字符串首尾空格，中间空格保留 | “abc” | 表单去空格基础操作 |
核心易错点（考试丢分重点）
String 是不可变字符串，所有操作（转大小写、截取、切割）都会生成新字符串，原字符串不会改变，必须赋值接收结果；
substring(start, end) 左取右不取；
indexOf 找不到目标返回 -1，可用来判断是否包含；
比较字符串内容统一用 equals()，== 只比较地址；
length() 是方法带括号，数组 arr.length 是属性无括号。
这里背了就有分！但要理解，知道！
十五、异常
15.1异常处理方式
try-catch-finally
try {
int[] arr = new int[5];
System.out.println(arr[10]); // 可能越界
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("数组越界：" + e.getMessage());
} finally {
System.out.println("无论如何都会执行");
}
throws（向上抛出）
public void readFile() throws IOException {
// 不处理，交给调用者
}
throw（手动抛出）
if (age < 0) {
throw new IllegalArgumentException("年龄不能为负数");
}
15.3 自定义异常
class MyException extends Exception {
public MyException(String msg) { super(msg); }
}
// 使用
throw new MyException("自定义错误");
finally 常见问题
finally 中通常释放资源（关闭文件、数据库连接）。
如果 finally 中有 return，会覆盖 try 中的 return。
十六、常用工具类介绍
包装类（Wrapper）
基本类型 → 引用类型（Integer、Double、Character、Boolean 等）。
自动装箱：Integer i = 100;
自动拆箱：int a = i;
Integer i1 = Integer.valueOf(100);
int i2 = i1.intValue();
// 字符串转数字
int num = Integer.parseInt("123");
Arrays 类（数组工具）
int[] arr = {5, 2, 8, 1, 9};
Arrays.sort(arr); // 排序
int index = Arrays.binarySearch(arr, 8); // 二分查找（先排序）
String str = Arrays.toString(arr); // 数组转字符串
int[] copy = Arrays.copyOf(arr, arr.length);
boolean eq = Arrays.equals(arr, copy);
Collections 类（集合工具）
针对 List、Set、Map 等（集合在进阶课程，但期末可能提）。
Collections.sort(list)
Collections.reverse(list)
Collections.shuffle(list)
Math类
Math.max(a, b);
Math.min(a, b);
Math.pow(2, 3); // 8.0
Math.sqrt(9); // 3.0
Math.random(); // [0.0, 1.0) 随机数
Date 与 LocalDateTime（时间日期）
旧版 Date、SimpleDateFormat，新版 java.time（推荐）。
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
LocalDate now = LocalDate.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String dateStr = now.format(fmt); // 2026-07-11
Scanner（输入）和 System（输出）——前面已经讲过
Random 类
Random rand = new Random();
int num = rand.nextInt(100); // 0~99
double d = rand.nextDouble(); // 0.0~1.0
最后冲刺建议
动手敲代码：每节的示例至少自己写一遍，不要只看。
理清关系：继承、多态、抽象、接口这些概念要画图理解。
利用好ai：让它给出个代码例子给你，简单理解
学习通：结合学习通题目进行作业
Java 并不难，只要把基础打牢，考试就是“照葫芦画瓢”。
转载自 CSDN-专业IT技术社区
原文链接：https://blog.csdn.net/mogreat/article/details/162787849
