继承（个人学习笔记黑马学习）

最新推荐文章于 2024-10-02 21:20:07 发布

寻心的无心者

最新推荐文章于 2024-10-02 21:20:07 发布

阅读量216

点赞数

分类专栏：黑马Java学习笔记文章标签：学习笔记 java idea

本文链接：https://blog.csdn.net/m0_59848857/article/details/130663053

版权

黑马Java学习笔记专栏收录该内容

23 篇文章 0 订阅

订阅专栏

文章详细介绍了Java中的继承概念，包括继承的格式、设计规范、特点、成员变量和方法的访问特点、方法重写、子类构造器的特点以及如何访问父类的有参构造器。同时，文章通过实例解释了this和super的关键作用，并强调了构造器中this(...)和super(...)的使用规则。

摘要由CSDN通过智能技术生成

继承的格式

格式：

package com.itheima.d5_extends;


public class Test {
    public static void main(String[] args) {
        //目标：认识继承关系
        student s=new student();
        s.run();



    }
}

package com.itheima.d5_extends;

/*
人类：父类

 */
public class People {
    public void run(){
        System.out.println("人会跑");
    }
}

package com.itheima.d5_extends;

/*
学生类：子类
 */
public class student extends People{

}

继承的设计规范

需求:
在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。
分析:

