大象席地而坐

01 面向对象

11分钟阅读

面向对象的基础为类和对象，面向对象的特点有封装、继承、多态和抽象。

类和对象

核心要点

定义

java是一门面向对象语言，class 是 java 的基础单位。class 内包含了属性、方法、类名、包等信息的定义。class 文件被称为类，而对象就是对类的实例化。

概念

类：类是模板，是对现实中一类事物公共行为或状态的抽象定义，如现实中对生物的区分为人、狗、猫等就是对一类生物的抽象命名。同理 java 中可以对人进行单独定义为一个类 Person 来表示。 对象： 对象是对类的具体实例，有行为及状态。如对 Pserson 实例化为 zhangSan。 属性：对于某个人来说，有自己的状态如身高、体重、名称，而属性就是对类实例化后会存在的状态进行的定义。 方法：方法是对类模板的行为进行的定义，如人吃饭、喝水等行为可以定义为一个方法。 包：在java中，同一个文件夹下只能有一个名称相同的类文件，而包就是体现类文件的具体路径。

变量/属性

局部变量：在方法、构造方法、代码块中定义的变量是局部变量，随着代码块执行结束自行销毁，且不可被方法外的代码调用。 成员变量：在类中，方法体之外的变量称为成员变量，成员变量可以被类中方法、构造方法访问到。 类变量：存在类中，方法体之外，被static修饰。

代码示例

/*  
 * @author zd * @date 2025/8/3 * @apiNote 面向对象  
 */
 public class DemoPerson {  
  
    //属性  
    private String name;  
    private int age;  
    private String sex;  
  
    public DemoPerson(String name, int age, String sex) {  
        this.name = name;  
        this.age = age;  
        this.sex = sex;  
    }  
  
    public void show() {  
        System.out.println("姓名：" + name + "，年龄：" + age + "，性别：" + sex);  
    }  
  
    public static void main(String[] args) {  
        DemoPerson person = new DemoPerson("张三", 18, "男");  
        person.show();  
    }  
}

注意

  1. 一个类文件可以存在多个类，但有且仅有一个类的命名与文件名称相同，且必须用public修饰，其余类不可用public修饰；
  2. 类在定义时会默认一个空参的构造方法，构造方法可以进行重写，可以同时存在多个；
  3. 类的初始化至少需要调用一个构造方法。

继承

继承是面向对象的核心之一，核心意义为将一个类(子类)基于另一个类(父类)进行构建。

核心要点

  1. 代码复用，子类继承了父类中所有的 非private 属性和方法；
/*  
 * @author zd 
 * @date 2025/8/5 
 * @apiNote 继承-父类  
 */
 public class DemoParent {  
      
    private String name;  
    public int age;  
    public void eat(){  
        System.out.println("吃饭");  
    }  
      
    private void sleep(){  
        System.out.println("睡觉");  
    }  
}
 
/*  
 * @author zd 
 * @date 2025/8/5 
 * @apiNote 面向对象-继承  
 */
 public class DemoInheritance extends DemoParent {  
    public static void main(String[] args) {  
        DemoInheritance demoInheritance = new DemoInheritance();  
        demoInheritance.eat();  
        demoInheritance.age = 18;  
    }  
}
  1. 可拓展性：子类继承父类后，依然可以新增方法和属性，也可以对父类方法进行重写；
/*  
 * @author zd 
 * @date 2025/8/5 
 * @apiNote 面向对象-继承  
 */
 public class DemoInheritance extends DemoParent {  
    public static void main(String[] args) {  
        DemoInheritance demoInheritance = new DemoInheritance();  
        demoInheritance.eat();  
        demoInheritance.age = 18;  
    }  
      
    @Override  
    public void eat() {  
        System.out.println("inheritance eat");  
    }  
}
  1. 层次关系：继承主要用于表达“is a” 的关系，强调子类属于父类对象的范畴。
  2. 调用父类对象：super 关键字可以调用访问父类方法。

注意

  1. 单继承：一个 Java 子类只能继承于一个父类；
  2. 继承非私有属性： 子类继承父类所有非 private 修饰的方法及属性；
  3. 构造方法不被继承：构造方法属于每个类独有的方法，方法名称与类名一致，所以无法继承，但可以通过 super 关键字方法父类所有方法；
  4. 所有类都隐式继承Object类：若未显式继承其他类，则默认继承 java.lang.Object（如 toString()方法）。

封装

隐藏了对象内部实现逻辑，只对外暴露访问及调用的接口，提高代码安全性、可维护性和灵活性。

核心要点

  1. 隐藏数据: 将对象的属性设为 private ，防止外部直接访问或修改；
  2. 提供公共方案：通过 public 的 getter、setter方法来控制访问。

