大数据必学Java基础（四十）：面向对象三大特性之一继承(Inheritance)

举报
Lansonli 发表于 2022/08/03 00:43:50 2022/08/03
【摘要】 ​面向对象三大特性之一继承(Inheritance)一、列举案例说明1、类是对对象的抽象举例：荣耀20 ，小米 红米3，华为 p40 pro ---> 类：手机类2、继承是对类的抽象举例：学生类：Student属性：姓名，年龄，身高，学生编号方法：吃饭，睡觉，喊叫，学习教师类：Teacher属性：姓名，年龄，身高，教师编号方法：吃饭，睡觉，喊叫，教学员工类：Emploee属性：姓名，年龄，身...

​面向对象三大特性之一继承(Inheritance)

一、列举案例说明

1、类是对对象的抽象

举例：

荣耀20 ，小米 红米3，华为 p40 pro ---> 类：手机类

2、继承是对类的抽象

举例：

学生类：Student

属性：姓名，年龄，身高，学生编号

方法：吃饭，睡觉，喊叫，学习

教师类：Teacher

属性：姓名，年龄，身高，教师编号

方法：吃饭，睡觉，喊叫，教学

员工类：Emploee

属性：姓名，年龄，身高，员工编号

方法：吃饭，睡觉，喊叫，工作

共同的东西

人类：

属性：姓名，年龄，身高

方法：吃饭，睡觉，喊叫

学生类/教师类/员工类 继承 自 人类

以后定义代码

先定义人类：

人类： ---》父类，基类，超类

属性：姓名，年龄，身高

方法：吃饭，睡觉，喊叫

再定义 ： ---》子类，派生类

学生类：Student：

属性：学生编号

方法：学习

教师类：Teacher

属性：教师编号

方法：教学

员工类：Emploee

属性：员工编号

方法：工作

子类 继承自 父类

狗类

属性：姓名，年龄，身高

方法：吃饭，睡觉，喊叫

我们的继承关系，是在合理的范围中进行的抽取 ，抽取出子类父类的关系

上面的案例中：

学生类/教师类/员工类 继承 自 人类 ---》合理

学生类/教师类/员工类 继承 自 狗类 ---》不合理

区分：

学生是一个人

教师是一个人

员工是一个人 ---》合理

学生是一个狗 ---》不合理

总结：继承 就是 is - a 的关系

3、代码层面的解释

先写父类，再写子类：

父类：人类 Person

子类：学生类 Student

package com.lanson.test03;

/**
 * @Auther: lanson
 */
public class Person {
    //属性：
    private int age;
    private String name;
    private double height;

    //提供setter getter方法：

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    //方法：
    public void eat(){
        System.out.println("可以吃饭。。。");
    }

    public void sleep(){
        System.out.println("可以睡觉。。。");
    }

}


package com.lanson.test03;

/**
 * @Auther: lanson
 */
public class Student extends Person {//子类Student 继承  父类Person
    //属性：
    private int sno;//学号

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    //方法：
    public void study(){
        System.out.println("学生可以学习");
    }

}


package com.lanson.test03;

