目录
1.在学习循环语句时，我有时会忘记更新循环变量，导致出现死循环的情况；
2.例如，在传递对象作为参数时，我错误地认为传递的是对象的副本而不是引用；
6.容易造成方法重载，不会使用导致参数胡乱调用，不知道走那一个调用方法；
7.递归的是要经常混乱，还是建议借助图来解决；（下面是斐波那契数列递归图）
1.通过try-catch-finally语句块和throw/throws关键字
作为一个初学者，开始学习 JavaSE 时，我感到非常兴奋和挑战。经过几个月的学习和实践，我终于完成了 JavaSE 的基本课程。在这个过程中，我学会了 Java 的基本概念，如变量、数据类型、运算符等，以及如何使用这些概念来编写程序。
一.初始JAVA
当我最初接触Java时，给我印象最深的是它的跨平台特性，这得益于Java虚拟机（JVM）。编写好的Java代码可以在不同操作系统上运行，只要该系统安装了对应的JVM。
1.一个简单的Hello World程序
在这个程序中，public class定义了一个公共类，main方法是程序的入口点，System.out.println用于输出信息到控制台。
2.注释
1.单行注释
// 注释内容（用的最多）
使用方法：crtl+/
2.多行注释
/* 注释内容*/（不推荐）
使用方法：crtl+shift+/
3.文档注释
/** 文档注释 */（常见于方法和类之上描述方法和类的作用)，可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档
二.数据类型与变量
1.数据类型
基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型和布尔型等，而引用数据类型则包括类、接口、数组等
int num = 10; // 声明一个整型变量并赋值
double price = 9.99; // 声明一个浮点型变量并赋值
char letter = 'A'; // 声明一个字符型变量并赋值
boolean flag = true; // 声明一个布尔型变量并赋值2.变量
1整形，2浮点型，3字符型，4布尔型
1
// 方式一：在定义时给出初始值
int a = 10;
System.Out.println(a);
// 方式二：在定义时没有给初始值，但使用前必须设置初值
int b;
b = 10;
System.Out.println(b);
// 使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
int c;
System.Out.println(c);
c = 100;
// int型变量所能表示的范围：
System.Out.println(Integer.MIN_VALUE);
System.Out.println(Integer.MAX_VALUE);
// 注意：在定义int性变量时，所赋值不能超过int的范围
int d = 12345678901234; // 编译时报错，初值超过了int的范围
2
double d = 3.14;
System.Out.println(d);
float num = 1.0f; // 写作 1.0F 也可以
System.out.println(num);
3
char c1 = 'A'; // 大写字母
char c2 = '1'; // 数字字符
System.out.println(c1);
System.out.println(c2);
// 注意：java中的字符可以存放整形
char c3 = '帅';
System.out.println(c3);
4
boolean b = true;
System.out.println(b);
b = false;
System.out.println(b);
三.运算符
Java有丰富的运算符，包括算术运算符（+、-、*、/、%）、关系运算符（>、<、==、!=等）、逻辑运算符（&&、||、!）等。例如：
int a = 5, b = 3;
int sum = a + b; // 算术运算符：加法
boolean isEqual = (a == b); // 比较运算符：等于
boolean isGreater = (a > b); // 比较运算符：大于
boolean andResult = (a > b) && (sum > 5); // 逻辑运算符：与四.程序逻辑控制
1.语句
程序逻辑控制主要包括条件语句（if - else）和循环语句（for、while、do - while）。if - else语句用于根据不同的条件执行不同的代码块，例如：
int score = 80;
if (score >= 60) {
System.out.println("及格");
} else {
System.out.println("不及格");
}
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
int j = 0;
while (j < 3) {
System.out.println(j);
j++;
}2.可能会出现的错误
1.在学习循环语句时，我有时会忘记更新循环变量，导致出现死循环的情况；
2.i未++；
3.i<3 j++；
4.i<边界不符合；
五.方法的使用
1.方法可以接受参数并返回结果
public class jkl {
public static int add(int a, int b) {
return a + b;
}
}
// 调用方法
int result = jkl.add(5, 3);
System.out.println(result); // 输出：82.如果多个方法的名字相同，参数列表不同 == 重载
public class TestMethod {
public static void main(String[] args) {
add(1, 2); // 调用add(int, int)
add(1.5, 2.5); // 调用add(double, double)
add(1.5, 2.5, 3.5); // 调用add(double, double, double)
}
public static int add(int x, int y) {
return x + y;
}
}
public static double add(double x, double y) {
return x + y;
}
public static double add(double x, double y, double z) {
return x + y + z;
}
}
3.可能出现的错误
1.在实际应用中，我曾因方法参数传递不当导致数据丢失。
2.例如，在传递对象作为参数时，我错误地认为传递的是对象的副本而不是引用；
3.传入参数未用合适的类型接收；
4.接收的个数和传入的个数不匹配；
5.接收的参数之间未用','进行隔开；
6.容易造成方法重载，不会使用导致参数胡乱调用，不知道走那一个调用方法；
7.递归的是要经常混乱，还是建议借助图来解决；（下面是斐波那契数列递归图）
六.数组的定义与使用
1.定义数组：
//动态定义，只定义大小
int[] arr = new int[5];
// 静态定义，只定义内容
int[] arr2 = {1, 2, 3};2.遍历数组
int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}3.可能出现的错误
1. 未初始化数组
在Java中，数组必须被初始化才能使用。初学者可能会忘记初始化数组。
错误写法：
int[] myArray;
// 使用myArray时会出现NullPointerException正确写法：
int[] myArray = new int[10]; // 初始化数组2. 错误地访问数组长度
初学者可能会错误地使用length属性来访问数组的长度。
错误写法：
int[] myArray = new int[5];
int length = myArray.length; // 正确，但初学者可能会写成myArray.length()正确写法：
int length = myArray.length; // length是数组的长度3. 越界访问
数组索引是从0开始的，所以访问数组时，索引值不能超过数组的长度减1。初学者可能会访问数组的越界索引。
错误写法：
int[] myArray = new int[5];
int value = myArray[5]; // ArrayIndexOutOfBoundsException正确写法：
if (index >= 0 && index < myArray.length) {
int value = myArray[index];
}4. 将数组作为参数传递
初学者可能会错误地将数组作为方法的参数传递。
错误写法：
public void printArray(int[] myArray) {
for (int i = 0; i < myArray.length; i++) {
System.out.println(myArray[i]);
}
}
int[] myArray = new int[5];
printArray(myArray);正确写法：
public void printArray(int[] myArray) {
for (int i = 0; i < myArray.length; i++) {
System.out.println(myArray[i]);
}
}
int[] myArray = new int[5];
printArray(myArray); // 正确传递数组5. 错误地修改数组大小
初学者可能会尝试修改数组的大小，但数组的大小是固定的，不能被修改。
错误写法：
int[] myArray = new int[5];
myArray = new int[10]; // 错误，不能修改数组大小正确写法：
int[] myArray = new int[5];
int[] newArray = new int[10]; // 创建一个新的数组6. 混淆数组和ArrayList
初学者可能会混淆数组和ArrayList的使用。
错误写法：
ArrayList<Integer> myList = new ArrayList<Integer>();
myList[0] = 10; // 错误，ArrayList使用get和set方法访问元素正确写法：
ArrayList<Integer> myList = new ArrayList<Integer>();
myList.add(10); // 添加元素
int value = myList.get(0); // 获取元素7. 多维数组的错误使用
在处理多维数组时，初学者可能会混淆索引。
错误写法：
int[][] myMultiArray = new int[3][2];
int value = myMultiArray[1][2]; // 错误，第二维只有2个元素正确写法：
int[][] myMultiArray = new int[3][2];
int value = myMultiArray[1][1]; // 正确七.类和对象
1.类定义格式
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
2.类的实例化
public class Main{
public static void main(String[] args) {
PetDog dogh = new PetDog(); //通过new实例化对象
dogh.name = "阿黄";
dogh.wag();
}
}
输出结果：
阿黄: 旺旺旺~~~
3.this使用
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
//this引用的是调用成员方法的对象，区分使用的量
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}
4.对象的初始化
public static void main(String[] args) {
Date d = new Date();
d.printDate();
d.setDate(2021,6,9);
d.printDate();
}
// 代码可以正常通过编译5.可能会出现的错误
-
类名和文件名不匹配： 在Java中，公共类的名称必须与文件名完全匹配。如果类名和文件名不一致，会导致编译错误。
// 错误示例 public class MyClass { // ... } // 文件名应该是MyClass.java -
构造函数使用错误： 构造函数的名称必须与类名完全相同，并且不能有返回类型。
// 错误示例 public int MyClass() { // ... } // 正确示例 public MyClass() { // ... } -
成员变量和局部变量混淆： 初学者可能会错误地将局部变量当作成员变量使用，或者反之。
// 错误示例 public class MyClass { int myField; public void myMethod() { int myField = 10; // 错误：局部变量名称与成员变量名称相同 } } -
访问修饰符使用不当： 初学者可能会混淆
public、private和protected访问修饰符的使用。// 错误示例 public class MyClass { public int myField; // 正确：可以被任何其他类访问 private int myPrivateField; // 错误：不应该在类外部访问 public void myMethod() { System.out.println(myPrivateField); } } -
对象创建和使用错误： 初学者可能会忘记创建对象实例，或者错误地使用对象。
// 错误示例 MyClass myObject; // 错误：没有使用new关键字创建对象 myObject.myMethod(); // 错误：myObject是null，不能调用方法 // 正确示例 MyClass myObject = new MyClass(); myObject.myMethod(); -
方法重载和重写混淆： 初学者可能会混淆方法重载（Overloading）和方法重写（Overriding）的概念。
// 错误示例 public class MyClass { public void myMethod() { // ... } public void myMethod(int param) { // 错误：这不是重写，这是重载 // ... } } -
this关键字使用不当：
this关键字用于引用当前对象的成员变量或方法，初学者可能会错误地使用它。// 错误示例 public class MyClass { int myField; public void myMethod() { int myField = this.myField; // 错误：不需要使用this } } -
静态成员和实例成员混淆： 初学者可能会错误地将静态方法或静态变量与实例变量混淆。
// 错误示例 public class MyClass { static int myStaticField; public void myMethod() { myStaticField = 10; // 错误：静态变量应该通过类名访问 } } -
错误地覆盖finalize方法： 初学者可能会错误地覆盖
finalize方法，而没有调用super.finalize()。// 错误示例 public class MyClass { @Override protected void finalize() throws Throwable { // ... } // 正确示例：调用super.finalize() @Override protected void finalize() throws Throwable { super.finalize(); // ... } } -
对象比较错误： 初学者可能会错误地使用
==来比较两个对象的内容。// 错误示例 MyClass obj1 = new MyClass(); MyClass obj2 = new MyClass(); if (obj1 == obj2) { // 错误：比较的是两个对象的内存地址 // ... } // 正确示例：使用equals方法 if (obj1.equals(obj2)) { // ... }
八.继承和多态
1.继承的语法
修饰符 class 子类 extends 父类 {
// ...
}2.this子类，super子类调用父类的方法和参数
class Student extends Person {
private String school;
public Student(String name, int age, String school) {
super(name, age);
this.school = school;
}
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
}3.多态是同一个行为的不同表现方式
public class Animal {
String name;
int age;
public Animal(String name, int age){
this.name = name;
this.age = age;
}
public void eat(){
System.out.println(name + "吃饭");
}
}
public class Cat extends Animal{
public Cat(String name, int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃鱼~~~");
}
}
public class Dog extends Animal {
public Dog(String name, int age){
super(name, age);
}
@Override
public void eat(){
System.out.println(name+"吃骨头~~~");
}
}4.可能出现的错误
1. 错误使用继承
错误写法：继承了不应该继承的类。
public class Animal {
// ...
}
public class Dog extends Animal {
// ...
}
public class Cat extends Animal {
// ...
}
public class Car extends Animal { // 错误：Car 不应该是 Animal 的子类
// ...
}正确做法：确保继承关系在逻辑上是有意义的。
2. 覆盖方法时使用错误的访问修饰符
错误写法：子类覆盖父类方法时使用了错误的访问修饰符。
public class Parent {
private void show() {
// ...
}
}
public class Child extends Parent {
public void show() { // 错误：无法覆盖 private 方法
// ...
}
}正确做法：确保子类方法的访问级别允许覆盖父类方法。
public class Parent {
protected void show() {
// ...
}
}
public class Child extends Parent {
@Override
protected void show() {
// ...
}
}3. 覆盖equals方法时未考虑继承
错误写法：覆盖equals方法时没有正确处理继承。
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return name != null ? name.equals(person.name) : person.name == null;
}
// ...
}
public class Employee extends Person {
private int id;
public Employee(String name, int id) {
super(name);
this.id = id;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Employee employee = (Employee) o;
return id == employee.id;
} // 错误：没有调用 super.equals(o)
}正确做法：在覆盖equals方法时，应该调用super.equals(o)。
4. 错误地使用多态
错误写法：错误地使用多态。
public class Animal {
public void makeSound() {
System.out.println("Some sound");
}
}
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Bark");
}
}
public class TestPolymorphism {
public static void main(String[] args) {
Animal myAnimal = new Animal();
myAnimal.makeSound(); // 输出 "Some sound"
Animal myDog = new Dog();
myDog.makeSound(); // 错误：输出 "Some sound" 而不是 "Bark"
}
}正确做法：确保多态的正确使用。
public class TestPolymorphism {
public static void main(String[] args) {
Animal myAnimal = new Animal();
myAnimal.makeSound(); // 输出 "Some sound"
Dog myDog = new Dog();
myDog.makeSound(); // 正确：输出 "Bark"
}
}5. 未正确实现接口
错误写法：接口中的所有方法未被实现。
public interface Runable {
void run();
void stop(); // 新增方法
}
public class Car implements Runable {
@Override
public void run() {
// ...
} // 错误：未实现接口中的 stop 方法
}正确做法：确保实现接口时覆盖了接口中的所有方法。
public class Car implements Runable {
@Override
public void run() {
// ...
}
@Override
public void stop() {
// ...
}
}6. 错误地使用抽象类
错误写法：抽象类中包含抽象方法以外的错误使用。
public abstract class Animal {
public abstract void makeSound();
public void eat() { // 错误：抽象类中不应该包含具体的实现
// ...
}
}正确做法：抽象类中可以包含抽象方法和具体方法，但应确保逻辑正确。
public abstract class Animal {
public abstract void makeSound();
public void breathe() {
// 具体实现
}
}7. 错误地使用final关键字
错误写法：错误地将父类方法标记为final，阻止子类覆盖。
public class Parent {
public final void show() {
// ...
}
}
public class Child extends Parent {
@Override
public void show() { // 错误：无法覆盖 final 方法
// ...
}
}正确做法：如果需要子类覆盖方法，不要将方法标记为final。
public class Parent {
public void show() {
// ...
}
}
public class Child extends Parent {
@Override
public void show() {
// ...
}
}九.抽象类和接口
1.抽象类定义方法
// 抽象类：被abstract修饰的类
public abstract class Shape {
// 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}2.接口的定义
3.可能会出现的问题
1. 错误地实现接口或继承抽象类
错误写法：
public class MyClass implements MyInterface {
// 实现接口的方法
}如果MyInterface是一个接口，那么MyClass必须实现接口中定义的所有方法。
正确写法：
public interface MyInterface {
void myMethod();
}
public class MyClass implements MyInterface {
@Override
public void myMethod() {
// 实现方法
}
}2. 在抽象类中实现接口方法
错误写法：
public abstract class MyAbstractClass implements MyInterface {
// 尝试实现接口的方法
}抽象类不能直接实现接口的方法。
正确写法：
public interface MyInterface {
void myMethod();
}
public abstract class MyAbstractClass implements MyInterface {
@Override
public abstract void myMethod();
}在抽象类中，接口的方法应该被声明为抽象的。
3. 在抽象类中使用final关键字
错误写法：
public abstract final class MyAbstractClass {
// ...
}final关键字意味着类不能被继承，这与抽象类的目的相矛盾。
正确写法：
public abstract class MyAbstractClass {
// ...
}4. 尝试实例化抽象类
错误写法：
public abstract class MyAbstractClass {
// ...
}
MyAbstractClass myObject = new MyAbstractClass();抽象类不能被实例化。
正确写法：
public abstract class MyAbstractClass {
// ...
}
public class MyConcreteClass extends MyAbstractClass {
// ...
}
MyConcreteClass myObject = new MyConcreteClass();5. 在接口中实现方法
错误写法（Java 8之前）：
public interface MyInterface {
void myMethod() {
// 实现方法
}
}在Java 8之前，接口中不能有方法的实现。
正确写法（Java 8之前）：
public interface MyInterface {
void myMethod();
}
public class MyConcreteClass implements MyInterface {
@Override
public void myMethod() {
// 实现方法
}
}正确写法（Java 8及之后）：
public interface MyInterface {
void myMethod();
default void defaultMethod() {
// 默认方法实现
}
}从Java 8开始，接口可以包含默认方法和静态方法。
6. 错误地使用接口作为数据类型
错误写法：
MyInterface myInterface = new MyInterface();接口不能被实例化。
正确写法：
MyInterface myInterface = new MyConcreteClass();接口应该被用作引用类型，指向实现了接口的具体类的对象。
7. 混淆抽象类和接口的使用场景
错误写法：
public abstract class MyAbstractClass {
public void myMethod() {
// ...
}
}
public class MyConcreteClass implements MyAbstractClass {
// ...
}类不能实现抽象类。
正确写法：
public abstract class MyAbstractClass {
public abstract void myMethod();
}
public class MyConcreteClass extends MyAbstractClass {
@Override
public void myMethod() {
// ...
}
}应该使用继承来实现抽象类。
十.认识String类
1.String对象是不可变的，一旦创建就不能被修改。
String str = "Hello";
String newStr = str + " World";这里并不是修改了str对象，而是创建了一个新的String对象newStr。在处理大量字符串拼接时，使用StringBuilder或StringBuffer会更高效，因为String的拼接会产生大量临时对象。
- 查找
- 使用
indexOf方法查找子串在字符串中的位置，例如查找子串 "world" 在 "hello world" 中的位置：int index = "hello world".indexOf("world");
- 使用
- 转化
- 这里假设将字符串转化为字节数组，使用
getBytes方法：byte[] bytes = "hello".getBytes();
- 这里假设将字符串转化为字节数组，使用
- 替换
- 使用
replace方法将字符串中的某个子串替换为另一个子串，例如将 "hello" 中的 "l" 替换为 "x"：String newStr = "hello".replace("l", "x");
- 使用
- 拆分
- 使用
split方法按照指定的分隔符拆分字符串，例如按照空格拆分 "hello world"：String[] parts = "hello world".split(" ");
- 使用
- 截取
- 使用
substring方法截取字符串的一部分，例如截取 "hello world" 从第 6 个字符开始的子串：String subStr = "hello world".substring(6);
- 使用
- 去空格
- 使用
trim方法去除字符串两端的空白字符：String trimmedStr = " hello ".trim();
- 使用
- 转大写
- 使用
toUpperCase方法将字符串转换为大写形式：String upperCaseStr = "hello".toUpperCase();
- 使用
- 转小写
- 使用
toLowerCase方法将字符串转换为小写形式：String lowerCaseStr = "HELLO".toLowerCase();
- 使用
2.可能出现的错误
1. 未初始化变量
错误示例：
int number;
System.out.println(number);错误原因： 变量在使用前必须初始化。
正确写法：
int number = 0;
System.out.println(number);2. 错误的数据类型使用
错误示例：
int myNumber = "123"; // 错误：尝试将字符串赋值给整型变量错误原因： 赋值的数据类型与变量类型不匹配。
正确写法：
int myNumber = 123;3. 字符串拼接错误
错误示例：
String name = "Kimi" + 123; // 错误：不能直接将整数与字符串拼接错误原因： 字符串与其他数据类型进行拼接时需要进行类型转换。
正确写法：
String name = "Kimi" + 123; // 正确：Java会自动将整数转换为字符串4. 数组越界
错误示例：
int[] numbers = new int[5];
System.out.println(numbers[5]); // 错误：索引越界错误原因： 数组索引超出了数组的有效范围。
正确写法：
int[] numbers = new int[5];
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}十一.认识异常
1.通过try-catch-finally语句块和throw/throws关键字
public void readFile(String filePath) {
try {
// 读取文件代码
System.out.println("File read successfully.");
} catch (FileNotFoundException e) {
System.err.println("File not found: " + e.getMessage());
} catch (IOException e) {
System.err.println("IO error: " + e.getMessage());
} finally {
// 清理资源代码
System.out.println("Cleaning up resources.");
}
}
// 抛出异常示例
public void checkAge(int age) throws IllegalArgumentException {
if (age < 0) {
throw new IllegalArgumentException("Age cannot be negative.");
}
}2.可能会出现的错误
1. 未处理的异常
错误示例：
try {
int result = 10 / 0;
} catch (Exception e) {
e.printStackTrace();
}错误原因： 除数为零会导致ArithmeticException，但未进行异常处理。
正确写法：
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
e.printStackTrace();
}2. 错误的逻辑控制
错误示例：
if (i = 10) { // 错误：使用了赋值运算符而不是比较运算符
// code block
}错误原因： 应该使用比较运算符==而不是赋值运算符=。
正确写法：
if (i == 10) {
// code block
}3. 错误的类和对象使用
错误示例：
MyClass myObject = new MyClass();
myObject.method(); // 错误：如果方法为private，则无法从外部访问错误原因： 尝试访问私有方法。
正确写法：
public class MyClass {
public void method() {
// code block
}
}
MyClass myObject = new MyClass();
myObject.method();4. 错误的继承使用
错误示例：
public class Dog extends Animal {
public void makeSound() {
System.out.println("Bark");
}
}
public class Cat extends Dog {
public void makeSound() {
System.out.println("Meow");
}
}
public class Main {
public static void main(String[] args) {
Animal myAnimal = new Cat(); // 错误：尝试实例化抽象类
myAnimal.makeSound(); // 错误：多态调用时，调用的是Cat的makeSound方法
}
}错误原因： 尝试实例化抽象类，以及多态调用时方法覆盖的问题。
正确写法：
public class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Bark");
}
}
public class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Meow");
}
}
public class Main {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.makeSound(); // 输出：Bark
Cat myCat = new Cat();
myCat.makeSound(); // 输出：Meow
}
}5. 错误的接口实现
错误示例：
public interface Runable {
void run();
}
public class Car implements Runable {
public void run() {
// code block
}
}
public class Main {
public static void main(String[] args) {
Runable myCar = new Car();
myCar.run(); // 错误：Car类没有正确实现接口中的run方法
}
}错误原因： 接口中的方法是public和abstract的，需要在实现类中正确实现。
正确写法：
public interface Runable {
void run();
}
public class Car implements Runable {
@Override
public void run() {
// code block
}
}
public class Main {
public static void main(String[] args) {
Runable myCar = new Car();
myCar.run();
}
}6. 错误的异常处理
错误示例：
try {
int result = 10 / 0;
} catch (Exception e) {
System.out.println("An error occurred"); // 错误：捕获了所有异常，但没有指明具体异常类型
}错误原因： 捕获了所有异常，但没有指明具体异常类型。
正确写法
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Arithmetic error occurred");
}总结
经过几个月的学习和实践，终于完成了 JavaSE 的基本课程。在这个过程中，我学会了 Java 的基本概念，如变量、数据类型、运算符等，以及如何使用这些概念来编写程序。同时，我也学到了如何使用 Java 的特性如继承、多态、异常处理等来实现代码重用和扩展。
希望本文能够帮助初学者入门 JavaSE，开始自己的学习之旅！
扫一扫
383
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
