JAVA基础8-继承性

继承性

概述

1. 继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力
2. 语法 class A extends B{}
   • A:子类，派生类，subclass
   • 父类，超类，基类，superclass
3. 一旦子类A继承父类B后，子类就获取了父类中的结构：属性和方法
4. 私有private属性和方法也会被继承，但由于作用域影响，也不能直接调

继承规定

1. 一个父类可以让多个子类继承
2. 一个子类只能有一个父类
3. 可以多层继承（当子类想继承多个父类时，通过这种方法可以实现）

//当子类C想继承A和B，通过多层继承实现
class B extends A{
    
    }
class C extends B{
    
    }
//这样C就具有A和B的属性和方法了

好处

1. 减少代码冗余
2. 便于功能扩展
3. 为多态性使用提供了前提

Object类

1. 所有的类都会直接或间接继承自java.lang.Object类
2. 所有的类也都会有Object中的功能

实例

1. Test2中代码

public class Test2 {
    
    
    String name;
    int age;
    public void eat(){
    
    
        System.out.println("吃饭");
        this.swim();
    }
    private void swim(){
    
    
        System.out.println("游泳");
    }
}

2. Test1中代码

public class Test1{
    
    
    public static void main(String[] args) {
    
    
        Test3 test3=new Test3();//这里直接实例化Test3
        test3.name="jack";//属性，方法来源于Test3继承Test2中的属性，方法
        System.out.println(test3.name);
        //jack
        test3.eat();
        //吃饭 游泳
        //游泳是私有对象，出了Test2后就不能使用了，但可以通过内部调用使用
    }
}
class Test3 extends Test2{
    
    
	//在Test3中没有任何代码
}

方法的重写

概述

1. 在子类中可以对父类中继承过来的方法进行改造，称为方法的重置，覆盖
2. 子类重写的方法的方法名与形参列表要与父类相同
3. 子类重写的权限修饰符范围可以大于或等于父类的权限修饰符
   注：但是不能重写private声明的方法
4. 子类重写异常throws方法小于或等于父类抛出异常类型
5. 重写时，子类和父类的static要相同，或者说非static，因为声明static的不是重写
6. 返回值类型

父类返回值类型	子类重写返回值类型
void	void
A类	A类或A的子类
基本数据类型	相同的基本数据类型

实例

1. 在Person中写入以下代码

public class Person {
    
    
    String name;
    int age;
    public void eat(){
    
    
        System.out.println("吃饭");
    }
    public Object info(){
    
    
        return null;
    }
}

2. 测试中写入已下代码

public class Test4 {
    
    
    public static void main(String[] args) {
    
    
        Student student1=new Student();
        System.out.println(student1.Professional);
        //math
        student1.eat();
        //大口吃饭
    }
}
class Student extends Person{
    
    
    String Professional ="math";
	//students自己的属性
	public void eat(){
    
    
        System.out.println("大口吃饭");
    }
    //重写eat方法
    public String info(){
    
    
        return "123";
    }
    //重写info方法，这里返回的类型改为了Object的子类String
}

super关键字

1. super理解为父类的，可以调用父类的属性，方法，构造器
2. 通过super.属性和super.方法显式调用，一般省略
3. 但如果子类和父类出现一样的属性和方法时，必须通过super关键字调用
4. super关键字与this关键字很像，一般情况下省略，当出现指代不明时，加入关键字区分
5. 实例：

public class Test4 {
    
    
    public static void main(String[] args) {
    
    
        Student student1=new Student();
        System.out.println(student1.Professional);
        student1.eat();
        //大口吃饭
        student1.eat2();
		//吃饭
    }
}
class Student extends Person{
    
    
    String Professional ="math";


    public void eat(){
    
    
        System.out.println("大口吃饭");
    }
    public String info(){
    
    
        return "123";
    }
    public void eat2(){
    
    
        super.eat();//这里通过super调用父类中的方法
    }
}

6. 可以通过super（形参列表）调用父类中声明的构造器
7. super（形参列表）必须声明在构造器首行，他与this（形参列表）只能二选一
8. 在构造器首行，没有显示声明this（形参列表）和super（新参列表），默认调用super（），也就是调用父类空构造器
9. 实例：

• Person中代码

public class Person {
    
    
    String name;
    int age;
    public Person(){
    
    
        System.out.println("我是父元素中的构造器");//super()默认调用输出
    }
    public Person(String name){
    
    
        this.name=name;//初始化name
    }
    public void eat(){
    
    
        System.out.println("吃饭");
    }
  
}

• Test中代码

public class Test4 {
    
    
    public static void main(String[] args) {
    
    
        Student student1=new Student();
        //我是父元素中的构造器  只要实例化，就会默认去调用父元素默认方法
        System.out.println(student1.Professional);
        //math
        student1.eat();
        //大口吃饭
        student1.eat2();
        //吃饭
        Student student2=new Student("jack");
        System.out.println(student2.name);//调用父类中的super(String name)初始化为jack
        //jack

    }
}
class Student extends Person{
    
    
    String Professional ="math";
    public Student(){
    
    
		//这里有个默认super(),当这里为空时
    }
    public Student(String name){
    
    
        super(name);
    }
    public void eat(){
    
    
        System.out.println("大口吃饭");
    }
 
    public void eat2(){
    
    
        super.eat();
    }
}

子类对象实例化过程

1. 通过子类构造器创建子类对象时，一定会直接或间接调用父类的构造器，父类也会调用父类的父类构造器，直到java.lang.Object中的空参构造器为止
2. 子类调用了父类构造器后，也就有了父类中属性和方法，在创建子类的对象，会在堆空间中加载所有父类中声明的方法