(十四)面向对象的三大特征

时间:2023-01-09 09:03:17

目录

前言:

一、面向对象三大特征之一:封装

二、面向对象三大特征之二:继承

三、面向对象三大特征之三:多态


前言:

        面向对象的三大特征:封装、继承、多态。

一、面向对象三大特征之一:封装

1.概述:

        封装是把过程和数据包围起来,对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治、封装的对象,这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术,在java中通过关键字private,protected和public实现封装。什么是封装?封装把对象的所有组成部分组合在一起,封装定义程序如何引用对象的数据,封装实际上使用方法将类的数据隐藏起来,控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护,也加强了程式码的安全性。

        封装:告诉我们,如何正确设计对象的属性和方法。

        封装的原则:对象代表什么,就得封装对应的数据,并提供数据对应得行为。

        private:修饰的成员只能在当前类中访问。

2.例子:

public class Show{

    public static void show(String str){

    System.out.println(str);

    }

}

上面就是对 System.out.println();的封装。

调用的时候 :

public class Use{

    public static void main(String[] args){

    Show.show("封装");
    
    }

}

这样用的时候就不用使:System.out.println("封装");

二、面向对象三大特征之二:继承

1.什么是继承?

        java中提供一个关键字extends,用这个关键字,我们可以让一个类和另一个类建立起父子关系。

        public class Student extends people{}

        Student称为子类(派生类),people称为父类(基类或超类)。

        父类(super)、子类(this)

        作用:      当子类继承父类后,就可以直接使用父类公共的属性和方法了。

2.继承规范:

        ①子类们相同特征(共性属性,共性方法)放在父类中定义。

        ②子类独有的属性和行为应该定义在子类自己里面。

3.继承的特点:

        ①子类有自己的构造器,不能继承父类的构造器 ②子类是否可以继承父类的私有成员(可以继承父类的私有成员,只是不能直接访问! )

        ③子类是否可以继承父类的静态成员(不是继承,是共享的父类的) ​ ④java只能继承一个父类,不支持多继承,不过支持多层继承。 多层继承: A继承B,B继承C;

        ⑤object :object是祖宗类

4.在子类中给访问成员(成员变量、成员方法)满足:就近原则(局域对象<子类对象<父类对象)

        ①先子类局部范围找。

        ②然后子类成员范围找。

        ③然后父类成员范围找,如果父类范围还没有找到则报错。

5.如果子父类中,出现了重名的成员,会优先使用子类的,此时如果一定要在子类中使用父类的怎么办?

        ①可以通过super关键字,指定访问父类的成员。

                格式:super.父类成员变量/父类成员方法

        ②可以通过this关键字,指定访问子类的成员。

                格式:this.子类成员变量/子类成员方法

6.继承后:方法重写

        在继承体系中,子类出现了和父类中一摸一样的方法声明,我们就称子类这个方法是重写的方法。

7.方法重写的应用场景

        ①当子类需要父类的功能,但父类的该功能不完全满足自己的需求时。

        ②子类可以重写父类中的方法。

8.@Override重写注解:

        放在重写后的方法上,作为重写是否正确的校验注解。

作用:

        1.这个方法必须是正确重写的;

        2.提高代码的可读性,代码优雅。

注意:

        ①重写方法的名词称、形参列表必须与被重写方法的名称和参数列表一致。

        ②私有方法不能被重写。

        ③子类重写父类方法时,访问权限必须大于或者等于父类。

        ④子类不能重写父类的静态方法,如果重写会报错。

9.方法重写案例:

 旧手机的功能只能是基本的打电话,发信息;

新手机的功能需要能够在基本的打电话下支持视频通话。基本的发信息下支持发送语音和图片。

main类:

public class extends_Test {
    public static void main(String[] args) {
        //方法重写
        newphone nw = new newphone();
        nw.call();
        nw.sending();
    }
}
新手机类(子类):
​​​​​​​/*
新手机:子类
 */
class newphone extends phone{
    //重写的方法
    @Override//1.这个方法必须是正确重写的;2.提高代码的可读性,代码优雅。
    public void call(){
        super.call();//先用父类的基本功能
        System.out.println("开始视频通话");
    }
    //重写的方法
    @Override
    public void sending(){
        super.sending();//先用父类的基本功能
        System.out.println("发送有趣的图片~~");
    }
}
旧手机类(父类):
/*
旧手机:父类
 */
class phone{
    public void call(){
        System.out.println("打电话");
    }
    public void sending(){
        System.out.println("发短信");
    }
}

10.继承后:子类继承父类后构造器的特点:

        子类所有构造器都会先访问父类构造器,再调用自己的构造器,初始化父类的数据。

