Java面向对象基础：封装、继承、多态

原创已于 2023-01-10 16:32:16 修改 · 287 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java

于 2023-01-02 22:43:49 首次发布

本文详细探讨了Java中的面向对象编程，主要涵盖封装、继承和多态这三个核心概念。封装是通过隐藏数据和提供公共方法来保护对象的实现细节；继承允许子类复用父类的状态和行为，增强了代码的复用性和维护性；多态则提供了运行时的灵活性，使得代码可以处理多种对象形态。文章还讨论了super和this关键字的用途，以及方法重写和多态的实现机制，并给出了具体示例代码。

前言

学习了几个月的加瓦，有了一定的代码量，谈谈对面向对象的理解，此文包括了11111一些官方话术（借鉴提炼）与个人见解，作为总结为目的粗略介绍Java面向对象基础.Java面向对11111象的三大重要特性：封装，继承，多态，深入理解这三大特性，是掌握Java语言的必经之路.面向对象，顾名思义嘛，Java 的设计理念：万物皆对象，只需要一个new关键字就可以造万11111物.计算机的世界本身就是很抽象，很难以理解的，从以前的机器码01到汇编语言，再到现在的11111高级语言，牛逼的科学家通过无数次的封装，将抽象的计算机世界与易于理解的现实世界联系起来.而Java中的面向对象就是其中一种体现了.

封装

封装的定义

将对象的数据与操作对象数据的方法相结合，用方法将对象的数据与实现细节保护起来就统称为封装.外界只能通过对象的方法进行访问，因此封装实现了对对象数据的隐藏.

封装的意义

通过封装与数据的隐藏机制，将对象相关的数据与实现细节封装成一个独立的软件体，单独进行实现与维护，并使对象能在系统内方便地进行传递，另外也保证对象数据的一致性使得程序易于维护

继承

继承的定义

当一个类是另一个类的特例时，这两个类具有父子类关系，子类可以继承父类的状态（变量）跟行为（方法），子类可以复用父类的代码块（继承具有传递性）.并且可以对父类的特性进行拓展或者改变(除了使用private与default（package）权限修饰符之外并且子类与父类不在同一个包中)，代码中使用extends关键字实现继承关系，继承是类之间的“is a ”的关系，继承关系反应一个子类是一个父类的特例，比如，动物是父类，猫是子类，猫是动物的一个特例.A cat is an animal.Java不像cpp，Java只支持单继承，不支持多重继承，单继承是指每一个子类只能继承一个父类，多重继承指的是一个子类可以同时继承多个父类.但是Java大佬们为了弥补这一缺陷就提出了接口的概念，可以通过接口的多重继承来实现一些特性的场景.

继承的意义

减少的代码的重复说明，提高代码的复用性，使得类与类之间具有关联性，更加方便管理与维护每一个类.

继承的注意事项（细节点）

1.子类可以继承父类的状态（变量）跟行为（方法），这里所说的是父类的成员变量与成员方法没有被private关键字与default关键字修饰并且子类与父类不在同一个包中.

2.规则:系统（JVM）进行对象初始化的时候，子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法，那调默认的构造方法，就是没有参数的构造方法，但是如果你自己写了构造方法，那么编译器就不会给你添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是在子类构造方法中我们并没有显示的调用基类的构造方法，就是没写，如: super（）；并没有这样写，但是这样就会调用父类没有参数的构造方法，如果父类中没有没有参数的构造方法就会出错.

