Lanson

V1

2022/12/15阅读:24主题:丘比特忙

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

面向对象三大特性之一继承(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类图设计中,聚合关系以空心菱形加实线箭头表示。

分类:

后端

标签:

Java

作者介绍

Lanson
V1

CSDN大数据领域博客专家