【JAVA语法】03Java-继承性-优快云博客

本文详细介绍了Java中继承的概念，包括继承的实现方式、限制条件、子类对象实例化的过程、方法重写规则以及super关键字的应用。此外，还探讨了重写与重载的区别、final关键字的作用、抽象类与接口的特性及其使用方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

继承的实现
继承的限制
子类对象的实例化
方法的重写
Super关键字
重写与重载的区别
final关键字
抽象类
接口

一、继承的实现

1.1 格式

    class 子类 extends 父类 {}
    class Student extends Person{}

二、继承的限制

2.1 Java中只允许单继承

    class Student extends People,Worker {}  
    //error,不允许多继承(一个人只允许有一个亲生父亲)

2.2 子类不能直接访问父类的私有成员
需要用get及set方法实现访问

三、子类对象的实例化

必须先调用父类中的构造方法，再调用子类构造方法

四、方法的重写

4.1 定义
子类定义了与父类同名的方法(方法名称、返回值类型和参数均完全相同)

class Parent{
    public void tell(){
        System.out.println("Parent");
    }
    
}
class Sub extends Parent{
    public void tell(){
        System.out.println("Sub");
    }
}
public class test {

    public static void main(String[] args) 
    {
        Sub subFunc = new Sub();
        subFunc.tell();
    }
        
    }
OUTPUT: Sub

4.2 重写限制
被子类重写的方法不能拥有比父类更加严格的访问权限 (一般和父类一样即可)

private(更严格)<default<public

五、Super关键字

5.1强行调用父类的方法

若想调用父类同名方法——Super关键字

class Parent{
    public void tell(){
        System.out.println("Parent");
    }
    
}
class Sub extends Parent{
    public void tell(){
        super.tell();
        System.out.println("Sub");
    }
}
public class test {

    public static void main(String[] args) 
    {
        Sub subFunc = new Sub();
        subFunc.tell();
    }
        
    }
OUTPUT: 
Parent
Sub

5.2 Super不一定在重写中使用，也可以表示那些方法是从父类继承而来的(提高代码可读性)

六、重写与重载区别

七、Final关键字

7.1 用途: 完结、最终
使用final声明的类不能被继承;
使用final声明的方法不能被重写;
使用final声明的属性不能被修改(常量)。

八、抽象类

8.1 概念
抽象类:包含一个抽象方法的类(不能直接实例化对象，需通过其子类实例化对象)
抽象方法:声明而未被实现的方法(使用abstract关键字声明)
重写：抽象类被子类继承，子类(如果不是抽象类)必须重写并实现抽象类中所有抽象方法

abstract class Abs{
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public abstract void say();//抽象方法
}
class SubAbs extends Abs{
    public void say(){
        
    }
}
public class test {

    public static void main(String[] args) 
    {
        SubAbs a = new SubAbs();
        a.setAge(20);
    }
        
    }

九、接口

9.1 概念
接口:特殊的类，全部由全局常量和公共抽象方法所组成
实现:接口必须通过子类实现(类比抽象方法)，使用关键字implements
多实现：接口可以多实现(多继承，区分"类"的单继承)

9.2 格式

    interface interfaceName{
    全局常量
    抽象方法
    }

9.3 一个子类可以同时继承抽象类和实现接口

    interface Inter1{
    public static final int AGE = 100;
    public abstract void tell();
}
interface Inter2{
    
    public abstract void say();
}

abstract class Abs1{
    public abstract void print();
}

class Sub extends Abs1 implements Inter1,Inter2{    //多继承(多实现)
    public void tell(){}
    public void say(){}
    public  void print(){                           //一个子类可以同时继承抽象类和实现接口
        
    }
}

9.4 接口的继承——相当于间接实现"类的多继承"

一个接口不能继承一个抽象类，但是可以通过extends关键字同时继承多个接口，实现接口的多继承

interface Inter1{
    public static final int AGE = 100;
    public abstract void tell();
}
interface Inter2{
    
    public abstract void say();
}

interface Inter3 extends Inter1,Inter2{
    
}

转载于:https://www.cnblogs.com/Neo007/p/6844278.html