Java基础--面向对象编程-优快云博客

本文链接：https://blog.youkuaiyun.com/shouxifeiwu/article/details/147470201

面向对象编程是一种以对象为核心的编程范式，其核心在于对象和类的概念。面向对象编程及其三大特性，即封装、继承、多态，是掌握现代编程技术的基础。

一、面向对象编程的本质

1. 基本概念

对象：具有属性和方法的实体
类：创建对象的模板
消息传递：对象之间通过方法调用来进行交互

2. 面向对象编程的核心思想

抽象：提取关键特征，忽略非本质细节
模块化：将系统分解为高内聚、低耦合的单元
层次化：通过继承建立类型层次结构

3.面向对象编程与面向过程编程

特性	面向对象编程	面向过程编程
基本单元	对象	函数
数据访问	通过方法控制	通常直接访问
扩展方式	继承/多态	函数组合
典型语言	Java/C#/Python	C/Pascal

二、封装

1. 封装的多维理解

1.隐藏数据：保护对象内部状态

2.行为绑定：将数据与操作数据的方法结合

3.接口契约：定义清晰的访问边界

2. 实现模式

public class test {
    private Integer id;//核心数据私有化
    public Integer get (){//受控制的获取方法
        return id;
    }
    public void set (Integer id){//受控制的修改方法
       this.id=id;
    }
    public void print(){//受控制的其他方法
        System.out.println(id);
    }
}

3. 封装的高级应用

1.不变类：所有字段final，无修改方法

2.建造者模式：封装复杂对象的构造过程

3.代理模式：控制对原始对象的访问

三、继承深度解析

1. 继承的多层次理解

1.语法继承：extends关键字

2.类型继承：子类"is-a"父类关系

3.实现继承：代码复用机制

2. 继承体系设计原则

// 继承层次示例
abstract class Animal {
    protected String species;
    
    public Animal(String species) {
        this.species = species;
    }
    
    // 抽象方法定义契约
    public abstract void makeSound();
    
    // 模板方法封装通用算法
    public final void dailyRoutine() {
        wakeUp();
        eat();
        makeSound();
        sleep();
    }
    
    protected void wakeUp() { /* 实现 */ }
    protected void eat() { /* 实现 */ }
    protected void sleep() { /* 实现 */ }
}

class Dog extends Animal {
    public Dog() { super("Canine"); }
    
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
    
    // 子类特有方法
    public void fetch() { /* 实现 */ }
}

class Cat extends Animal {
    public Cat() { super("Feline"); }
    
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
    
    // 重写父类方法扩展行为
    @Override
    protected void eat() {
        super.eat();
        purr();
    }
    
    private void purr() { /* 实现 */ }
}

3. 继承的替代方案

1.组合(Composition)：通过包含其他类对象实现功能复用

2.委托(Delegation)：将操作转发给其他对象

3.接口(Interface)：定义契约而不提供实现

四、多态深度解析

1. 多态的表现形式

类型	机制	绑定时机	示例
编译时多态	方法重载	编译时	`print(String)` vs `print(int)`
运行时多态	方法重写	运行时	`Animal a = new Dog(); a.makeSound()`
参数多态	泛型	编译时	`List<String>`
强制多态	类型转换	运行时	`(String)obj`

2. 运行时多态实现机制

interface Payment {
    void pay(double amount);
}

class CreditCard implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("信用卡支付：" + amount);
    }
}

class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付：" + amount);
    }
}

class PaymentProcessor {
    // 多态方法：参数类型是接口
    public void processPayment(Payment payment, double amount) {
        payment.pay(amount);  // 动态绑定具体实现
    }
}

// 使用
PaymentProcessor processor = new PaymentProcessor();
processor.processPayment(new CreditCard(), 100.0);
processor.processPayment(new Alipay(), 200.0);

3. 多态的高级应用

1.策略模式：运行时选择算法

2.观察者模式：处理多种事件类型

3.访问者模式：对复杂对象结构进行操作

五、三大特性的协同与平衡

1. 特性关系矩阵

特性组合	应用场景	示例
封装+继承	框架设计	父类封装通用逻辑，子类扩展功能
封装+多态	组件开发	隐藏实现细节，暴露接口
继承+多态	算法家族	抽象类定义算法骨架，子类实现具体步骤