/**
 * @Auther: lanson
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建子类Student的对象
        Student s = new Student();
        s.setSno(1001);
        s.setAge(18);
        s.setName("菲菲");
        s.setHeight(180.4);

        System.out.println("学生名字为："+s.getName()+",学生的年纪："+s.getAge());

        //访问方法：
        s.study();
        s.eat();
        s.sleep();
    }
}


4、继承的好处：提高代码的复用性

父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了

需要注意的点：

父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式，可以间接调用。

5、总结

5.1、继承关系

父类/基类/超类

子类/派生类

子类继承父类一定在合理的范围进行继承的 子类 extends 父类

5.2、继承的好处

1）提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了

2）便于代码的扩展

3）为了以后多态的使用。是多态的前提

5.3、父类private修饰的内容，子类也继承过来了

5.4、一个父类可以有多个子类

5.5、一个子类只能有一个直接父类

但是可以间接的继承自其它类。

5.6、继承具有传递性

Student --》继承自 Person ---》继承自Object

Object类是所有类的根基父类。

所有的类都直接或者间接的继承自Object。

二、内存分析

三、权限修饰符

1、private

权限：在当前类中可以访问

2、default:缺省修饰符

权限：到同一个包下的其他类都可以访问

3、protected

权限：最大到不同包下的子类

4、public

权限：在整个项目中都可以访问

5、总结

属性，方法：修饰符：四种：private，缺省，protected，public

类：修饰符：两种：缺省，public

以后写代码

一般属性：用private修饰 ，方法：用public修饰

四、方法的重写

1、重写

发生在子类和父类中，当子类对父类提供的方法不满意的时候，要对父类的方法进行重写。

2、重写有严格的格式要求

子类的方法名字和父类必须一致，参数列表（个数，类型，顺序）也要和父类一致。

3、代码

public class Person {
    public void eat(){
        System.out.println("吃食物");
    }
    public void sleep(){
        System.out.println("睡觉");
    }
}

 
public class Student extends Person {
    public void study(){
        System.out.println("学习");
    }
          @override
    public void eat(){
        System.out.println("我喜欢吃小龙虾喝啤酒。。");
    }
}


public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个Student类的对象：
        Student s = new Student();
        s.eat();
    }
}


4、内存

5、重载和重写的区别

重载：在同一个类中，当方法名相同，形参列表不同的时候 多个方法构成了重载

重写：在不同的类中，子类对父类提供的方法不满意的时候，要对父类的方法进行重写

五、super

【1】super:指的是父类的

【2】super可以修饰属性，可以修饰方法；

在子类的方法中，可以通过 super.属性 super.方法 的方式，显示的去调用父类提供的属性，方法。在通常情况下，super.可以省略不写

在特殊情况下，当子类和父类的属性重名时，你要想使用父类的属性，必须加上修饰符super.，只能通过super.属性来调用

在特殊情况下，当子类和父类的方法重名时，你要想使用父类的方法，必须加上修饰符super.，只能通过super.方法来调用

在这种情况下，super.就不可以省略不写。

【3】super修饰构造器：

其实我们平时写的构造器的第一行都有：super() -->作用：调用父类的空构造器，只是我们一般都省略不写

（所有构造器的第一行默认情况下都有super(),但是一旦你的构造器中显示的使用super调用了父类构造器，那么这个super()就不会给你默认分配了。如果构造器中没有显示的调用父类构造器的话，那么第一行都有super(),可以省略不写）

如果构造器中已经显示的调用super父类构造器，那么它的第一行就没有默认分配的super()

在构造器中，super调用父类构造器和this调用子类构造器只能存在一个，两者不能共存：

因为super修饰构造器要放在第一行，this修饰构造器也要放在第一行：

改正二选一即可：

【4】以后写代码构造器的生成可以直接使用IDEA提供的快捷键：

alt+insert

六、继承条件下构造方法的执行过程

package com.lanson.test10;

/**
 * @Auther: lanson
 */
public class Person {
    int age;
    String name;

    public Person(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public Person() {
    }
}


public class Student extends Person {
    double height ;

    public Student() {
    }

    public Student(int age, String name, double height) {
        super(age, name);
        this.height = height;
    }
}


public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        Student s = new Student(19,"feifei",160.8);
    }
}


七、Object类

所有类都直接或间接的继承自Object类，Object类是所有Java类的根基类。

也就意味着所有的Java对象都拥有Object类的属性和方法。

如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类。

1、toString()方法

【1】Object类的toString()的作用：

方法的原理：

现在，使用toString方法的时候，打印出来的东西 “不好看”，对于其他人来说不友好，可读性不好

我们现在是想知道对象的信息，名字，年龄，身高......

现在的格式不好：

出现的问题：子类Student对父类Object提供的toString方法不满意，不满意--》对toString方法进行重写：

package com.lanson.test01;

/**
 * @Auther: lanson
 */
public class Student /*extends Object*/{
    private String name;
    private int age;
    private double height;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public Student() {
    }

    public Student(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }

    public String toString() {
        return "这是一个Student对象，这个对象的名字："+name+",年龄："+age+",身高："+height;
    }
}


测试类

总结：toString的作用就是对对象进行“自我介绍”，一般子类对父类提供的toString都不满意，都要进行重写。

2、equals方法

package com.lanson.test02;

/**
 * @Auther: lanson
 */
public class Phone {//手机类：
    //属性：
    private String brand;//品牌型号
    private double price;//价格
    private int year ;//出产年份
    //方法：

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", year=" + year +
                '}';
    }

    //构造器：

    public Phone() {
    }

    public Phone(String brand, double price, int year) {
        this.brand = brand;
        this.price = price;
        this.year = year;
    }


    //对equals方法进行重写：
    public boolean equals(Object obj) {//Object obj = new Phone();
        //将obj转为Phone类型：
        Phone other = (Phone)obj;//向下转型，为了获取子类中特有的内容
        if(this.getBrand()==other.getBrand()&&this.getPrice()==other.getPrice()&&this.getYear()==other.getYear()){
            return true;
        }
        return false;
    }
}


package com.lanson.test02;

/**
 * @Auther: lanson
 */
public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {

        //创建Phone类的对象：
        Phone p1 = new Phone("华为P40",2035.98,2020);
        Phone p2 = new Phone("华为P40",2035.98,2020);
        //比较两个对象：p1和p2对象：
        //==的作用：比较左右两侧的值是否想的，要么相等，返回true,要么不相等,返回false
        System.out.println(p1==p2);//-->>>对于引用数据类型来说，比较的是地址值。--->一定返回的是false

        //Object类提供了一个方法 equals方法 ：作用：比较对象具体内容是否相等。
        boolean flag = p1.equals(p2);//点进源码发现：底层依旧比较的是==，比较的还是地址值。
        System.out.println(flag);

    }
}


