【第三章-2】面向对象——三大特性-CSDN博客

本文详细介绍了Java中的构造方法、封装的特性（包括封装的概念和访问控制）、继承的机制（包括语法、重写和重载）、以及多态性的两种形式（编译时多态和运行时多态）。通过实例展示了这些面向对象编程的核心概念及其应用。

摘要由CSDN通过智能技术生成

3.4.方法的重写（Overriding）

1.构造方法

1.1 概念

构造方法是在面向对象编程中用于创建对象并初始化对象属性的特殊方法。
在Java语言中，构造方法的名称与类名相同，不需要返回值，也不需要使用`void`关键字修饰。
每个类都有构造方法，如果没有显式定义构造方法，Java会为该类提供一个默认构造方法。
构造方法的主要作用是为创建的对象赋予合理的初始数值

1.2 构造方法代码演示

// 1.定义一个类
class Person {
    String name;
    int age;
}

// 2.构造方法，用于初始化对象的属性
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

// 3.区别：普通方法，用于打印对象的属性值
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

public static void main(String[] args) {
        //4. 创建一个 Person 对象并调用构造方法进行初始化
        Person person1 = new Person("Alice", 25);
        
        // 5.调用普通方法显示对象的属性值
        person1.displayInfo();
    }
}

1.3 构造方法与普通方法的区别

1.名称不同：构造方法的名称必须与类名相同，而普通方法的名称可以自定义.
2.调用方式：构造方法会在创建对象时自动调用，而普通方法需要通过对象来显式调用.
3.返回值：构造方法没有返回值类型，而普通方法需要指定返回值类型.
4.执行目的：构造方法用于创建新对象，而普通方法则用于执行特定功能并返回结果
小结：构造方法在对象创建时自动执行，没有返回值类型，且名称与类名相同，主要目的是初始化对象，而普通方法需要显式调用，有返回值类型，名称可以自定义，用于执行特定功能

2.面向对象的特性——封装

2.1 什么是封装？

假设你有一个安全箱，里面存放着一些贵重物品。为了保护这些物品不被随意触碰或损坏，你将安全箱外部加上了一层加密锁。其他人无法直接打开安全箱，只能通过特定的方式（密码、钥匙等）来打开。这样，你可以控制谁能够访问和操作安全箱内的物品，从而保障其安全。

2..2 Java中封装哪些内容？

1.属性（Fields）：在Java中，我们可以使用private关键字将类的属性（字段）封装起来，使其只能在类的内部访问。这样可以防止外部直接访问和修改类的属性，通过提供公有的getter和setter方法来控制属性的访问和修改。
2.方法（Methods）：类中的方法也可以被封装，我们可以将一些方法设置为private，限制其只能在类的内部调用。这样可以隐藏一些实现细节，提高类的封装性。
3.构造方法（Constructors）：构造方法也可以被封装。通过使用private修饰构造方法，可以限制外部类直接实例化该类，只能通过类内部的静态方法或工厂方法来创建对象。
4.内部类（Inner Classes）：在Java中，我们可以在一个类的内部定义另一个类，这就是内部类。内部类可以访问外部类的私有属性和方法，但外部类无法直接访问内部类的成员，从而实现了一定程度的封装。
5.包（Packages）：Java中的包（Packages）也是一种封装机制，用于将相关的类和接口组织在一起。通过包的访问控制符（public、protected、private、默认）可以控制类的可见性，实现对类的封装。

Java中的封装机制主要是通过访问修饰符（private、protected、public、默认）来限制对类的访问，从而保护类的内部实现细节，提高类的封装性和安全性。

2.3 返场知识点——访问控制

public：被 public 修饰的类、接口、字段和方法可以被任何其他类访问。
private：被 private 修饰的字段和方法只能在定义它们的类内部访问。
protected：被 protected 修饰的字段和方法只能在同一个包内或者子类中访问。
默认访问修饰符：如果没有指定访问修饰符，则使用默认访问修饰符，只允许同一个包内的类访问。

2.4 简单尝试

任务：
在一个类TestClass中定义两个变量visible、invisible；
其中visible是public的，invisible是private的；
定义另一个类AnotherCLass，然后在这个类中的main方法中，创建TestClass类对象，尝试调用该类对象的两个成员变量；
通过以上，感受public和private访问修饰符对成员变量的访问权限

2.5 访问控制的作用

封装：通过对类的成员使用 private 访问修饰符，可以隐藏类的内部实现细节，提供外部访问接口，从而提高代码的可维护性和安全性。
保护数据：通过限制对字段的直接访问，可以保护数据不被恶意修改或篡改。
控制访问权限：访问控制修饰符可以控制类的成员对外部的可见性，使得只有需要访问的类或方法能够进行操作，提高代码的安全性和可读性。

访问控制——代码示例

public class MyClass {
    private int privateField;
    public int publicField;
    protected int protectedField;
    int defaultField; // 默认访问修饰符
}

1.定义了一个类： MyClass
2.类里面有四个成员变量： privateField、 publicField、
protectedField、 defaultField
3.这四个变量的修饰符不一样

在上述示例中，通过使用不同的访问修饰符对字段和方法进行修饰，可以控制它们的可访问性。
外部类只能访问 publicField 和 publicMethod()，而不能直接访问其他字段和方法。
这样就实现了对类成员的访问控制。