为什么?

        ①子类在初始化的时候,有可能会使用到父类中的数据,如果父类没有完成初始化,子类将无法使用父类的数据。

        ②子类初始化之前,一定要调用父类构造器先完成父类数据空间的初始化。

怎么调用父类构造器?

        子类构造器的第一行语句默认都是:super(),不写也存在。

11.继承后:子类构造器访问父类有参构造器?

super调用父类有参构造器的作用:

        初始化继承自父类的数据;

 如果父类中没有无参数构造器,只有有参构造器,会出现什么现象呢?

         会报错,因为子类默认是调用父类无参构造器的。

如何解决?

        子类构造器中可以书写super(...),手动调用父类的有参数构造器。

12.代码演示:

猫类(子类):

public class cat extends dog {
    public cat(){
        System.out.println("子类cat无参数构造器被执行~~");
    }
    public cat(String name){
        System.out.println("子类cat有参数构造器被执行~~");
    }
}
狗类(父类):

public class dog {
    public dog(){
        System.out.println("父类dog无参数构造器被执行~~");
    }
}
main类:

public class test1 {
    public static void main(String[] args) {
        //继承后子类构造器的特点
        cat c1 = new cat();
        System.out.println(c1);
        System.out.println("----------");
        cat c2 = new cat("金毛");
        System.out.println(c2);
    }
}
 

13.this和super小结

        this:代表本类对象的引用;
        super:代表父类存储空间的标识。

(十四)面向对象的三大特征

  • this()和super()必须要在第一行,所以一个构造器中不能共存this()和super();

  • this :访问子类当前对象的成员

  • super :在子类方法中指定访问父类的成员

  • this(...) :访问本类兄弟构造器

  • super(...) : 在本类构造器中指定访问父类的构造器

14.代码演示:

动物类(父类):

public abstract class Animal {
    public String name = "动物名";
​
    public void eat() {
        System.out.println("动物要吃东西!");
    }
​
    public static String location = "长隆动物园";
​
    public abstract void run();
}

老虎类(子类):

public class Tiger extends Animal {
    public static boolean location;
    String name = "老虎名";
​
    public void showName(){
        String name = "局部名";
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
        super.eat();
        this.eat();
    }
    @Override // 1、重写校验注解,加上之后,这个方法必须是正确重写的,这样更安全  2、提高代码的可读性
    /**1、重写的名字和形参列表必须与被重写的方法一样
     * 2、私有方法不能被重写
     * 3、子类重写父类方法时,访问权限必须大于或者等于父类( 访问权限:privase < 不写 < protected < public)
     * 4、静态方法不能被子类重写
     */
    public void eat(){
        super.eat();//方法重写,重写父类
        System.out.println("老虎在吃东西");
    }
​
    @Override
    public void run() {
        
    }
}

实现类:

//extends :子类继承父类  让一个类与另一个类建立父子关系,用于提高代码复用性(子类extends 父类)
//父类(super)、子类(this)
public class extends_Demo4 {
    /**  继承的特点:
     * 1、子类有自己的构造器,不能继承父类的构造器
     * 2、子类是否可以继承父类的私有成员(可以继承父类的私有成员,只是不能直接访问! )
     * 3、子类是否可以继承父类的静态成员(不是继承,是共享的父类的)
     * 4、java只能继承一个父类,不支持多继承,不过支持多层继承。  多层继承: A继承B,B继承C;
     * 5、object :object是祖宗类
     * 在子类中给访问成员(成员变量、成员方法)满足:就近原则(局域对象<子类对象<父类对象)
     */
    //子类所有构造器都会先访问父类构造器,再调用自己的构造器,初始化父类的数据
​
    /**
     * this()和super()必须要在第一行,所以一个构造器中不能共存this()和super();
     * this :访问子类当前对象的成员
     * super :在子类方法中指定访问父类的成员
     * this(...) :访问本类兄弟构造器
     * super(...) : 在本类构造器中指定访问父类的构造器
     */
    public static void main(String[] args) {
        Tiger t = new Tiger();
        t.eat();
        System.out.println(Tiger.location);
        t.showName();
​
    }
}

 

三、面向对象三大特征之三:多态

1.概述:

        同类型的对象执行同一个行为,会表现出不同的行为特征。

2.多态的常见形式:

        父类类型 对象名称 = new 子类构造器;

        接口 对象名称 = new 实现类构造器;

3.代码演示:

动物类:

public abstract class Animal {
    public String name = "动物名";
​
    public void eat() {
        System.out.println("动物要吃东西!");
    }
​
    public static String location = "长隆动物园";
​
    public abstract void run();
}

实现类:

