面向对象、封装、继承、多态

最新推荐文章于 2023-09-05 16:42:08 发布

weixin_44987227

最新推荐文章于 2023-09-05 16:42:08 发布

阅读量183

点赞数

分类专栏： java面向对象

本文链接：https://blog.csdn.net/weixin_44987227/article/details/114105807

版权

java面向对象专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、面向对象思想

面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。

面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

二、类与对象

2.1 什么是类：

一组相同属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
现实中，描述一类事物：属性：就是该事物的状态信息。行为：就是该事物能够做什么。
举例：小猫。属性：名字、体重、年龄、颜色。行为：走、跑、叫。

2.2 什么是对象：

是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为

现实中，一类事物的一个实例：一只小猫。
举例：一只小猫。属性：tom、5kg、2 years、yellow。行为：溜墙根走、蹦跶的跑、喵喵叫。

2.3 类与对象的关系：

类是对一类事物的描述，是抽象的。
对象是一类事物的实例，是具体的。
类是对象的模板，对象是类的实体。

三、封装

3.1 封装的概述

封装是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

原则：将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

3.2 封装的步骤

使用 private 关键字来修饰成员变量。
对需要访问的成员变量，提供对应的一对 getXxx 方法、 setXxx 方法。

3.3 this关键字

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

记住：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

3.4 构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

注意事项

如果你不提供构造方法，系统会给出无参数构造方法。
如果你提供了构造方法，系统将不再提供无参数构造方法。
构造方法是可以重载的，既可以定义参数，也可以不定义参数。

四、继承

4.1 定义

子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

Java只支持单继承，不支持多继承。
Java支持多层继承(继承体系)
子类拥有父类非 private 的属性、方法。

4.2 继承后特点

4.2.1 成员变量

成员变量不重名：不影响访问

成员变量重名：子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前学过的 this 。

4.2.2 成员方法

成员方法不重名：不影响访问

成员方法重名：重写，子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

4.2.3 构造方法

构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。

构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

子类是不继承父类的构造方法的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

4.2.4 super和this

父类空间优先于子类对象产生 在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。理解图解如下：

super和this的含义： super ：代表父类的存储空间标识(可以理解为父亲的引用)。 this ：代表当前对象的引用(谁调用就代表谁)。

this.成员变量 ‐‐ 本类的

super.成员变量 ‐‐ 父类的

this.成员方法名() ‐‐ 本类的

super.成员方法名() ‐‐ 父类的

4.2.5 方法重载与重写

(1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。

(2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。

(3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

五、接口

5.1 概述

如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，在JAVA编程语言中是一个抽象类型，是抽象方法的集合一个类通过继承接口的方式，从而来继承接口的抽象方法。

5.2 格式

public interface 接口名称 {
    // 抽象方法
    // 默认方法
    // 静态方法
    // 私有方法
}

5.3 接口的多实现

在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
    // 重写接口中抽象方法【必须】
    // 重写接口中默认方法【不重名时可选】
}

[ ]： 表示可选操作。

抽象方法接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：定义多个接口：

interface A {
    public abstract void showA();
    public abstract void show();
}
interface B {
    public abstract void showB();
    public abstract void show();
}

定义实现类：

public class C implements A,B{
    @Override
    public void showA() {
        System.out.println("showA");
    }
    @Override
    public void showB() {
        System.out.println("showB");
    }
    @Override
    public void show() {
        System.out.println("show");
    }
}

默认方法接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：定义多个接口：

interface A {
    public default void methodA(){}
    public default void method(){}
}
interface B {
    public default void methodB(){}
    public default void method(){}
}

定义实现类：

public class C implements A,B{
    @Override
    public void method() {
        System.out.println("method");
    }
}

静态方法接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

优先级的问题当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

六、多态

6.1 概述

引入：生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

定义：指同一行为，具有多个不同表现形式。

前提【重点】：

继承或者实现【二选一】
方法的重写【意义体现：不重写，无意义】
父类引用指向子类对象【格式体现】

6.2 多态的体现

多态体现的格式：

父类类型 变量名 = new 子类对象；
变量名.方法名();

如：
Fu f = new Zi();
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

6.3 多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。代码如下：

定义父类：

public abstract class Animal {

    public abstract void eat();

}

定义子类：

class Cat extends Animal {

    public void eat() {
        System.out.println("吃鱼");
    }
}

class Dog extends Animal {

    public void eat() {
        System.out.println("吃骨头");
    }
}

定义测试类：

public class Test {

    public static void main(String[] args) {

        // 多态形式，创建对象
        Cat c = new Cat();
        Dog d = new Dog();

        // 调用showCatEat
        showCatEat(c);

        // 调用showDogEat
        showDogEat(d);

    /* 
    以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
    而执行效果一致
    */
    showAnimalEat(c);
    showAnimalEat(d);

    }

    public static void showCatEat (Cat c){
        c.eat();
    }

    public static void showDogEat (Dog d){
        d.eat();
    }

    public static void showAnimalEat (Animal a){
        a.eat();
    }

}

6.4 引用类型的转换

多态的转型分为向上转型与向下转型两种：

6.4.1 向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。使用格式：

父类类型 变量名 = new 子类类型();

如：Animal a = new Cat();

6.4.2 向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。使用格式：

子类类型 变量名 = (子类类型) 父类变量名;

如:Cat c =(Cat) a;

6.4.3 为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。转型演示，代码如下：定义类：

abstract class Animal {
    abstract void eat();
}

class Cat extends Animal {

    public void eat() {
        System.out.println("吃鱼");
    }

    public void catchMouse() {
        System.out.println("抓老鼠");
    }
}

class Dog extends Animal {

    public void eat() {
        System.out.println("吃骨头");
    }

    public void watchHouse() {
        System.out.println("看家");
    }
}

定义测试类：

public class Test {

    public static void main(String[] args) {

        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat

        // 向下转型
        Cat c = (Cat)a;
        c.catchMouse(); // 调用的是 Cat 的 catchMouse

    }
}

6.4.4 转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {

    public static void main(String[] args) {

        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat
    
        // 向下转型
        Dog d = (Dog)a;
        d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】

    }
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了 Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型

如果变量属于该数据类型，返回true。

如果变量不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {

    public static void main(String[] args) {

        // 向上转型
        Animal a = new Cat();
        a.eat(); // 调用的是 Cat 的 eat

        // 向下转型
        if (a instanceof Cat){

            Cat c = (Cat)a;
            c.catchMouse(); // 调用的是 Cat 的 catchMouse

        } else if (a instanceof Dog){

            Dog d = (Dog)a;
            d.watchHouse(); // 调用的是 Dog 的 watchHouse

        }
    }
}

weixin_44987227

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象、封装、继承、多态

一、面向对象思想面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。二、类与对象2.1 什么是类：.
复制链接

扫一扫

专栏目录