2.6 封装:setter与getter

在Java中，setter和getter通常被称为"setter方法"和"getter方法"，或者简称为"set方法"和"get方法"。
这些方法用于设置（修改）和获取对象的属性值。
通常情况下，setter方法用于设置对象的属性值，而getter方法用于获取对象的属性值。
这些方法遵循一定的命名约定，通常以"set"和"get"作为前缀，后面跟着属性的名称，首字母大写。

//Setter方法示例：
public void setName(String name) {
    this.name = name;
}


//Getter方法示例
public String getName() {
    return this.name;
}

this 在Java中表示当前对象的引用，可以用来引用当前对象的成员变量、成员方法，以及调用当前对象的构造方法。
简单来说，this 就是指代当前对象本身。

在上面的示例中：

setName方法是一个setter方法，用于设置name属性的值；getName方法是一个getter方法，用于获取name属性的值。

这种命名约定有助于提高代码的可读性和可维护性

3.面向对象的特性——继承

3.1 理解继承

想象一棵家谱树，爷爷奶奶是树的根，他们有很多孩子，这些孩子又各自生了自己的孩子，孙子孙女们。如果我们说孙子孙女继承了爷爷奶奶的血脉和遗传基因，那么这种关系就好比是继承。孙子孙女们可以继承爷爷奶奶的一些特征和能力，但也可以在这基础上添加自己独特的特征。

3.2 继承的语法

在程序中，如果想声明一个类继承另一个类，需要使用extends关键字，语法格式如下所示。

class 父类{

……

}

class 子类 extends 父类{

……

}

3.3 继承——代码示例

// 父类
class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

// 子类继承父类
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

// 在Main类中的main()中实现
public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat(); // 继承自父类Animal的eat方法
        dog.bark(); // 子类Dog独有的bark方法
    }

在上述代码中，Animal 类是父类，Dog 类是子类，Dog 类继承了 Animal 类。子类 Dog 可以继承（拥有）父类 Animal 中的 eat 方法，同时还可以在自己内部定义独有的 bark 方法。通过继承，子类可以获得父类的属性和方法，同时可以添加自己的特有属性和方法。

3.4.方法的重写（Overriding）

1. 方法重写指的是子类重新定义（覆盖）了父类中的方法，子类中的方法具有相同的名称和参数列表。

2. 方法重写的主要特点是子类中的方法与父类中的方法具有相同的方法签名（方法名和参数列表）。

3. 在运行时，根据对象的实际类型来确定调用哪个方法，即动态绑定（运行时多态）。

4. 方法重写用于实现子类对父类方法的定制化需求，提供了面向对象编程的多态性特性。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

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

3.5.方法重载

方法重载（Overloading）：

•方法重载指的是在同一个类中，可以定义多个方法具有相同的名称但参数列表不同的情况。

•方法重载的主要特点是方法名相同，但参数列表不同（参数个数、类型或顺序不同）。

•编译器根据方法的参数列表来区分不同的重载方法，并在调用时根据传入的参数类型或个数来选择调用哪个重载方法。

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

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

3.6.方法重写与方法重载

总结：

•方法重载是在同一类中定义多个方法，而方法重写是子类重写父类的方法。

•方法重载是静态多态，编译时确定调用哪个方法；方法重写是动态多态，运行时确定调用哪个方法。

4. 面向对象的特性——多态

在Java中，多态性（Polymorphism）是面向对象编程中的一个重要概念，它允许不同类的对象对同一个消息作出响应，这些类可以共享一个父类或接口，并且可以具有不同的行为。

多态性有两种形式：编译时多态（静态多态）和运行时多态（动态多态）。

4.1 多态——代码示例

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

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

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

定义了父类：Animal

定义了两个子类：Dog 、

子类都重写了方法：makeSound()

@Override 注解：可以明确地表明 makeSound 方法是重写的父类中的方法，这样有助于代码的可读性和可维护性。

4.2 编译时多态——代码示例

编译时多态（静态多态）：在编译时期，编译器会根据引用变量的类型来决定调用哪个方法。这种多态性主要体现在方法的重载（Overloading）上，即相同方法名，不同参数列表的方法可以根据传递的参数类型来执行相应的操作。编译时多态（静态多态）：在编译时期，编译器会根据引用变量的类型来决定调用哪个方法。这种多态性主要体现在方法的重载（Overloading）上，即相同方法名，不同参数列表的方法可以根据传递的参数类型来执行相应的操作。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound(); // 编译时选择Animal类中的makeSound方法
    }
}

在上述代码中，虽然 animal 对象实际上是 Dog 类的实例，但是编译时会选择 Animal 类中的 makeSound 方法进行调用。

4.3 运行时多态

运行时多态（动态多态）：在程序运行时，根据对象的实际类型来确定调用哪个方法。这种多态性主要体现在方法的重写（Overriding）上，即子类可以重写父类的方法，从而实现不同类对象对同一消息作出不同响应的特性。

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog is barking");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.makeSound(); // 运行时选择Dog类中的makeSound方法
    }
}

运行时多态是指在程序运行时根据对象的实际类型确定调用的方法。当一个父类引用指向子类对象，并且调用的方法被子类重写时，运行时会根据对象的实际类型来确定调用的是子类的方法。