示例

/*
 * @author zd
 * @date 2025/8/8
 * @apiNote 面向对象-封装
 */
public class DemoPackage {
    
    private String name;
    private int age;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        if (name == null){
            System.out.println("name is null");
            return;
        }
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
}

多态

同一个方法或接口在不同的对象上表现出不同行为，提高了代码灵活性和可拓展性。

核心要点

通过 类继承、接口实现 的方式实现 同一个方法不同体现形式。当一个父类/接口定义方法后，其不同子类/实现类中对方法进行重写，重写后的方法可以有不同的行为。

示例

多态区分为两种：

  1. 运行时多态(动态多态) → 方案重写+向上转型：子类重写父类的方法，并通过向上转型(父类引用指向子类对象) 调用。
/*
 * @author zd
 * @date 2025/8/8
 * @apiNote 面向对象-多态接口
 */
public interface DemoPolymorphicService {
 
    void doSomething();
}
 
/*
 * @author zd
 * @date 2025/8/8
 * @apiNote 面向对象-多态实现类
 */
public class DemoPolymorphicServiceImpl implements DemoPolymorphicService {
    @Override
    public void doSomething() {
        System.out.println("多态实现类----测试1");
    }
}
 
/*
 * @author zd
 * @date 2025/8/8
 * @apiNote 面向对象-多态实现类
 */
public class DemoPolymorphicServiceImpl2 implements DemoPolymorphicService {
    @Override
    public void doSomething() {
        System.out.println("多态实现类2----测试2");
    }
}
 
/*
 * @author zd
 * @date 2025/8/8
 * @apiNote
 */
public class DemoPolymorphic {
    public static void main(String[] args) {
 
        DemoPolymorphicService demoPolymorphicService = new DemoPolymorphicServiceImpl();
        demoPolymorphicService.doSomething();
        //多态实现类----测试1
 
        demoPolymorphicService = new DemoPolymorphicServiceImpl2();
        demoPolymorphicService.doSomething();
        //多态实现类2----测试2
    }
}
  1. 编译时多态(静态多态) → 方法重写 ：在同一个类中，方法名相同，参数列表不同
public class DemoPolymorphic {
    public static void main(String[] args) {
        DemoPolymorphic demoPolymorphic = new DemoPolymorphic();
        demoPolymorphic.test1();
        demoPolymorphic.test1(11);
    }
 
    public  void test1() {
        System.out.println("空参数");
    }
 
    public  void test1(int a) {
        System.out.println("参数为"+a);
    }
}

抽象

隐藏复杂实现，只暴露必要借口。

核心要点

  • 定义规范，不关心实现，不关心如何实现，只关注能做什么；
  • 实现方式
    • 抽象类
    • 接口

实现方式

抽象类

特点：

  • 用abstract 关键字修饰的类；
  • 可以包含抽象方法(没有方法体)和具体方法；
  • 不能直接实例化，必须由子类继承并实现抽象方案。

使用场景： 多个相关类共享部分方法，且部分方案需单独实现。

代码示例：

/*
 * @author zd
 * @date 2025/8/8
 * @apiNote 抽象类
*/
public abstract class DemoAbstract {
 
    //自定义方法
    public abstract void customizable();
 
    //通用方法
    public void commonMethod(){
        System.out.println("这是抽象类中的通用方法");
    }
}
 
/*
 * @author zd
 * @date 2025/8/8
 * @apiNote 抽象类继承
 */
public class DemoAbstractChild extends DemoAbstract {
    @Override
    public void customizable() {
        System.out.println("抽象类继承自定义方法");
    }
 
    public static void main(String[] args) {
        DemoAbstract demoAbstract = new DemoAbstractChild();
        demoAbstract.commonMethod();//这是抽象类中的通用方法
        demoAbstract.customizable();//抽象类继承自定义方法
    }
}

接口

特点：

  • 用interface 关键字修饰；
  • 所有方法默认是 public abstract（Java 8+ 支持默认方法 default）；
  • 不能包含成员变量（除非是 public static final 常量）；
  • 类通过 implements 实现接口，必须实现所有抽象方法（除非是抽象类）。

使用场景： 只需要定义行为，不需要在意方法实现的场景。

总结

抽象类与接口的区别

特性抽象类（Abstract Class）接口（Interface）
关键字abstract classinterface
方法可包含抽象方法和具体方法Java 8 前只能有抽象方法，后支持 default/static 方法
变量可包含普通成员变量只能有 public static final 常量
继承/实现单继承（一个子类只能继承一个父类）多实现（一个类可实现多个接口）
构造方法有无
设计目的代码复用（共享部分逻辑）定义行为规范（契约）

关系图谱