第4章：面向对象程序设计（进阶）

4.1 封装

  • 定义：封装是面向对象编程的一个重要特性，它隐藏了对象的实现细节，并通过公共方法提供对这些细节的访问控制。

  • 实现方式：

  • 使用private修饰符限制字段的直接访问。
  • 提供公共的getter和setter方法来间接访问和修改私有字段。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Person {
    private String name;
    private int age;
 
    // Getter and Setter methods
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

　　

4.2 继承

  • 定义：继承允许一个类从另一个类派生，从而复用代码并建立层次化的类型关系。

  • 关键字：使用extends关键字来表示一个类继承自另一个类。

  • 方法重写（Override）：

    • 子类可以重新定义父类中已有的方法以改变其行为。
    • 使用@Override注解确保正确地覆盖了父类方法。

  • 构造器调用：在子类构造器中使用super()调用父类构造器。

  • ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    示例：
    public class Student extends Person {
        private String studentId;
     
        public Student(String name, int age, String studentId) {
            super(name, age); // 调用父类构造器
            this.studentId = studentId;
        }
     
        @Override
        public void sayHello() {
            System.out.println("Hello, I'm a student named " + getName());
        }
    }

    4.3 super 关键字

    • 用途：super关键字用于引用当前对象的直接父类。
      • 可以用来调用父类的方法或访问父类的属性。
    • 场景：
    • 在子类构造器中调用父类构造器。
    • 在子类方法中调用父类同名方法。
    • ?
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      public class Animal {
          public void makeSound() {
              System.out.println("Animal makes a sound.");
          }
      }
       
      public class Dog extends Animal {
          @Override
          public void makeSound() {
              super.makeSound(); // 调用父类方法
              System.out.println("Dog barks.");
          }
      }

      4.4 final 关键字用途

      　

      final关键字可以用于修饰类、方法和变量，分别表示不可继承、不可重写和不可再赋值。

    • 类：防止其他类继承该类。
    • 方法：防止子类重写该方法。
    • 变量：声明常量，一旦赋值就不能更改。

    　　

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    public final class Constants {
        public static final double PI = 3.14159;
    }
     
    public class Circle {
        private final double radius;
     
        public Circle(double radius) {
            this.radius = radius; // 最后一次赋值
        }
     
        public final double calculateArea() {
            return Constants.PI * radius * radius;
        }
    }

    4.5 Object 类
    Object是所有类的根类，每个类都隐式或显式地继承自Object。
    常用方法：toString()：返回对象的字符串表示形式。

    equals(Object obj)：判断两个对象是否相等。

    hashCode()：返回对象的哈希码值。

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    public class Person {
        private String name;
     
        @Override
        public String toString() {
            return "Person{name='" + name + "'}";
        }
     
        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (obj == null || getClass() != obj.getClass()) return false;
            Person person = (Person) obj;
            return Objects.equals(name, person.name);
        }
    }

    　　

  • 4.6 多态

    • 定义：

      • 多态意味着不同的对象可以通过统一的接口调用相同名称的方法，在不同的上下文中表现出不同的行为。

    • 实现形式：

      • 编译时多态（静态绑定/早期绑定）：通过方法重载（Overloading）实现。
      • 运行时多态（动态绑定/晚期绑定）：通过方法重写（Overriding）实现。
      • ?
        1
        2
        Animal animal = new Dog();
        animal.makeSound(); // 实际上调用的是Dog类中的makeSound方法

        　　

      • 4.7 抽象类
      • 抽象类不能被实例化，通常用于定义其他类的共同基础。
      • 可以包含抽象方法（没有具体实现的方法）和具体方法。

      • 特点：

        • 使用abstract关键字声明。
        • 子类必须实现所有的抽象方法，除非子类也是抽象类。
        • ?
          1
          2
          3
          4
          5
          6
          7
          8
          9
          10
          11
          12
          13
          14
          public abstract class Animal {
              public abstract void makeSound();
           
              public void breathe() {
                  System.out.println("Breathing...");
              }
          }
           
          public class Cat extends Animal {
              @Override
              public void makeSound() {
                  System.out.println("Meow!");
              }
          }

          　　

      • 4.8 接口

        • 定义：

          • 接口是一组方法签名的集合，定义了类必须实现的行为。
          • 所有方法默认为public和abstract，所有字段默认为public static final。

        • 特点：

          • 使用interface关键字声明。
          • 一个类可以实现多个接口，使用implements关键字。
          • Java 8及以后版本允许接口中定义默认方法和静态方法。
          • ?
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            public abstract class Animal {
                public abstract void makeSound();
             
                public void breathe() {
                    System.out.println("Breathing...");
                }
            }
             
            public class Cat extends Animal {
                @Override
                public void makeSound() {
                    System.out.println("Meow!");
                }
            }

            　　

        • 4.9 内部类概述

          • 定义：

            • 内部类是定义在一个类内部的类，它可以访问外部类的所有成员。

          • 类型：

            • 成员内部类：作为外部类的一个成员存在。
            • 局部内部类：定义在方法或作用域内。
            • 匿名内部类：没有名字的一次性使用的类。
            • 静态内部类：使用static修饰，不依赖于外部类的实例。

          • 优势：

            • 提高代码组织的灵活性。
            • 内部类可以捕获外部类的状态，便于实现回调机制。

          • 示例：

          •  

            ?
            1
            2
            3
            4
            5
            6
            7
            8
            9
            10
            11
            12
            13
            14
            public class OuterClass {
                private String outerField = "Outer";
             
                public class InnerClass {
                    public void print() {
                        System.out.println(outerField); // 访问外部类的字段
                    }
                }
            }
             
            // 使用内部类
            OuterClass outer = new OuterClass();
            OuterClass.InnerClass inner = outer.new InnerClass();
            inner.print();<br><br><br><br><br>　　
            学习心得

            封装是面向对象编程的一个核心概念，它通过隐藏对象的实现细节并提供公共接口来增强代码的安全性和灵活性。理解了封装后，能够更好地设计类结构，保护数据不被外部直接访问，同时提供了对内部状态的受控访问。

             

            遇到的难点及解决方法
            • 难点：如何在不影响现有功能的情况下修改类的内部实现。
            • 解决方法：通过遵循开闭原则（Open/Closed Principle），即对扩展开放、对修改关闭，可以使用继承或组合来添加新功能而不改变原有代码。此外，编写单元测试确保修改不会破坏现有功能。
posted @   乘风破浪的小落夜  阅读(22)  评论(0)  编辑  收藏  举报
相关博文：
· 第3章：面向对象程序设计
· 第1章和第二2章
· java笔记4
· 14. 面向对象的特性
· 面向对象（二）
阅读排行：
· 无需6万激活码！GitHub神秘组织3小时极速复刻Manus，手把手教你使用OpenManus搭建本
· C#/.NET/.NET Core优秀项目和框架2025年2月简报
· 葡萄城 AI 搜索升级：DeepSeek 加持，客户体验更智能
· 什么是nginx的强缓存和协商缓存
· 一文读懂知识蒸馏
点击右上角即可分享
微信分享提示