JAVASE总结

目录

一.初始JAVA

1.一个简单的Hello World程序

2.注释

1.单行注释

2.多行注释

3.文档注释

二.数据类型与变量

1.数据类型

2.变量

三.运算符

四.程序逻辑控制

1.语句

2.可能会出现的错误

1.在学习循环语句时，我有时会忘记更新循环变量，导致出现死循环的情况；

2.i未++；

3.i<3 j++；

4.i<边界不符合；

五.方法的使用

1.方法可以接受参数并返回结果

2.如果多个方法的名字相同，参数列表不同 == 重载

3.可能出现的错误

1.在实际应用中，我曾因方法参数传递不当导致数据丢失。

2.例如，在传递对象作为参数时，我错误地认为传递的是对象的副本而不是引用；

3.传入参数未用合适的类型接收；

4.接收的个数和传入的个数不匹配；

5.接收的参数之间未用','进行隔开；

6.容易造成方法重载，不会使用导致参数胡乱调用，不知道走那一个调用方法；

7.递归的是要经常混乱，还是建议借助图来解决；（下面是斐波那契数列递归图）

六.数组的定义与使用

1.定义数组：

2.遍历数组

3.可能出现的错误

1. 未初始化数组

2. 错误地访问数组长度

3. 越界访问

4. 将数组作为参数传递

5. 错误地修改数组大小

6. 混淆数组和ArrayList

7. 多维数组的错误使用

七.类和对象

1.类定义格式

2.类的实例化

3.this使用

4.对象的初始化

5.可能会出现的错误

八.继承和多态

1.继承的语法

2.this子类，super子类调用父类的方法和参数

3.多态是同一个行为的不同表现方式

4.可能出现的错误

1. 错误使用继承

2. 覆盖方法时使用错误的访问修饰符

3. 覆盖equals方法时未考虑继承

4. 错误地使用多态

5. 未正确实现接口

6. 错误地使用抽象类

7. 错误地使用final关键字

九.抽象类和接口

1.抽象类定义方法

2.接口的定义

3.可能会出现的问题

1. 错误地实现接口或继承抽象类

2. 在抽象类中实现接口方法

3. 在抽象类中使用final关键字

4. 尝试实例化抽象类

5. 在接口中实现方法

6. 错误地使用接口作为数据类型

7. 混淆抽象类和接口的使用场景

十.认识String类

1.String对象是不可变的，一旦创建就不能被修改。

2.可能出现的错误

1. 未初始化变量

2. 错误的数据类型使用

3. 字符串拼接错误

4. 数组越界

十一.认识异常

1.通过try-catch-finally语句块和throw/throws关键字

2.可能会出现的错误

 1. 未处理的异常

2. 错误的逻辑控制

3. 错误的类和对象使用

4. 错误的继承使用

5. 错误的接口实现

6. 错误的异常处理

总结

作为一个初学者，开始学习 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); // 输出：8

2.如果多个方法的名字相同，参数列表不同 == 重载

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.可能会出现的错误

1. 类名和文件名不匹配： 在Java中，公共类的名称必须与文件名完全匹配。如果类名和文件名不一致，会导致编译错误。

   // 错误示例
   public class MyClass {
       // ...
   }
   // 文件名应该是MyClass.java

2. 构造函数使用错误： 构造函数的名称必须与类名完全相同，并且不能有返回类型。

   // 错误示例
   public int MyClass() {
       // ...
   }
   // 正确示例
   public MyClass() {
       // ...
   }

3. 成员变量和局部变量混淆： 初学者可能会错误地将局部变量当作成员变量使用，或者反之。

   // 错误示例
   public class MyClass {
       int myField;
       
       public void myMethod() {
       int myField = 10; // 错误：局部变量名称与成员变量名称相同
       }
   }

4. 访问修饰符使用不当： 初学者可能会混淆public、private和protected访问修饰符的使用。

   // 错误示例
   public class MyClass {
       public int myField; // 正确：可以被任何其他类访问
       
       private int myPrivateField; // 错误：不应该在类外部访问
       public void myMethod() {
           System.out.println(myPrivateField);
       }
   }

5. 对象创建和使用错误： 初学者可能会忘记创建对象实例，或者错误地使用对象。

   // 错误示例
   MyClass myObject; // 错误：没有使用new关键字创建对象
   myObject.myMethod(); // 错误：myObject是null，不能调用方法
   // 正确示例
   MyClass myObject = new MyClass();
   myObject.myMethod();

6. 方法重载和重写混淆： 初学者可能会混淆方法重载（Overloading）和方法重写（Overriding）的概念。

   // 错误示例
   public class MyClass {
       public void myMethod() {
           // ...
       }
       
       public void myMethod(int param) { // 错误：这不是重写，这是重载
           // ...
       }
   }

7. this关键字使用不当： this关键字用于引用当前对象的成员变量或方法，初学者可能会错误地使用它。

   // 错误示例
   public class MyClass {
       int myField;
       
       public void myMethod() {
           int myField = this.myField; // 错误：不需要使用this
       }
   }

8. 静态成员和实例成员混淆： 初学者可能会错误地将静态方法或静态变量与实例变量混淆。

   // 错误示例
   public class MyClass {
       static int myStaticField;
       
       public void myMethod() {
           myStaticField = 10; // 错误：静态变量应该通过类名访问
       }
   }

9. 错误地覆盖finalize方法： 初学者可能会错误地覆盖finalize方法，而没有调用super.finalize()。

   // 错误示例
   public class MyClass {
       @Override
       protected void finalize() throws Throwable {
           // ...
       }
       // 正确示例：调用super.finalize()
       @Override
       protected void finalize() throws Throwable {
           super.finalize();
           // ...
       }
   }

10. 对象比较错误： 初学者可能会错误地使用==来比较两个对象的内容。

    // 错误示例
    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的拼接会产生大量临时对象。

1. 查找
   • 使用indexOf方法查找子串在字符串中的位置，例如查找子串 "world" 在 "hello world" 中的位置：int index = "hello world".indexOf("world");
2. 转化
   • 这里假设将字符串转化为字节数组，使用getBytes方法：byte[] bytes = "hello".getBytes();
3. 替换
   • 使用replace方法将字符串中的某个子串替换为另一个子串，例如将 "hello" 中的 "l" 替换为 "x"：String newStr = "hello".replace("l", "x");
4. 拆分
   • 使用split方法按照指定的分隔符拆分字符串，例如按照空格拆分 "hello world"：String[] parts = "hello world".split(" ");
5. 截取
   • 使用substring方法截取字符串的一部分，例如截取 "hello world" 从第 6 个字符开始的子串：String subStr = "hello world".substring(6);
6. 去空格
   • 使用trim方法去除字符串两端的空白字符：String trimmedStr = " hello ".trim();
7. 转大写
   • 使用toUpperCase方法将字符串转换为大写形式：String upperCaseStr = "hello".toUpperCase();
8. 转小写
   • 使用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，开始自己的学习之旅！