Java-第三章-面向对象（下）

Note

继面向对象基础（类、对象、封装）后，本章深入学习面向对象核心特性：继承、多态、抽象类、接口、Object类、内部类，是Java进阶必备知识点！

面向对象编程（OOP）的核心思想是将现实世界中的事物抽象为程序中的 “对象”，通过封装、继承、多态三大特性实现代码复用与程序扩展。本节我们重点讲解面向对象进阶核心：继承、final关键字、抽象类和接口、多态、Object类、内部类。

继承#

1. 核心概念#

继承：让一个类（子类/派生类）复用另一个类（父类/基类）的属性和方法，是代码复用的核心机制。
关键字：extends
特点：Java 只支持单继承，一个子类只能有一个直接父类。
子类可以重写父类方法，也可以新增自己的成员。

2. 语法规则#

1
// 父类
2
public class 父类名 {
3
    // 父类属性和方法
4
}
5

6
// 子类继承父类
7
public class 子类名 extends 父类名 {
8
    // 子类新增属性和方法
9
}

示例

1
// 父类：Person
2
class Person {
3
    String name;
4
    int age;
5

6
    public void eat() {
7
        System.out.println("人在吃饭");
8
    }
9
}
10

11
// 子类：Student 继承 Person
12
class Student extends Person {
13
    String studentId; // 子类独有属性
14

15
    public void study() { // 子类独有方法
16
        System.out.println(name + "正在学习");
17
    }
18
}
19

20
public class Test {
21
    public static void main(String[] args) {
22
        Student s = new Student();
23
        s.name = "小明"; // 继承父类属性
24
        s.age = 18;
25
        s.eat(); // 继承父类方法
26
        s.study(); // 调用子类独有方法
27
    }
28
}

运行效果

1
人在吃饭
2
小明正在学习

final关键字#

1. 核心概念#

final 表示最终、不可改变，可修饰类、方法、变量。
修饰类：该类不能被继承。
修饰方法：该方法不能被重写。
修饰变量：该变量变为常量，只能赋值一次。

2. 语法规则#

1
// final 修饰类：不能被继承
2
final class 类名 {}
3

4
// final 修饰方法：不能被重写
5
public final 返回值类型 方法名() {}
6

7
// final 修饰变量：常量
8
final 数据类型 变量名 = 值;

示例

1
// final 类：无法被继承
2
final class Animal {
3
    // final 方法：无法被重写
4
    public final void run() {
5
        System.out.println("动物在跑");
6
    }
7
}
8

9
// class Dog extends Animal {} 报错：不能继承final类
10

11
public class Test {
12
    public static void main(String[] args) {
13
        // final 变量：常量，不可修改
14
        final int NUM = 10;
15
        // NUM = 20; 报错
16
        System.out.println(NUM);
17
    }
18
}

运行效果

1
10

抽象类和接口#

1. 抽象类#

用 abstract 修饰，包含抽象方法（无方法体），不能实例化。
子类必须重写所有抽象方法。

1
abstract class 抽象类名 {
2
    // 抽象方法
3
    public abstract void 方法名();
4
}

2. 接口#

特殊抽象类，全局常量 + 公共抽象方法。
关键字：interface、implements。
一个类可实现多个接口。

1
// 定义接口
2
interface 接口名 {
3
    void 方法名();
4
}
5

6
// 实现接口
7
class 类名 implements 接口名 {
8
    @Override
9
    public void 方法名() {}
10
}

示例

1
// 抽象类
2
abstract class Shape {
3
    public abstract double getArea();
4
}
5

6
// 接口
7
interface Color {
8
    void setColor();
9
}
10

11
// 子类继承抽象类 + 实现接口
12
class Circle extends Shape implements Color {
13
    @Override
14
    public double getArea() {
15
        return 3.14 * 2 * 2;
16
    }
17

18
    @Override
19
    public void setColor() {
20
        System.out.println("红色圆形");
21
    }
22
}
23

24
public class Test {
25
    public static void main(String[] args) {
26
        Circle c = new Circle();
27
        c.setColor();
28
        System.out.println("面积：" + c.getArea());
29
    }
30
}

运行效果

1
红色圆形
2
面积：12.56

多态#

1. 核心概念#

多态：同一行为，不同子类有不同实现。
前提：继承/实现、方法重写、父类引用指向子类对象。
好处：提高代码扩展性。

2. 语法规则#

1
父类类型 引用名 = new 子类对象();
2
接口名 引用名 = new 实现类对象();

示例

1
class Animal {
2
    public void shout() {
3
        System.out.println("动物叫");
4
    }
5
}
6

7
class Cat extends Animal {
8
    @Override
9
    public void shout() {
10
        System.out.println("喵喵喵");
11
    }
12
}
13

14
class Dog extends Animal {
15
    @Override
16
    public void shout() {
17
        System.out.println("汪汪汪");
18
    }
19
}
20

21
public class Test {
22
    public static void main(String[] args) {
23
        // 多态：父类引用指向子类对象
24
        Animal a1 = new Cat();
25
        Animal a2 = new Dog();
26
        a1.shout();
27
        a2.shout();
28
    }
29
}

运行效果

1
喵喵喵
2
汪汪汪

Object类#

1. 核心概念#

Object 是Java所有类的顶级父类，任何类默认继承它。
常用方法：
- toString()：返回对象字符串表示。
- equals()：比较对象内容。
- hashCode()：返回哈希值。

2. 语法规则#

1
// 所有类都默认继承 Object
2
public class 类名 {}

示例

1
class Student {
2
    String name;
3

4
    // 重写 toString
5
    @Override
6
    public String toString() {
7
        return "Student{name=" + name + "}";
8
    }
9
}
10

11
public class Test {
12
    public static void main(String[] args) {
13
        Student s = new Student();
14
        s.name = "小红";
15
        System.out.println(s); // 自动调用 toString
16
    }
17
}

运行效果

1
Student{name=小红}

内部类#

1. 核心概念#

内部类：定义在类内部的类。
分类：成员内部类、静态内部类、局部内部类、匿名内部类。
作用：访问外部类私有成员，代码封装。

2. 语法规则#

1
class 外部类 {
2
    // 成员内部类
3
    class 内部类 {}
4

5
    // 静态内部类
6
    static class 静态内部类 {}
7
}

示例

1
class Outer {
2
    private int num = 10;
3

4
    // 成员内部类
5
    class Inner {
6
        public void show() {
7
            // 直接访问外部类私有变量
8
            System.out.println("内部类访问：" + num);
9
        }
10
    }
11
}
12

13
public class Test {
14
    public static void main(String[] args) {
15
        Outer.Inner inner = new Outer().new Inner();
16
        inner.show();
17
    }
18
}

运行效果

1
内部类访问：10

总结#

继承：extends，代码复用，单继承。
final：不可改变，修饰类、方法、变量。
抽象类&接口：规范定义，接口可多实现。
多态：父类引用指向子类，提高扩展性。
Object：所有类的父类，提供通用方法。
内部类：类中定义类，可访问外部私有成员。

音乐

Pigeons2023

音乐

Java-第三章-面向对象（下）

继承#

1. 核心概念#

2. 语法规则#

final关键字#

1. 核心概念#

2. 语法规则#

抽象类和接口#

1. 抽象类#

2. 接口#

多态#

1. 核心概念#

2. 语法规则#

Object类#

1. 核心概念#

2. 语法规则#

内部类#

1. 核心概念#

2. 语法规则#

总结#

支持与分享

评论区

音乐

目录