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进阶------注解一文全懂 → |

相关推荐
Owen_Q11 分钟前
Denso Create Programming Contest 2025（AtCoder Beginner Contest 413）
开发语言·算法·职场和发展
hqxstudying20 分钟前
java依赖注入方法
java·spring·log4j·ioc·依赖
·云扬·28 分钟前
【Java源码阅读系列37】深度解读Java BufferedReader 源码
java·开发语言
liulilittle1 小时前
C++ i386/AMD64平台汇编指令对齐长度获取实现
c语言·开发语言·汇编·c++
Bug退退退1232 小时前
RabbitMQ 高级特性之重试机制
java·分布式·spring·rabbitmq
小皮侠2 小时前
nginx的使用
java·运维·服务器·前端·git·nginx·github
Thomas_YXQ2 小时前
Unity URP法线贴图实现教程
开发语言·unity·性能优化·游戏引擎·unity3d·贴图·单一职责原则
Zz_waiting.2 小时前
Javaweb - 10.4 ServletConfig 和 ServletContext
java·开发语言·前端·servlet·servletconfig·servletcontext·域对象
全栈凯哥2 小时前
02.SpringBoot常用Utils工具类详解
java·spring boot·后端
兮动人2 小时前
获取终端外网IP地址
java·网络·网络协议·tcp/ip·获取终端外网ip地址
热门推荐
01集群聊天服务器---MySQL数据库的建立02GPU 进阶笔记（二）：华为昇腾 910B GPU03Coze扣子平台完整体验和实践（附国内和国际版对比）04使用Ruby接入实时行情API教程05Word粘贴时出现“运行时错误53,文件未找到：MathPage.WLL“的解决方案06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07基于odoo17的设计模式详解---装饰模式08扣子空间的使用教程与大模型技术思考09DeepSeek各版本说明与优缺点分析10Everything文件检索工具 几秒检索几百G的文件