public class polymorphic_Demo {
    public static void main(String[] args) {
        Animal a = new Animal() {//父类类型 对象名称 = new 子类构造器;
            @Override
            public void run() {
                System.out.println("????跑得很快~~");
            }
        };
        a.run();//编译看左边,运行看右边
    }

4.多态成员访问特点:

  • 方法调用:编译看左边,运行看右边

  • 变量调用:编译看左边,运行看左边(多态侧重行为多态)

5.多态的前提:

        ①有继承/实现关系;

        ②有父类引用指向子类对象;

        ③有方法重写;

6.多态的优势:

        ①在多态的形式下,右边对象可以实现解耦合,便于扩展和维护;

        ②定义方法的时候,使父类型作为参数,该方法可以接收这父类的一切子类对象,体现出多态的扩展性与便利;

        ③多态下不能访问子类的独有功能;

7.多态下引用数据类型的类型转换

  • 自动类型转换(从子到父):子类对象赋值给父类类型的变量指向;

  • 强制类型转换(从父到子):子类 对象变量 = (子类)父类类型的变量;

  • 作用:解决多态下的劣势,实现调用子类独有的功能。

  • 有继承或实现关系编译阶段可以强制转换,但如果转型后的类型和对象的真实类型不是同一种类型,那么在转换的时候就会出现异常:ClassCastException

  • (十四)面向对象的三大特征 

  • Java建议强制转换前使用instanceof判断当前对象的真实类型,再进行强制转换;

  • 变量名 instanceof 真实类型:用于判断关键字左边的变量指向的对象的真实类型,是否是右边的类型或者是其子类类型,是则返回true;

  • (十四)面向对象的三大特征

     

9.案例:

需求:

        ①使用面向对象编程模拟:设计一个电脑对象,可以安装2个USB设备。

        ②鼠标:被安装时可以完成接入、调用点击功能、拔出功能。

        ③键盘:被安装时可以完成接入、调用点击功能、拔出功能。

分析:

        ①定义一个USB的接口(申明USB设备的规范必须是:可以接入和拔出)。

        ②提供2个USB实现类代表鼠标和键盘,让其实现USB接口,并分别定义独有功能。

        ③创建电脑对象,创建2个USB实现类对象,分别安装到电脑中并触发功能的执行。

USB接口规范类:

/**
 * USB接口 == 规范
 */
public interface USB {
    //接入、拔出
    void connect();
    void unconnect();
}

键盘实现类:

/**
 * 实现类
 */
public class keyBoard implements USB{
    private String name;
​
    public keyBoard(String name) {
        this.name = name;
    }
    @Override
    public void connect() {
        System.out.println(name+"成功连接电脑");
    }
​
    @Override
    public void unconnect() {
        System.out.println(name+"成功拔出电脑");
    }
​
    /**
     * 独有功能
     */
    public void keyDown(){
        System.out.println(name+"敲击了:来了,老弟~~");
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}

鼠标实现类:

   /**
     * 实现类
     */
public class Mouse implements USB {
        private String name;
        public Mouse(String name) {
            this.name = name;
        }
        @Override
        public void connect() {
            System.out.println(name + "成功连接电脑");
        }
​
        @Override
        public void unconnect() {
            System.out.println(name + "成功拔出电脑");
        }
        /**
         * 独有功能
         */
        public void duClick() {
            System.out.println(name + "双击点亮:小红心~~");
        }
​
        public String getName() {
            return name;
        }
​
        public void setName(String name) {
            this.name = name;
        }
}

电脑实现类:

public class computer {
    private String name;
​
    public computer(String name) {
        this.name = name;
    }
    public void start(){
        System.out.println(name+"电脑开机了~~");
    }
​
    /**
     * 提供安装USB设备的入口
     */
    public void installUSB(USB usb){
        //多态:usb == 可能是鼠标,也可以是键盘
        usb.connect();
        //独有功能:先判断再强转
        if (usb instanceof keyBoard) {
            keyBoard k = (keyBoard) usb;
            k.keyDown();
        }else if(usb instanceof Mouse){
            Mouse m = (Mouse) usb;
            m.duClick();
        }
        usb.unconnect();
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}

实现main类:

/**
 * 目标:USB设备模拟
 * 1、定义USB接口:插入和拔出
 * 2、定义两个USB的实现类 :鼠标和键盘
 * 3、创建一个电脑对象,创建USB设备对象,安装启动
 */
public class Test {
    public static void main(String[] args) {
        //1.创建电脑对象
        computer c = new computer("外星人");
        c.start();
        //2.创建鼠标和键盘对象
        USB u = new keyBoard("双飞燕");
        c.installUSB(u);
        USB u1 = new Mouse("逻辑");
        c.installUSB(u1);
​
    }
}