java基础知识点详细（部分）

小厂永远得不到的男人
159 阅读6分钟

Java 基础语法详解

Java 是一种广泛应用于企业级开发的面向对象编程语言，以其强大的功能、良好的安全性和优秀的跨平台能力而著称。本文将深入探讨 Java 中几个关键的基础语法知识点，包括 == 与 equals 的区别、异常处理机制、自定义异常类以及类的定义与使用等。

== 与 equals 的区别

  • ==：这个运算符用于比较两个变量在内存中的地址，即它们是否指向同一个对象。这是一种底层的指针级别的比较。
  • equals：这个方法用于比较两个对象的内容是否相等。所有 Java 类都继承自 java.lang.Object 类，因此默认的 equals 方法实际上执行的是 == 比较。为了根据实际需求比较对象的内容，通常需要重写 equals 方法。

Java 类的定义与使用

  • 构造方法：每个类至少有一个构造方法。如果没有显式定义，编译器会提供一个无参的默认构造方法。构造方法用于初始化对象的状态。

  • 访问控制：Java 提供了四种访问级别：

    • public：可以在任何地方访问。
    • protected：在同一包内或不同包的子类中访问。
    • default（包私有）：仅在同一包内访问。
    • private：仅在本类中访问。

继承

继承 是面向对象编程的一个核心概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，可以实现代码的复用，减少重复代码，提高开发效率。

  • extends 关键字：子类通过 extends 关键字继承父类。例如：

    java
浅色版本
class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("The dog barks.");
    }
}

    在这个例子中，Dog 类继承了 Animal 类的 eat 方法，并添加了自己的 bark 方法。

  • 方法重写：子类可以重写父类的方法，以提供不同的实现。重写方法时，子类方法的名称、返回类型和参数列表必须与父类方法相同。例如：

    java
浅色版本
class Animal {
    void makeSound() {
        System.out.println("Some generic sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof woof!");
    }
}

  • 构造方法：子类的构造方法可以调用父类的构造方法，使用 super 关键字。例如：

    java
浅色版本
class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);  // 调用父类的构造方法
    }
}

  • Java 不支持多重继承：一个类只能继承一个父类，但可以通过实现多个接口来达到类似的效果。

多态

多态 是面向对象编程的另一个重要特性，它允许子类对象被当作父类对象处理。多态增加了程序的灵活性和可扩展性，使得代码更加通用和可维护。

  • 向上转型：将子类对象赋值给父类引用，称为向上转型。例如：

    java
浅色版本
Animal myDog = new Dog();
myDog.makeSound();  // 输出 "Woof woof!"

    在这个例子中，myDog 是一个 Animal 类型的引用，但它实际上指向的是一个 Dog 对象。调用 makeSound 方法时，会调用 Dog 类中重写的方法。

  • 向下转型：将父类引用转换为子类对象，称为向下转型。例如：

    java
浅色版本
Animal myAnimal = new Dog();
Dog myDog = (Dog) myAnimal;
myDog.bark();  // 输出 "The dog barks."

    下转型需要显式地进行类型转换，并且要确保引用的实际对象是目标类型的实例，否则会抛出 ClassCastException。

封装

封装 是面向对象编程的基本原则之一，它通过访问控制符限制对类成员的直接访问，增强类的安全性和简化类的使用。

  • 访问控制符：

    • public：可以在任何地方访问。
    • protected：在同一包内或不同包的子类中访问。
    • default（包私有）：仅在同一包内访问。
    • private：仅在本类中访问。

    例如：

    java
浅色版本
class Person {
    private String name;  // 私有属性
    private int age;      // 私有属性

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

    在这个例子中，name 和 age 属性是私有的，外部无法直接访问。通过提供公共的 getter 和 setter 方法，可以控制对这些属性的访问和修改。

抽象

抽象 是面向对象编程中的一个重要概念，用于定义规范。抽象类和接口是实现抽象的主要手段。

  • 抽象类：

    • 定义：抽象类使用 abstract 关键字定义，不能被实例化，但可以被声明。
    • 抽象方法：抽象方法只有方法头，没有方法体，必须在子类中实现。
    • 非抽象方法：抽象类可以包含非抽象方法，提供部分实现。
    • 抽象属性：抽象类可以包含属性、构造方法和非抽象方法。

    例如：

    java
浅色版本
abstract class Animal {
    abstract void makeSound();

    void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof woof!");
    }
}

  • 接口：

    • 定义：接口使用 interface 关键字定义，所有方法都是抽象的（Java 8 之后可以有默认方法和静态方法）。
    • 实现：类通过 implements 关键字实现接口，必须实现接口中的所有抽象方法。
    • 多实现：一个类可以实现多个接口，从而实现多继承的效果。

    例如：

    java
浅色版本
interface Animal {
    void makeSound();
}

interface Swimmer {
    void swim();
}

class Duck implements Animal, Swimmer {
    @Override
    public void makeSound() {
        System.out.println("Quack quack!");
    }

    @Override
    public void swim() {
        System.out.println("The duck swims.");
    }
}

何时使用抽象类或接口？

选择使用抽象类还是接口取决于具体的设计需求：

  • 抽象类：

    • 当你需要提供部分实现时，使用抽象类。
    • 当你希望子类共享一些通用的实现时，使用抽象类。

  • 接口：

    • 当你关注一个操作或行为时，使用接口。
    • 当你需要实现多继承的效果时，使用接口。

Java 异常处理

Java 的异常处理机制是确保程序稳定运行的重要手段。主要包括以下两个关键字：

  • throws：用于声明一个方法可能抛出的异常。这样可以让调用者知道可能发生的异常，并采取相应的措施。多个异常可以用逗号分隔。
  • throw：用于在方法内部抛出一个异常对象。throw 通常与 try-catch 结构或 throws 关键字结合使用，以确保异常能够被正确处理或传递给上层调用者。
自定义异常类

自定义异常类可以通过继承 Exception 或其子类来实现。例如，可以创建两个异常类 MyException1 和 MyException2，分别用于处理数值过小和过大的情况：

java
浅色版本
class MyException1 extends Exception {
    double num;
    MyException1(double a) {  num = a; }
    @Override
    public String toString() { return num + "<0! 值必须大于0"; }
}

class MyException2 extends Exception {
    double num;
    MyException2(double a) { num = a; }
    @Override
    public String toString() { return num + ">100! 值必须小于100"; }
}

然后，在一个方法中使用这些自定义异常：

java
浅色版本
public class Test {
    static void checkScore(double a) throws MyException1, MyException2 {
        if (a < 0) throw new MyException1(a);
        if (a > 100) throw new MyException2(a);
        System.out.println("数据符合要求");
    }
}

总结

本文详细介绍了 Java 编程中的一些基础但重要的概念，包括 == 和 equals 的区别、类的定义与使用、异常处理机制、自定义异常类等。理解这些基础知识对于编写健壮、高效、易于维护的代码至关重要。希望本文能帮助初学者更好地掌握 Java 编程的核心技巧。

avatar
文章
阅读
粉丝