总结：

equals作用：这个方法提供了对对象的内容是否相等 的一个比较方式，对象的内容指的就是属性。

父类Object提供的equals就是在比较==地址，没有实际的意义，我们一般不会直接使用父类提供的方法，

而是在子类中对这个方法进行重写。

instanceof

利用集成开发工具生成equals方法

【1】利用eclipse：

【2】利用idea：

八、类和类的关系

1、案例和代码

【1】面向对象的思维：找参与者，找女孩类，找男孩类

【2】体会了什么叫方法的性擦，什么叫方法的实参：

具体传入的内容实参：

【3】类和类可以产生关系：

（1）将一个类作为另一个类中的方法的形参

（2）将一个类作为另一个类的属性

public class Girl {
    //属性：
    String name;
    double weight;
    Mom m /*= new Mom()*/;
    //方法：
    public void add(int a){//参数是基本数据类型
        System.out.println(a);
        System.out.println(a+100);
    }
    //谈恋爱的方法：
    public void love(Boy b){//参数是引用数据类型Boy
        System.out.println("我男朋友的名字是："+b.name+"，我男朋友的年龄是："+b.age);
        b.buy();
    }

    //女孩跟妈妈聊天：
    public void wechat(){
        m.say();
    }

    //构造器：
    public Girl(String name, double weight) {
        this.name = name;
        this.weight = weight;
    }
}

public class Boy {
    //属性：
    int age;
    String name;
    //方法：
    public void buy(){
        System.out.println("跟我谈恋爱，我给你买买买。。。");
    }
    //构造器：
    public Boy(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

public class Mom {
    //方法：
    public void say(){
        System.out.println("妈妈唠唠叨叨 都是爱，听妈妈的话。。");
    }
}


public class Test {
    //这是一个main方法，是程序的入口：
    public static void main(String[] args) {
        //创建一个Boy类的具体的对象：
        Boy boy = new Boy(30,"鹿晗");
        //创建一个Girl类的具体的对象：
        Girl girl = new Girl("关晓彤",100);
        //谈恋爱：
        //girl.love(boy);
        Boy boy2 = new Boy(35,"陈伟霆");
        girl.love(boy2);

        //还可以跟妈妈微信聊天：
        girl.m = new Mom();
        girl.wechat();
    }
}


2、总结

2.1、继承关系

继承指的是一个类（称为子类、子接口）继承另外的一个类（称为父类、父接口）的功能，并可以增加它自己的新功能的能力。在Java中继承关系通过关键字extends明确标识，在设计时一般没有争议性。在UML类图设计中，继承用一条带空心三角箭头的实线表示，从子类指向父类，或者子接口指向父接口。

2.2、实现关系

实现指的是一个class类实现interface接口（可以是多个）的功能，实现是类与接口之间最常见的关系。在Java中此类关系通过关键字implements明确标识，在设计时一般没有争议性。在UML类图设计中，实现用一条带空心三角箭头的虚线表示，从类指向实现的接口。

2.3、依赖关系

简单的理解，依赖就是一个类A使用到了另一个类B，而这种使用关系是具有偶然性的、临时性的、非常弱的，但是类B的变化会影响到类A。比如某人要过河，需要借用一条船，此时人与船之间的关系就是依赖。表现在代码层面，让类B作为参数被类A在某个method方法中使用。在UML类图设计中，依赖关系用由类A指向类B的带箭头虚线表示。

2.4、关联关系

关联体现的是两个类之间语义级别的一种强依赖关系，比如我和我的朋友，这种关系比依赖更强、不存在依赖关系的偶然性、关系也不是临时性的，一般是长期性的，而且双方的关系一般是平等的。关联可以是单向、双向的。表现在代码层面，为被关联类B以类的属性形式出现在关联类A中，也可能是关联类A引用了一个类型为被关联类B的全局变量。在UML类图设计中，关联关系用由关联类A指向被关联类B的带箭头实线表示，在关联的两端可以标注关联双方的角色和多重性标记。

2.5、聚合关系

聚合是关联关系的一种特例，它体现的是整体与部分的关系，即has-a的关系。此时整体与部分之间是可分离的，它们可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。比如计算机与CPU、公司与员工的关系等，比如一个航母编队包括海空母舰、驱护舰艇、舰载飞机及核动力攻击潜艇等。表现在代码层面，和关联关系是一致的，只能从语义级别来区分。在UML类图设计中，聚合关系以空心菱形加实线箭头表示。

​

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Java 大数据 面向对象编程
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入