Java进阶——面向对象编程

就改了2025-03-05 17:43

本篇文章，将深入探讨 Java 面向对象编程的关键知识点，并用一些例子展示这些概念的实际工作开发中的应用。

本文目录

    • [一、 三大特性](#一、 三大特性)
      • [1. 封装](#1. 封装)
      • [2. 继承](#2. 继承)
      • [3. 多态](#3. 多态)
    • [二、 类与对象](#二、 类与对象)
      • [1. 对象创建](#1. 对象创建)
      • [2. 构造方法](#2. 构造方法)
      • [3. 静态成员](#3. 静态成员)
    • [三、 访问控制修饰符](#三、 访问控制修饰符)
    • 四、方法相关
      • [1. 方法签名](#1. 方法签名)
      • [2. final 关键字](#2. final 关键字)
      • [3. 可变参数](#3. 可变参数)
    • 五、对象生命周期
    • [六、 高级特性](#六、 高级特性)
      • [1. 接口和抽象类](#1. 接口和抽象类)
      • [2. 内部类](#2. 内部类)
      • [3. 枚举类](#3. 枚举类)
    • [七、 对象关系](#七、 对象关系)
      • [1. 组合](#1. 组合)
      • [2. 聚合](#2. 聚合)
    • 总结

一、 三大特性

1. 封装

封装是指隐藏对象的内部细节，通过 private 关键字控制对对象属性的访问，并提供 public 的 getter/setter 方法来实现对属性的安全访问和修改。

java 复制代码 
public class User {
    private String password;

    public void setPassword(String input) {
        if (isValidPassword(input)) {
            this.password = encrypt(input);
        }
    }

    private boolean isValidPassword(String input) {
        // 密码验证逻辑
        return input.length() >= 6;
    }

    private String encrypt(String input) {
        // 加密逻辑
        return "encrypted_" + input;
    }
}

getter/setter里面可以做一些简单的逻辑

2. 继承

Java 中的继承通过 extends 关键字实现，一个类只能继承一个父类。子类可以重写父类的方法，通过 @Override 注解显式声明。

java 复制代码 
// 父类
class Animal {
    public void sound() {
        System.out.println("sound");
    }
}

// 子类
class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("barks");
    }
}


public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog(); 
        animal.sound();             
    }
}

3. 多态

多态分为编译时多态和运行时多态。编译时多态通过方法重载实现，运行时多态通过父类引用指向子类对象实现。

java 复制代码 
// 方法重载
class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

// 运行时多态
class Animal {
    public void sound() {
        System.out.println("sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();  
        animal.sound();             
    }
}

二、 类与对象

1. 对象创建

使用 new 关键字触发构造方法调用，对象内存分配在堆中，引用变量存储在栈中。

java 复制代码 
class Person {
    String name;

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

public class Main {
    public static void main(String[] args) {
        Person person = new Person("John");
        System.out.println(person.name);
    }
}

2. 构造方法

构造方法与类同名，无返回类型，可以重载多个构造器。默认构造器在类未定义任何构造器时自动生成。

java 复制代码 
class Car {
    private String brand;

    // 默认构造器
    public Car() {
        this.brand = "Unknown";
    }

    // 带参数的构造器
    public Car(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }
}

public class Main {
    public static void main(String[] args) {
        Car car1 = new Car();
        Car car2 = new Car("Toyota");
        System.out.println(car1.getBrand());
        System.out.println(car2.getBrand());
    }
}

3. 静态成员

static 修饰的属性和方法属于类级别，通过类名直接访问。静态方法不能访问非静态成员（无 this 上下文）。

java 复制代码 
class MathUtils {
    public static final double PI = 3.14159;

    public static double circleArea(double radius) {
        return PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        double area = MathUtils.circleArea(5);
        System.out.println(area);
    }
}

三、 访问控制修饰符

Java 提供了四种访问控制修饰符：private、默认、protected 和 public。

修饰符 类内部 同包 子类 其他包
private ✔ ✘ ✘ ✘
默认 ✔ ✔ ✘ ✘
protected ✔ ✔ ✔ ✘
public ✔ ✔ ✔ ✔

四、方法相关

1. 方法签名

方法签名由方法名 + 参数列表组成（返回类型和异常不属于签名）。

2. final 关键字

final 可以修饰类（不可继承）、方法（不可重写）、变量（常量）。

java 复制代码 
final class FinalClass {
    // final 方法
    public final void finalMethod() {
        System.out.println("Final method");
    }
}

public class Main {
    public static void main(String[] args) {
        final int MAX_VALUE = 100;
        // MAX_VALUE = 200; // 编译错误，final 变量不可修改
    }
}

3. 可变参数

java 复制代码 
public class Main {
    public void printItems(String... items) {
        for (String item : items) {
            System.out.println(item);
        }
    }

    public static void main(String[] args) {
        Main main = new Main();
        main.printItems("1", "2", "3");
    }
}

五、对象生命周期

对象的生命周期包括创建、使用和销毁三个阶段。对象由 new 关键字实例化，使用引用操作对象，最后由垃圾回收器自动回收无引用对象。

六、 高级特性

1. 接口和抽象类

特性 接口 抽象类
实现方式 implements extends
方法实现 Java 8+ 支持默认方法 可包含具体方法
成员变量 默认 public static final 无限制
多继承 支持多接口继承 单继承

2. 内部类

Java 中有四种内部类：成员内部类、静态内部类、局部内部类和匿名内部类。

java 复制代码 
// 成员内部类
class OuterClass {
    private int outerField;

    class InnerClass {
        public void accessOuterField() {
            System.out.println(outerField);
        }
    }
}

// 静态内部类
class OuterClass2 {
    private static int staticOuterField;

    static class StaticInnerClass {
        public void accessStaticOuterField() {
            System.out.println(staticOuterField);
        }
    }
}

// 局部内部类
class OuterClass3 {
    public void outerMethod() {
        final int localVariable = 10;
        class LocalInnerClass {
            public void accessLocalVariable() {
                System.out.println(localVariable);
            }
        }
        LocalInnerClass inner = new LocalInnerClass();
        inner.accessLocalVariable();
    }
}

// 匿名内部类
class Main {
    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println("Task running");
            }
        };
        new Thread(task).start();
    }
}

3. 枚举类

使用 enum 关键字定义枚举类，自动继承 java.lang.Enum。

java 复制代码 
public enum OrderStatus {
    PENDING("待处理"), PAID("已支付");
    private String desc;
    OrderStatus(String desc) { this.desc = desc; }

    public String getDesc() {
        return desc;
    }
}

public class Main {
    public static void main(String[] args) {
        OrderStatus status = OrderStatus.PENDING;
        System.out.println(status.getDesc());
    }
}

七、 对象关系

1. 组合

组合是一种强关联关系，整体与部分的生命周期一致。

java 复制代码 
class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

class Car {
    private Engine engine = new Engine();

    public void startCar() {
        engine.start();
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.startCar();
    }
}

2. 聚合

聚合是一种弱关联关系，整体与部分可以独立存在。

java 复制代码 
class Student {
    private String name;

    public Student(String name) {
        this.name = name;
    }
}

class Classroom {
    private List<Student> students;

    public Classroom(List<Student> students) {
        this.students = students;
    }
}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("Alice");
        Student student2 = new Student("Bob");
        List<Student> students = List.of(student1, student2);
        Classroom classroom = new Classroom(students);
    }
}

总结

面向对象编程的核心在于理解类与对象的关系。

|----------------------------------------------------------------------------------------------------------|--------------------|-------------------------------------------------------------------------------------------------|
| ← 上一篇 Java进阶------Stream流以及常用方法详解 | 记得点赞、关注、收藏哦！ | 下一篇 Java进阶------注解一文全懂 → |

相关推荐
~Yogi4 分钟前
每日学习Java之一万个为什么？（Maven篇+RPC起步+CICD起步）（待完善）
java·学习·maven
银之夏雪17 分钟前
ESLint 深度解析：原理、规则与插件开发实践
java·前端·javascript
重生之成了二本看我逆天改命走向巅峰30 分钟前
从0搭建Tomcat第二天：深入理解Servlet容器与反射机制
java·开发语言·笔记·学习·servlet·tomcat·idea
rkmhr_sef32 分钟前
Java进阶：Dubbo
java·开发语言·dubbo
数维学长98634 分钟前
【2025rust笔记】超详细，小白，rust基本语法
开发语言·笔记·rust
不止会JS37 分钟前
cursor使用经验分享（java后端服务开发向）
java·开发语言·经验分享·cursor
徐白117737 分钟前
Rust WebAssembly 入门教程
开发语言·rust·wasm
码熔burning41 分钟前
(二 十 三)趣学设计模式 之 解释器模式！
java·设计模式·解释器模式
三水气象台41 分钟前
对ArrayList中存储的TreeNode的排序回顾
java·数据结构·算法·huffman tree
solomonzw1 小时前
C++ 学习(八)(模板,可变参数模板,模板专业化(完整模板专业化,部分模板专业化),类型 Traits,SFINAE（替换失败不是错误）,)
c语言·开发语言·c++·学习
热门推荐
01DeepSeek各版本说明与优缺点分析02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03如何在WPS和Word/Excel中直接使用DeepSeek功能04Windows 11 安装 Dify 完整指南 非docker环境05DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具06DeepSeek本地部署详细指南07WPF 复杂页面布局及漂亮 UI 界面设计全解析08本地部署DeepSeek教程（Mac版本）09在Windows下安装Ollama并体验DeepSeek r1大模型10如何本地部署AI智能体平台，带你手搓一个AI Agent