extends怎么用，Java中extends用法详解
一、 简介
从面向对象编程设计特征中已知：继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。
在Java之中，如果要实现继承的关系，可以使用如下的语法：
class 子类 extends 父类 {}二、 default类的继承
子类又被称为派生类；父类又被称为超类（Super Class）. 来个示例：
public class Inherit {
public static void main(String[] args) {
// 实例化子类 Pupil
Pupil pupil = new Pupil();
// 赋值
pupil.setAge(18);
pupil.setName("李四");
// 打印输出
pupil.show();
}
}
class Human { // default类
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void show() {
System.out.println("name="+name+", age="+age);
}
}
class Pupil extends Human {
/* 继承Human；不作任何操作
* 类似Python中的：
* class A(B):
* pass
*/
}
通过示例可以看出，子类不进行任何操作，而在主类中所使用的全部操作都是由Person类定义的，这证明：子类即使不扩充父类，也能维持父类的操作。这和Python的继承如出一辙！
同样想要扩充父类功能，也很简单：
public class Inherit {
public static void main(String[] args) {
// 实例化子类 Pupil
Pupil pupil = new Pupil();
// 赋值
pupil.setAge(18);
pupil.setName("李四");
pupil.setSex("男");
// 打印输出
pupil.show();
}
}
class Human {
private String name;
private int age;
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void show() {
System.out.println("name="+name+", age="+age);
}
}
class Pupil extends Human {
private String sex;
public void setSex(String _sex) {
this.sex = _sex;
System.out.println("sex="+ sex);
}
}
不同于Python的继承，Java中一个子类只能够继承一个父类，存在单继承局限【即：Java之中只允许多层继承，不允许多重继承】。
class A {}
class B {}
class C extends A,B {} // 一个子类继承了两个父类
这种做法也称多重继承，在java语法中是不支持的；但可以换个思路：
class A {}
class B extends A {}
class C extends B {}
相当于B类继承了A类的全部方法，而C类又继承了A和B类的方法，这种操作称为多层继承。
此外，java在一个子类继承的时候，实际上会继承父类之中的所有操作（属性、方法），但是需要注意的是，对于所有的非私有（no private）操作属于显式继承（可以直接利用对象操作），而所有的私有操作属于隐式继承（间接完成）。
public class Inherit {
public static void main(String[] args) {
// 实例化子类 Pupil
Pupil pupil = new Pupil();
pupil.show();
}
}
class Human {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
class Pupil extends Human {
public void show() {
// System.out.println("name="+name); // 直接访问报错: private String name
setName("张三"); // 通过setter方法赋值"张三"
System.out.println(getName()); // 通过getter方法获取信息
}
}
此时对于A类之中的msg这个私有属性发现无法直接进行访问，但是却发现可以通过setter、getter方法间接的进行操作。
最后在继承关系之中，如果要实例化子类对象，会默认先调用父类构造，为父类之中的属性初始化，之后再调用子类构造，为子类之中的属性初始化。
即：默认情况下，子类会找到父类之中的无参构造方法。
public class Inherit {
public static void main(String[] args) {
// 实例化子类 Pupil
Pupil pupil = new Pupil();
}
}
class Human {
private String name;
Human() {
System.out.println("=====老子的无参数构造函数=====");
}
public void setName(String name) {
this.name = name;
}
}
class Pupil extends Human {
Pupil() {
System.out.println("=====小子的无参数构造函数=====");
}
}
// 输出：
// =====老子的无构造函数=====
// =====小子的无构造函数=====
这个时候虽然实例化的是子类对象，但是发现它会默认先执行父类构造，调用父类的无参数构造函数执行，而后再实例化子类对象，调用子类的无参数构造函数。那么，这个时候，对于子类的构造函数而言，就相当于隐含了一个super()的形式:
class Pupil extends Human {
Pupil() {
super(); // 调用父类构造——一般情况下都隐藏了
System.out.println("=====小子的无构造函数=====");
}
}
现在默认调用的是无参构造，而如果这个时候父类没有无参构造，则子类必须通过super()调用指定参数的构造方法:
public class Inherit {
public static void main(String[] args) {
// 实例化子类 Pupil
Pupil pupil = new Pupil();
pupil.show();
}
}
class Human {
private String name;
Human(String name) {
this.name = name;
}
public void show() {
System.out.println(name);
}
}
class Pupil extends Human {
Pupil() {
super("张三"); // 调用父类构造
}
}
也就是说：在任何的情况下，子类都逃不出父类构造的调用，且使用super调用父类构造时，一定要放在构造方法的首行上。
三、 public类的继承
public class PublicInherit {
String name = "public";
static int age = 18;
}
class subPublic extends PublicInherit {
subPublic(){
System.out.println(name);
System.out.println(age);
}
}
class Run {
public static void main(String[] args) {
subPublic sub = new subPublic();
}
}
运行后发现和default一致，不再赘述
四、 final类的继承
可以看到，final 类不能被继承，也就没有类能够继承 final 类的任何特性
五、 abstract类的继承
abstract class Person { //抽象类，注意不能同时被 abstract 和 final 修饰
String name = "法外狂徒";
}
class Human extends Person{
Human(){
System.out.println(name);
}
}
class AbstractInherit{
public static void main(String[] args) {
Human hum = new Human();
}
}
运行后发现和default一致，能够被继承
总结
在类的声明中，通过关键字extends来创建一个类的子类
extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法
extends不能继承final类，且只允许多层继承，不允许多重继承
在继承时，private属性或方法不会涉及到重载和覆写问题
在进行覆写时，若父类的方法使用了default权限定义，那么子类定义(覆写)该方法时只能使用public或default定义；若父类的方法使用了public权限定义，那么子类定义(覆写)该方法时只能使用public定义
本文地址：IT百科频道 https://www.hkm168.com/tags/930656.html，易企推百科一个免费的知识分享平台，本站部分文章来网络分享，本着互联网分享的精神，如有涉及到您的权益，请联系我们删除，谢谢！
相关阅读