学生信息和行为 (名称，年龄，所在班级，查看课表，填写听课反馈)
老师信息和行为(名称，年龄，部门名称，查看课表，发布问题
定义角色类作为父类包含属性 (名称，年龄)，行为 (查看课表定义子类
学生类包含属性 (所在班级)，行为 (填写听课反馈定义子类
老师类包含属性 (部门名称)，行为 (发布问题)
package com.itheima.d5_extends_test;

public class Test {
    public static void main(String[] args) {
        Student s=new Student();
        s.setName("蜘蛛精");
        s.setAge(99);
        System.out.println(s.getName());
        System.out.println(s.getAge());
        s.queryCourse();
        s.writeInfo();

    }
}
package com.itheima.d5_extends_test;
/*
子类
 */

public class Student extends People {
    public void writeInfo(){
        System.out.println(getName()+"写东西");
    }

}
package com.itheima.d5_extends_test;
/*
父类
 */

public class People {
    private String name;
    private int age;

    /*
    查看课表
     */
    public void queryCourse(){
        System.out.println(name+"在查看课表");
    }
    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;
    }
}

继承的特点

子类可以继承父类的属性和行为，但是子类不能继承父类的构造器
lava是单继承模式:一个类只能继承一个直接父类
ava不支持多继承、但是支持多层继承
ava中所有的类都是Object类的子类

package com.itheima.d7_extends_feature;

public class Test {
    public static void main(String[] args) {
        //目标：理解继承的特点
        //1.子类不能继承父类的构造器
        //1.子类是否可以继承父类的私有成员？ 我认为是可以 只是不能直接访问
        Tiger t=new Tiger();
        //t.eat();
        //3.子类是否可以继承父类的静态成员 我认为不算继承，只是共享
        System.out.println(Tiger.location);
    }
}

class Animal{
    private void eat(){
        System.out.println("在吃饭");
    }
    public static String location="北京动物园";
}

class Tiger extends Animal{

}

继承后，成员变量和成员方法的访问特点

继承后成员方法的访问特点，就近原则

package com.itheima.d8_extends_field_method;


public class Test {
    public static void main(String[] args) {
        //目标:理解继承后成员变量的访问特点，就近原则
        Dog d=new Dog();
        d.run();//子类的
        d.lookDoor();//子类的

    }
}

class Animal{
    public void run(){
        System.out.println("动物可以跑");
    }
}


class Dog extends Animal{
    public void lookDoor(){
        System.out.println("狗可以看门 ");
    }

    public void run(){
        System.out.println("狗跑的贼快");
    }
}

继承后成员变量的访问特点，就近原则

package com.itheima.d8_extends_field_method;

public class Test {
    public static void main(String[] args) {
        //目标:理解继承后成员变量的访问特点，就近原则
        Dog d=new Dog();
        d.run();//子类的
        d.lookDoor();//子类的
        d.showName();

    }
}

class Animal{
    public String name="动物名";
    public void run(){
        System.out.println("动物可以跑");
    }
}


class Dog extends Animal{
    public String name="狗名";
    public void lookDoor(){
        System.out.println("狗可以看门 ");
    }

    public void showName(){
        String name="局部名";
        System.out.println(name);
        System.out.println(this.name);//指定访问当前子类对象的name
    }
    public void run(){
        System.out.println("狗跑的贼快");
    }
}

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

格式：super.父类成员变量\父类成员方法

package com.itheima.d8_extends_field_method;

public class Test {
    public static void main(String[] args) {
        //目标:理解继承后成员变量的访问特点，就近原则
        Dog d=new Dog();
        d.run();//子类的
        d.lookDoor();//子类的
        d.showName();

    }
}

class Animal{
    public String name="动物名";
    public void run(){
        System.out.println("动物可以跑");
    }
}


class Dog extends Animal{
    public String name="狗名";
    public void lookDoor(){
        System.out.println("狗可以看门 ");
    }

    public void showName(){
        String name="局部名";
        System.out.println(name);
        System.out.println(this.name);//指定访问当前子类对象的name
        System.out.println(super.name);//指定访问父类的name
    }
    public void run(){
        System.out.println("狗跑的贼快");
    }
}

继承后：方法的重写

案例演示:

旧手机的功能只能是基本的打电话，发信息
新手机的功能需要能够:基本的打电话下支持视频通话。基本的发信息下支持发送语音和图片
package com.itheima.d9_extends_override;

public class Test {
    public static void main(String[] args) {
        //目标：认识方法重写
        NewPhone hw=new NewPhone();
        hw.call();
        hw.sendMsg();
    }
}

/*
新手机：子类
 */
class NewPhone extends Phone{
    //重写方法
    public void call(){
        super.call();
        System.out.println("开始语音通话");
    }

    //重新方法
    public void sendMsg(){
        super.sendMsg();
        System.out.println("发送图片");
    }
}


/*
旧手机：父类
 */
class Phone{
    public void call(){
        System.out.println("打电话");
    }

    public void sendMsg(){
        System.out.println("发短信");
    }
}
@Override重写注解

@override是放在重写后的方法上，作为重写是否正确的校验注解
加上该注解后如果重写错误，编译阶段会出现错误提示。
建议重写方法都加@Override注解，代码安全，优雅!
package com.itheima.d9_extends_override;

public class Test {
    public static void main(String[] args) {
        //目标：认识方法重写
        NewPhone hw=new NewPhone();
        hw.call();
        hw.sendMsg();
    }
}

/*
新手机：子类
 */
class NewPhone extends Phone{
    //重写方法
    @Override//1.重写校验注解，加上之后，这个方法必须是正确重写的，这样更安全  2.提高程序的可读性，代码优雅
    public void call(){
        super.call();
        System.out.println("开始语音通话");
    }

    //重新方法
    @Override
    public void sendMsg(){
        super.sendMsg();
        System.out.println("发送图片");
    }
}


/*
旧手机：父类
 */
class Phone{
    public void call(){
        System.out.println("打电话");
    }

    public void sendMsg(){
        System.out.println("发短信");
    }
}
方法重写注意事项和要求

重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
私有方法不能被重写。
子类重写父类方法时，访问权限必须大于或者等于父类 (暂时了解: 缺省< protected < public)
子类不能重写父类的静态方法，如果重写会报错的

继承后，子类构造器的特点

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

子类中所有的构造器默认都会先访问父类中无参的构造器，再执行自己。

为什么?

子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化。

怎么调用父类构造器的?

子类构造器的第一行语句默认都是:super()，不写也存在。
package com.itheima.d10_extends_constructor;


public class Test {
    public static void main(String[] args) {
        //目标：认识继承后子类构造器的特点
        //特点：子类的全部构造器默认会先访问父类的无参构造器再执行自己
        Dog d1=new Dog();
        System.out.println(d1);

        System.out.println("---------");

        Dog d2=new Dog("金毛");
        System.out.println(d2);
    }
}
package com.itheima.d10_extends_constructor;


public class Animal {
    public Animal(){
        System.out.println("父类Animal无参构造器");
    }
}
package com.itheima.d10_extends_constructor;


public class Dog extends Animal {

    public Dog(){
        super();//写不写都存在，默认找父类的无参构造器
        System.out.println("子类Dog无参数构造器");
    }
    public Dog(String name){
        System.out.println("子类Dog有参构造器");
    }
}

继承后，子类构造器访问父类的有参构造器

package com.itheima.d11_extends_constructor;

public class Test {
    public static void main(String[] args) {
        //目标：学习子类构造器如何去访问父类有参构造器
        Teacher t=new Teacher("dlei",18);
        System.out.println(t.getName());
        System.out.println(t.getAge());
    }
}

package com.itheima.d11_extends_constructor;

public class People {
    private String name;
    private int age;

    public People() {
    }

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

    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;
    }
}

package com.itheima.d11_extends_constructor;

public class Teacher extends People {
    public Teacher(String name,int age){
        //调用父类的有参构造器，初始化继承父类的数据
        super(name,age);
    }
}

this、super小结

关键字

访问成员变量

访问成员方法

访问构造方法

this

this.成员变量

访问本类成员变量

this.成员方法(...)

访问本类成员方法

this.(...)

访问本类构造器

super

super.成员变量

访问父类成员变量

super.成员方法(...)

访问父类成员方法

super(...)

访问父类构造器

案例需求:

在学员信息登记系统中，后台创建对象封装数据的时候如果用户没有输入学校，则默认使用“黑马培训中心”
如果用户输入了学校则使用用户输入的学校信息。

package com.itheima.d12_this;

public class Test {
    public static void main(String[] args) {
        //目标：理解this(...)的作用，本类构造器中访问本类兄弟构造器
        Student s1=new Student("小明","清华");
        System.out.println(s1.getName());
        System.out.println(s1.getSchoolName());


        Student s2=new Student("张三丰");
        System.out.println(s2.getName());
        System.out.println(s2.getSchoolName());
    }
}

package com.itheima.d12_this;

public class Student {
    private String name;
    private String schoolName;

    public Student() {
    }
    /*
    借用本类构造器
     */
    public Student(String name){
        this(name,"黑马程序员");
    }

    public Student(String name, String schoolName) {
        this.name = name;
        this.schoolName = schoolName;
    }

    public String getName() {
        return name;
    }

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

    public String getSchoolName() {
        return schoolName;
    }

    public void setSchoolName(String schoolName) {
        this.schoolName = schoolName;
    }
}