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类图设计中，聚合关系以空心菱形加实线箭头表示。

📢博客主页：https://lansonli.blog.csdn.net
📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正！
📢本文由 Lansonli 原创，首发于 CSDN博客🙉
📢停下休息的时候不要忘了别人还在奔跑，希望大家抓紧时间学习，全力奔赴更美好的生活✨

以上是关于大数据必学Java基础（四十）：面向对象三大特性之一继承(Inheritance)的主要内容，如果未能解决你的问题，请参考以下文章

大数据必学Java基础（三十九）：面向对象三大特性之一封装(Encapsulation)

大数据必学Java基础（四十六）：内部类和面向对象项目实战

大数据必学Java基础（四十四）：接口讲解

大数据必学Java基础（四十三）：抽象类和抽象方法讲解

大数据必学Java基础（四十二）：Final关键词讲解

大数据必学Java基础（三十四）：面向对象内存分析