3.Java程序在执行子类的构造方法之前（必定先调用父类的构造方法再调用子类的构造方法），如果没有用super(）来调用父类特定的构造方法，则会自动调用父类中“没有参数的构造方法”。因此，如果父类中只定义了有参数的构造函数，而子类的构造方法中没有用super(）来调用父类中特定的构造方法，则编译时将发生出错，因为Java程序在父类中找不到没有参数的构造方法可供执行。解决方法是在父类里加一个不做事且没有参数的构造方法，或者在子类特定的有参构造中用super（）；调用父类的无参构造.

4.Java中构造方法不能被继承，因为如果构造方法被继承了就违背了Java的构造方法规范：方法名必须与类名一致.

继承的经典代码例子

//父类Animal
public class Animal {
//成员变量
    String name;
    int age;
//空参构造
    public Animal() {
        System.out.println("我运行了Animal的空参构造");
    }
//有参构造
    public Animal(String name, String age) {
        this.name = name;
        this.age = age;
        System.out.println("我运行了Animal的有参构造");
    }
//成员方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void drink(){
        System.out.println("喝水");
    }
}


//子类Cat
public class Cat extends Animal{
//空参构造，继承父类Animal
    public Cat() {
//此处super访问父类空参构造，系统（JVM）默认调用可省略不写
//        super();
        System.out.println("我运行了Cat的空参构造");
    }
//继承父类的有参构造，通过super关键字访问父类的地址值
    public Cat(String name  , String age) {
        super(name, age);
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
    public String getDatails(){
        return super.name + "   "+super.age;
    }
}



//测试类
public class Test {
    public static void main(String[] args) {
        //创建对象并调用方法
        //创建猫对象
        Cat cat = new Cat();
        cat.drink();
        cat.eat();
        cat.catchMouse();
        cat.name = "田园猫";
        cat.age = "18";
        System.out.println(cat.getDatails());
    }
}

运行结果：

多态

多态定义与概述

多态指的是外部提供一个接口，内部多种实现，多态顾名思义，一个对象的多种不同的形态，是先有了继承关系才会有多态的概念，Java中分为编译时多态与运行时多态，编译时多态是指方法的重载，运行时多态指的是类之间的继承性，方法的重写（虚方法表），晚联编技术.

运行时多态

- 上塑造型

子类对象既可以当作子类的类型，也可以作为父类的类型对待，将子类对象的引用转换为父类对象引用（父类类型的变量指向子类的对象（子类对象地址值）），就称为上塑造型.子类通常是对父类的拓展，比父类有更多的变量与方法，所以子类是父类的超集，因此上塑造型是从一个特殊，具体的类型到一个通用，抽象的转换，是安全的.上塑造型的存在，使得子类对象可以当作父类的对象使用，父类的对象变量可以指向子类对象，所以父类对象变量父类类型的变量引用发出变量的访问与方法的调用只能在运行时刻根据该变量引用指向的具体类型确定（编译看左边，运行看右边），这就是运行时多态（方法的重写（虚方法表），晚联编技术）.

- 下塑造型

与上塑造型相反，通俗的讲就是我们常见的强制类型转换，将父类的引用转换为子类类型，是不安全的.需要进行类型检查.

多态的意义

应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。大大提高程序的可复用性。//继承

派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高可扩充性和可维护性。 //多态的真正作用，

3.可替换性(substitutability)。多态对已存在代码具有可替换性。例如，多态对圆Circle类工作，对其他任何圆形几何体，如圆环，也同样工作。

4.可扩充性(extensibility)。多态对代码具有可扩充性。增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作。实际上新加子类更容易获得多态功能。例如，在实现了圆锥、半圆锥以及半球体的多态基础上，很容易增添球体类的多态性。

5.接口性(interface-ability)。多态是超类通过方法签名，向子类提供了一个共同接口，由子类来完善或者覆盖它而实现的。

6.灵活性(flexibility)。它在应用中体现了灵活多样的操作，提高了使用效率。

7.简化性(simplicity)。多态简化对应用软件的代码编写和修改过程，尤其在处理大量对象的运算和操作时，这个特点尤为突出和重要。

8.把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

多态的经典代码例子

//父类Animal
public class Animal {
    String name = "动物";
    public void eat(){
        System.out.println("吃东西");
    }
    public void drink(){
        System.out.println("动物在喝东西" );
    }
}

//子类Dog
public class Dog extends Animals{
    String age;
    @Override
    public void eat(){
        System.out.println("狗吃狗粮");
    }
    public void catchMouse(){
        System.out.println("狗抓老鼠");
    }
}

//子类Cat
public class Cat extends Animals{
    String hobby;
    @Override
    public void eat(){
        System.out.println("猫吃猫粮");
    }
    public void lookHome(){
        System.out.println("猫看家");
    }
}


//测试类
public class Test {
    public static void main(String[] args) {
        Animal c = new Cat();
        c.eat();/*调用成员方法编译看左边（编译器先看父类有没有这个方法，所以不能调用子类特有的方法调                  用lookHome方法，编译报错），运行看右边（如果子类重写了父类的方法，运行时是运行子类的方法）*/
        Animal d = new Dog();
        d.eat();
        c.drink();
        System.out.println(c.name);
    }
}

运行结果