java继承基础概念梳理及拓展

概念

将子类之间的共性进行抽取生成父类, 在继承关系下, 子类能够直接拥有父类可被继承的内容

继承的作用之一就是解决子类之间的代码冗余问题

语法

public class 子类类名 extends 父类类名{
    
}

package com.by.entity;

/**
 动物类-父类
 */
public class Animal {
    //名字  年龄  性别
    public String name;
    public int age;
    public boolean sex;

    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }
}

public class Dog extends Animal{

}

public class Cat extends Animal{

}

package com.by.test;

import com.by.entity.Cat;
import com.by.entity.Dog;

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "小黑";
        d.eat();
        d.sleep();
        Cat c = new Cat();
        c.eat();
        c.sleep();

    }
}

规则

1. 继承双方必须满足is a的关系结构
2. 一个子类只能有一个直接父类,一个父类可以拥有多个直接子类**(单继承)**
3. 一个子类在身为子类的同时也可以是其他类的父类
4. 子类可以拥有独有内容
5. 子类可以继承拥有所有父类所有可被继承的内容
6. 父类无法使用和访问子类的独有内容
7. 父类的私有内容子类无法直接使用
8. 父类的构造子类

子类内存结构

• 子类内存由父类内容和子类独有独有内容组成

父类封装

package com.by.entity;

/**
 动物类-父类
 */
public class Animal {
    //名字  年龄  性别
    private String name;
    private int age;
    private boolean sex;

    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 boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }

    private void method(){

    }
}

package com.by.test;

import com.by.entity.Dog;

public class Test {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.setName("小黑");
        System.out.println(d.getName());

    }

}

方法重写

• 子类对从父类继承过来的方法进行方法体的重新书写,简称方法重写, 也称为方法覆盖

规则

1. 建立在继承关系之上
2. 方法名、参数列表、返回值类型必须与父类保持一致
3. 访问修饰符与父类相同或更宽
4. 不允许抛出比父类更大或更多的异常

使用

1. 子类重写之后,优先执行子类重写内容
2. 父类的作用:
   • 解决子类之间的冗余问题
   • 强制约束子类必须拥有某些内容

访问修饰符

	本类	同包	非同包子类	非同包非子类
private-私有的	√
default-默认的	√	√
protected-受保护的	√	√	√
public-公共的,公开的	√	√	√	√

1. 只有default和public可以修饰类
2. default无法显式声明
3. 以上四个都可以修饰属性、方法、构造
4. 以上四个都不能修饰局部变量

有继承关系的对象的创建过程

1. 给父子类属性分配空间,赋默认值
2. 给父类属性赋初始值
3. 执行父类构造再次赋值
4. 给子类属性赋初始值
5. 执行子类构造再次赋值

总结: 先构建父类内容,才能构建子类内容

super关键字

• 代表父类对象

super()

作用为调用父类构造内容

使用

1. 必须写在子类构造方法有效代码第一行

2. 和this()无法同时显式存在

3. 通过实参列表决定调用的是哪个父类构造

4. 子类构造第一行默认存在无参的super()

子类有参构造写法:

public 子类类名(父类的形参列表,自己独有的属性){
 //先调用super()给父类声明属性赋值
 super(对应的父类的形参);
 //再this.给自己的独有属性赋值
 this.自己的属性名=属性名;
}

package com.by.entity;

/**
动物类-父类
*/
public class Animal {
 //名字  年龄  性别
 private String name;
 private int age;
 private boolean sex;

 public Animal(){}
 public Animal(String name, int age, boolean sex) {
     this.name = name;
     this.age = age;
     this.sex = sex;
 }
//省略getter\setter
}

public class Cat extends Animal{
 private String color;

 public Cat(){}
 public Cat(String name, int age, boolean sex,String color){
    //先调用super()给父类声明属性赋值
     super(name, age, sex);
     //再this.给自己的独有属性赋值
     this.color = color;
 }
}

super.

• 用来指明调用父类的属性或方法

super.属性名
super.方法名(实参)

public class Dog extends Animal{
        //从animal继承过来了名字,年龄,性别,吃饭(),睡觉()

    //重写父类方法
    public void eat(){
        //调用父类的eat方法
        super.eat();
        System.out.println("狗吃大骨头");
    }
}