Java 面向对象核心知识详解

java 是一门面向对象的编程语言，面向对象编程（OOP）思想是 Java 编程的核心。下面我们就来深入探讨 Java 面向对象的关键内容。

一、面向对象基础

面向对象编程以 “对象” 为核心，将现实世界中的事物抽象为程序中的对象，对象包含数据（属性）和操作数据的行为（方法）。在 Java 中，通过类来定义对象的模板，然后基于类创建对象（实例）。例如，我们要表示 “汽车” 这个事物，会定义一个 Car 类，包含汽车的属性（如颜色、品牌、速度等）和方法（如启动、加速、刹车等），然后创建具体的 Car 对象。

二、三大特性：封装、继承、多态

（一）封装

封装是指将对象的属性和方法隐藏在类的内部，仅对外提供有限的访问接口。通过封装，可以保护数据的安全性，防止外部直接修改对象的内部状态，同时也能简化外部对对象的使用。在 Java 中，实现封装主要通过访问修饰符（private、default、protected、public）来控制类、属性和方法的访问权限。通常将属性设置为 private（私有），然后提供 public（公共）的 getter 和 setter 方法来访问和修改属性。例如：

public class Person {
    // 私有属性，外部无法直接访问
    private String name;
    private int age;
    // 公共的 getter 方法，用于获取 name 属性
    public String getName() {
        return name;
    }
    // 公共的 setter 方法，用于设置 name 属性
    public void setName(String name) {
        this.name = name;
    }
    // 公共的 getter 方法，用于获取 age 属性
    public int getAge() {
        return age;
    }
    // 公共的 setter 方法，用于设置 age 属性，同时可以添加逻辑（如年龄验证）
    public void setAge(int age) {
        if (age >= 0 && age <= 120) {
            this.age = age;
        } else {
            System.out.println("年龄不合法！");
        }
    }
}

（二）继承

继承是指一个类（子类）可以继承另一个类（父类）的属性和方法，子类还可以在父类的基础上进行扩展，添加新的属性和方法，或者重写父类的方法。继承实现了代码的复用，让类之间形成层次结构。Java 中使用 extends 关键字实现继承，且是单继承（一个类只能直接继承一个父类），但可以通过接口实现多继承的效果。例如：

// 父类
public class Animal {
    protected String name;
    public void eat() {
        System.out.println(name + " 在吃东西");
    }
}
// 子类，继承 Animal 类
public class Dog extends Animal {
    // 子类添加自己的属性
    private String breed;
    // 子类重写父类的 eat 方法
    @Override
    public void eat() {
        System.out.println(name + "（品种：" + breed + "）在吃骨头");
    }
    // 子类添加自己的方法
    public void bark() {
        System.out.println(name + " 在汪汪叫");
    }
}

（三）多态

多态是指同一个行为具有多种不同的表现形式。在 Java 中，多态的实现主要依赖于继承、方法重写和父类引用指向子类对象。多态使得程序更加灵活，提高了代码的可扩展性。例如，我们有一个父类 Shape（形状），子类 Circle（圆形）和 Rectangle（矩形）都继承自 Shape，并且重写了 Shape 中的 draw（绘制）方法：

public class Shape {
    public void draw() {
        System.out.println("绘制形状");
    }
}
public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}
public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}
// 测试多态
public class Test {
    public static void main(String[] args) {
        // 父类引用指向子类对象，体现多态
        Shape shape1 = new Circle();
        Shape shape2 = new Rectangle();
        shape1.draw(); // 输出：绘制圆形
        shape2.draw(); // 输出：绘制矩形
    }
}

三、内部类

内部类是定义在另一个类内部的类。内部类可以访问外部类的所有成员（包括私有成员），根据定义的位置和方式不同，内部类分为成员内部类、局部内部类、匿名内部类和静态内部类。

（一）匿名内部类

匿名内部类是一种特殊的局部内部类，它没有类名，通常用于创建只需要使用一次的类的实例，经常和接口或抽象类配合使用。例如，我们有一个接口 MyInterface：

public interface MyInterface {
    void doSomething();
}
// 使用匿名内部类实现接口
public class Test {
    public static void main(String[] args) {
        MyInterface obj = new MyInterface() {
            @Override
            public void doSomething() {
                System.out.println("执行 doSomething 方法");
            }
        };
        obj.doSomething(); // 输出：执行 doSomething 方法
    }
}

匿名内部类在事件监听、线程创建等场景中非常常用，比如创建一个线程：

new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("线程执行中...");
    }
}).start();

四、抽象类

抽象类是使用 abstract 关键字修饰的类，抽象类不能被实例化，只能被继承。抽象类中可以包含抽象方法（使用 abstract 修饰，只有方法声明，没有方法体）和普通方法。子类继承抽象类后，必须重写抽象类中的所有抽象方法（除非子类也是抽象类）。抽象类用于定义一些通用的模板，让子类去实现具体的细节。例如：

public abstract class Animal {
    protected String name;
    // 抽象方法，子类必须重写
    public abstract void makeSound();
    // 普通方法
    public void eat() {
        System.out.println(name + " 在吃东西");
    }
}
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println(name + " 喵喵叫");
    }
}

五、接口

接口是一种完全抽象的类型，使用 interface 关键字定义。接口中只能包含常量（默认 public static final）和抽象方法（Java 8 之前），Java 8 及以后允许在接口中定义默认方法（default 修饰）和静态方法（static 修饰），Java 9 及以后还允许定义私有方法。类可以通过 implements 关键字实现一个或多个接口，实现接口的类必须重写接口中的所有抽象方法（除非类是抽象类）。接口用于定义类的行为规范，实现了类的多继承能力。例如：

public interface Flyable {
    void fly();
    // 默认方法
    default void land() {
        System.out.println("降落");
    }
}
public interface Swimmable {
    void swim();
}
// 类实现多个接口
public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("鸭子飞翔");
    }
    @Override
    public void swim() {
        System.out.println("鸭子游泳");
    }
}

六、父子类之间转换

（一）向上转型

向上转型是指将子类对象赋值给父类引用，这是自动进行的。向上转型后，只能调用父类中定义的方法和属性，子类特有的方法和属性无法直接调用。向上转型体现了多态的思想。例如前面提到的 Shape 类和 Circle 类的例子，Shape shape = new Circle(); 就是向上转型。

（二）向下转型

向下转型是指将父类引用转换为子类引用，需要使用强制类型转换。向下转型之前，通常需要使用 instanceof 关键字判断父类引用指向的对象是否是目标子类的实例，否则可能会发生 ClassCastException（类型转换异常）。例如：

Shape shape = new Circle();
if (shape instanceof Circle) {
    // 向下转型
    Circle circle = (Circle)shape;
    circle.draw(); // 可以调用 Circle 类特有的方法（如果有的话）
}

七、Object 基类

Object 类是 Java 中所有类的根类，每个类都直接或间接继承自 Object 类。Object 类中定义了一些通用的方法，如 equals()（用于比较对象是否相等）、hashCode()（返回对象的哈希码）、toString()（返回对象的字符串表示）、getClass()（获取对象的类信息）、clone()（用于对象的克隆）、finalize()（在对象被垃圾回收前调用）、wait()、notify()、notifyAll()（用于线程同步）等。子类可以根据需要重写这些方法，以实现特定的功能。例如，重写 toString() 方法：

public class Person {
    private String name;
    private int age;
    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
    // 其他代码...
}

Java 面向对象的这些知识是 Java 编程的核心基石，掌握好它们，能让我们更好地进行 Java 应用开发，编写出结构清晰、可维护性高的代码。