菜鸟教程 -- 学的不仅是技术,更是梦想!

Java 教程
(追記) (追記ここまで)

Java 继承

继承的概念

继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。

生活中的继承:

兔子和羊属于食草动物类,狮子和豹属于食肉动物类。

食草动物和食肉动物又是属于动物类。

所以继承需要符合的关系是:is-a,父类更通用,子类更具体。

虽然食草动物和食肉动物都是属于动物,但是两者的属性和行为上有差别,所以子类会具有父类的一般特性也会具有自身的特性。

类的继承格式

在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的,一般形式如下:

类的继承格式

class 父类 {}class 子类 extends 父类 {}

为什么需要继承

接下来我们通过实例来说明这个需求。

开发动物类,其中动物分别为企鹅以及老鼠,要求如下:

  • 企鹅:属性(姓名,id),方法(吃,睡,自我介绍)
  • 老鼠:属性(姓名,id),方法(吃,睡,自我介绍)

企鹅类:

publicclassPenguin{privateStringname; privateintid; publicPenguin(StringmyName, intmyid){name = myName; id = myid; }publicvoideat(){System.out.println(name+"正在吃"); }publicvoidsleep(){System.out.println(name+"正在睡"); }publicvoidintroduction(){System.out.println("大家好!我是" + id + "号" + name + "."); }}

老鼠类:

publicclassMouse{privateStringname; privateintid; publicMouse(StringmyName, intmyid){name = myName; id = myid; }publicvoideat(){System.out.println(name+"正在吃"); }publicvoidsleep(){System.out.println(name+"正在睡"); }publicvoidintroduction(){System.out.println("大家好!我是" + id + "号" + name + "."); }}

从这两段代码可以看出,代码存在重复,导致代码量大且臃肿,而且维护性不高(主要表现是后期需要修改的时候,需要修改很多的代码,容易出错)。要从根本上解决这两段代码的问题,就需要继承,将两段代码中相同的部分提取出来组成 一个父类:

公共父类:

publicclassAnimal{privateStringname; privateintid; publicAnimal(StringmyName, intmyid){name = myName; id = myid; }publicvoideat(){System.out.println(name+"正在吃"); }publicvoidsleep(){System.out.println(name+"正在睡"); }publicvoidintroduction(){System.out.println("大家好!我是" + id + "号" + name + "."); }}

这个Animal类就可以作为一个父类,然后企鹅类和老鼠类继承这个类之后,就具有父类当中的属性和方法,子类就不会存在重复的代码,维护性也提高,代码也更加简洁,提高代码的复用性(复用性主要是可以多次使用,不用再多次写同样的代码) 继承之后的代码:

企鹅类:

publicclassPenguinextendsAnimal{publicPenguin(StringmyName, intmyid){super(myName, myid); }}

老鼠类:

publicclassMouseextendsAnimal{publicMouse(StringmyName, intmyid){super(myName, myid); }}

继承类型

需要注意的是 Java 不支持多继承,但支持多重继承。

继承的特性

  • 子类拥有父类非 private 的属性、方法。

  • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

  • 子类可以用自己的方式实现父类的方法。

  • Java 的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如 B 类继承 A 类,C 类继承 B 类,所以按照关系就是 B 类是 C 类的父类,A 类是 B 类的父类,这是 Java 继承区别于 C++ 继承的一个特性。

  • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系越紧密,代码独立性越差)。

继承关键字

继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承 Object(这个类在 java.lang 包中,所以不需要 import)祖先类。

extends关键字

在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。

extends 关键字

publicclassAnimal{privateStringname; privateintid; publicAnimal(StringmyName, intmyid){//初始化属性值}publicvoideat(){//吃东西方法的具体实现 } publicvoidsleep(){//睡觉方法的具体实现 } }publicclassPenguinextendsAnimal{}

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

implements 关键字

publicinterfaceA{publicvoideat(); publicvoidsleep(); }publicinterfaceB{publicvoidshow(); }publicclassCimplementsA,B{}

super 与 this 关键字

super 关键字:我们可以通过 super 关键字来实现对父类成员的访问,用来引用当前对象的父类。

this 关键字:指向自己的引用,引用当前对象,即它所在的方法或构造函数所属的对象实例。。

实例

classAnimal{voideat(){System.out.println("animal : eat"); }}classDogextendsAnimal{voideat(){System.out.println("dog : eat"); }voideatTest(){this.eat(); // this 调用自己的方法super.eat(); // super 调用父类方法}}publicclassTest{publicstaticvoidmain(String[]args){Animala = newAnimal(); a.eat(); Dogd = newDog(); d.eatTest(); }}

输出结果为:

animal : eat
dog : eat
animal : eat

final 关键字

final 可以用来修饰变量(包括类属性、对象属性、局部变量和形参)、方法(包括类方法和对象方法)和类。

final 含义为 "最终的"。

使用 final 关键字声明类,就是把类定义定义为最终类,不能被继承,或者用于修饰方法,该方法不能被子类重写:

  • 声明类:

    final class 类名 {//类体}

  • 声明方法:

    修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注: final 定义的类,其中的属性、方法不是 final 的。

构造器

子类是不继承父类的构造器(构造方法或者构造函数)的,它只是调用(隐式或显式)。如果父类的构造器带有参数,则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数,则在子类的构造器中不需要使用 super 关键字调用父类构造器,系统会自动调用父类的无参构造器。

实例

classSuperClass{privateintn; // 无参数构造器publicSuperClass(){System.out.println("SuperClass()"); }// 带参数构造器publicSuperClass(intn){System.out.println("SuperClass(int n)"); this.n = n; }}// SubClass 类继承classSubClassextendsSuperClass{privateintn; // 无参数构造器,自动调用父类的无参数构造器publicSubClass(){System.out.println("SubClass()"); }// 带参数构造器,调用父类中带有参数的构造器publicSubClass(intn){super(300); System.out.println("SubClass(int n): " + n); this.n = n; }}// SubClass2 类继承classSubClass2extendsSuperClass{privateintn; // 无参数构造器,调用父类中带有参数的构造器publicSubClass2(){super(300); System.out.println("SubClass2()"); }// 带参数构造器,自动调用父类的无参数构造器publicSubClass2(intn){System.out.println("SubClass2(int n): " + n); this.n = n; }}publicclassTestSuperSub{publicstaticvoidmain(String[]args){System.out.println("------SubClass 类继承------"); SubClasssc1 = newSubClass(); SubClasssc2 = newSubClass(100); System.out.println("------SubClass2 类继承------"); SubClass2sc3 = newSubClass2(); SubClass2sc4 = newSubClass2(200); }}

输出结果为:

------SubClass 类继承------
SuperClass()
SubClass()
SuperClass(int n)
SubClass(int n): 100
------SubClass2 类继承------
SuperClass(int n)
SubClass2()
SuperClass()
SubClass2(int n): 200
AI 思考中...

11 篇笔记 写笔记

  1. #0
    143

    java 中若要在子类调用父类的方法,需使用关键字super。

    实例

    class Animal{
 void go(){
 System.out.println("animal go");
 }
}
class Dog extends Animal{
 void go(){
 //调用父类方法
 super.go();
 }
}
//驱动函数
public static void main(String[] args){
 Dog dog=new Dog();
 dog.go();
}

    输出结果:

    animal go
    10年前 (2016年12月31日)
  2. #0

    我是小菜鸟

    824***[email protected]

    190

    面向对象编程——继承和多态

    //---引用我课堂老师的讲义(詹老师)

    1、为什么使用继承

    从已有的类派生出新的类,称为继承。

    在不同的类中也可能会有共同的特征和动作,可以把这些共同的特征和动作放在一个类中,让其它类共享。

    因此可以定义一个通用类,然后将其扩展为其它多个特定类,这些特定类继承通用类中的特征和动作。

    继承是 Java 中实现软件重用的重要手段,避免重复,易于维护,易于理解。

    2、父类和子类

    如果类 B 从类 A 派生,或者说类 B 扩展自类 A,或者说类 B 继承类 A,

    则称类 A 为"父类",也称为超类、基类;

    称类 B 为"子类",也称为次类、扩展类、派生类。

    子类从它的父类中继承可访问的数据域和方法,也可以添加新的数据域和新的方法。

    定义继承的语法:

    修饰符 class 子类名 extends 父类名

    例如:Shape 类是父类,其子类可以有 Circle 类、Rectangle 类、Triangle 类,等等。

    继承的注意点:

    • 子类不是父类的子集,子类一般比父类包含更多的数据域和方法。
    • 父类中的 private 数据域在子类中是不可见的,因此在子类中不能直接使用它们。
    • 继承是为"是一个"的关系建模的,父类和其子类间必须存在"是一个"的关系,否则不能用继承。
      但也并不是所有"是一个"的关系都应该用继承。例如,正方形是一个矩形,但不能让 Square 类来继承 Rectangle 类,因为正方形不能从矩形扩展得到任何东西。正确的继承关系是 Square 类继承 Shape 类
    • Java 只允许单一继承(即一个子类只能有一个直接父类),C++ 可以多继承(即一个子类有多个直接父类)。

    3、super 关键字

    super 表示使用它的类的父类。super 可用于:

    • 调用父类的构造方法;
    • 调用父类的方法(子类覆盖了父类的方法时);
    • 访问父类的数据域(可以这样用但没有必要这样用)。

    调用父类的构造方法语法:

    super(); 
或 
super(参数列表);

    注意:super 语句必须是子类构造方法的第一条语句。不能在子类中使用父类构造方法名来调用父类构造方法。 父类的构造方法不被子类继承。调用父类的构造方法的唯一途径是使用 super 关键字,如果子类中没显式调用,则编译器自动将 super(); 作为子类构造方法的第一条语句。这会形成一个构造方法链。

    静态方法中不能使用 super 关键字。

    调用父类的方法语法: 

    super.方法名(参数列表);

    如果是继承的方法,是没有必要使用 super 来调用,直接即可调用。但如果子类覆盖或重写了父类的方法,则只有使用 super 才能在子类中调用父类中的被重写的方法。

    4、this 关键字

    this 关键字表示当前对象。可用于:

    • 调用当前类的构造方法,并且必须是方法的第一条语句。如:this(); 调用默认构造方法。this(参数); 调用带参构造方法。
    • 限定当前对象的数据域变量。一般用于方法内的局部变量与对象的数据域变量同名的情况。如 this.num = num。this.num 表示当前对象的数据域变量 num,而 num 表示方法中的局部变量。

    我是小菜鸟

    824***[email protected]

    9年前 (2017年04月17日)
  3. #0

    Mr.先生

    yu5***[email protected]

    105

    final 的作用随着所修饰的类型而不同

    1、final 修饰类中的属性或者变量

    无论属性是基本类型还是引用类型,final 所起的作用都是变量里面存放的"值"不能变。

    这个值,对于基本类型来说,变量里面放的就是实实在在的值,如 1,"abc" 等。

    而引用类型变量里面放的是个地址,所以用 final 修饰引用类型变量指的是它里面的地址不能变,并不是说这个地址所指向的对象或数组的内容不可以变,这个一定要注意。

    例如:类中有一个属性是 final Person p=new Person("name"); 那么你不能对 p 进行重新赋值,但是可以改变 p 里面属性的值 p.setName('newName');

    final 修饰属性,声明变量时可以不赋值,而且一旦赋值就不能被修改了。对 final 属性可以在三个地方赋值:声明时、初始化块中、构造方法中,总之一定要赋值。

    2、final修饰类中的方法

    作用:可以被继承,但继承后不能被重写。

    3、final修饰类

    作用:类不可以被继承。

    Mr.先生

    yu5***[email protected]

    9年前 (2017年10月11日)
  4. #0

    WaterHole

    710***[email protected]

    86

    java文件被编译成class文件时,在子类的所有构造函数中的第一行(第一个语句)会默认自动添加 super() 语句,在执行子类的构造函数前,总是会先执行父类中的构造函数。

    在编写代码要注意:

    • 1.如果父类中不含 默认构造函数(就是 类名() ),那么子类中的super()语句就会执行失败,系统就会报错。一般 默认构造函数 编译时会自动添加,但如果类中已经有一个构造函数时,就不会添加。
    • 2.执行父类构造函数的语句只能放在函数内语句的首句,不然会报错。

    在继承关系中,在调用函数(方法)或者类中的成员变量时,JVM(JAVA虚拟机)会先检测当前的类(也就是子类)是否含有该函数或者成员变量,如果有,就执行子类中的,如果没有才会执行父类中的。如下:

    public class Start
{
 public static void main(String[] args)
 {
 Cat cat=new Cat("Jack","黑色");
 cat.eat();
 cat.run();
 cat.sleep();
 }
}
class Animal 
{
 String name;
 
 public Animal(){}//必须要写这个构造函数,不然Cat类的代码会出错
 
 public Animal(String name)
 {
 this.name=name;
 }
 
 void eat()
 {
 System.out.println(name+"正在吃");
 }
 
 void run()
 {
 System.out.println(name+"正在奔跑");
 }
 
 void sleep()
 {
 System.out.println(name+"正在睡觉");
 }
}
class Cat extends Animal
{
 String color;
 public Cat(String name,String color)
 {
 this.name=name;
 this.color=color;
 }
 void eat()
 {
 System.out.println(color+"的"+name+"正在吃鱼");
 }
}

    运行结果如下:

    黑色的Jack正在吃鱼
Jack正在奔跑
Jack正在睡觉

    当子类出现与父类一样的函数时,这个被称为 重写 也叫 覆盖

    Object类是所有类的直接父类或间接父类,也就是说是所有类的根父类,这个可以运用于参数的传递

    如下:

    public class Start
{
 public static void main(String[] args)
 {
 A a=new A();
 B b=new B();
 C c=new C();
 D d=new D();
 speak(a);
 speak(b);
 speak(c);
 speak(d);
 }
// instanceof 关键字是用于比较类与类是否相同,相同返回true,不同返回false
//当你不清楚你需要的参数是什么类型的,可以用Object来代替,Object可以代替任何类
 static void speak(Object obj)
 {
 if(obj instanceof A)//意思是:如果参数是 A 类,那么就执行一下语句
 {
 A aobj=(A)obj;//这里是向下转换,需要强制转换
 aobj.axx();
 }
 else if(obj instanceof B)
 {
 B bobj=(B)obj;
 bobj.bxx();
 }
 else if(obj instanceof C)
 {
 C cobj=(C)obj;
 cobj.cxx();
 }
 }
}
//这里举了四个类,他们的函数都不同,但都是 Object 类的子类
class A
{
 void axx()
 {
 System.out.println("Good morning!");
 System.out.println("This is A");
 }
}
class B
{
 void bxx()
 {
 System.out.println("Holle!");
 System.out.println("This is B"); 
 }
}
class C
{
 void cxx()
 {
 System.out.println("Look!");
 System.out.println("This is C"); 
 }
}
class D
{
 void dxx()
 {
 System.out.println("Oh!Bad!");
 System.out.println("This is D"); 
 }
}

    运行结果:

    Good morning!
This is A
Holle!
This is B
Look!
This is C

    WaterHole

    710***[email protected]

    9年前 (2018年01月06日)
  5. #0

    wyk123

    101***[email protected]

    76
    • 子类的所有构造方法内部, 第一行会(隐式)自动先调用父类的无参构造函数super();
    • 如果子类构造方法第一行显式调用了父类构造方法,系统就不再调用无参的super()了。

    实例:

    class Base {
 public Base() {
 System.out.println("Base--默认构造方法");
 }
 
 public Base(int c){
 System.out.println("Base--有参构造方法--" + c);
 }
}
public class Derived extends Base {
 public Derived() {
 // super(); //系统会自动隐式先调用父类的无参构造函数 super(); //必须是第一行,否则不能编译 
 System.out.println("Derived--默认构造方法");
 }
 
 public Derived(int c) {
 // super(); //系统会自动隐式先调用父类的无参构造函数 super(); //必须是第一行,否则不能编译
 System.out.println("Derived--有参构造方法" + c);
 }
 
 public Derived(int a, int b) {
 super(a); //如果子类构造方法第一行显式调用了父类构造方法,系统就不再调用无参的super()了。
 System.out.println("Derived--有参构造方法--" + b);
 }
 
 public static void main(String[] args) {
 System.out.println("============子类无参============");
 Derived no = new Derived();
 System.out.println("============子类有参============");
 Derived have = new Derived(33);
 System.out.println("============子类有参============");
 Derived have2 = new Derived(33, 55);
 }
}

    运行结果如下:

    ============子类无参============
Base--默认构造方法
Derived--默认构造方法
============子类有参============
Base--默认构造方法
Derived--有参构造方法33
============子类有参============
Base--有参构造方法--33
Derived--有参构造方法--55

    注意:如果父类没有无参构造函数,创建子类时,不能编译,除非在构造函数代码体中的第一行显式调用父类有参构造函数。

    wyk123

    101***[email protected]

    8年前 (2018年06月02日)
  6. #0

    芳小酱

    fan***[email protected]

    35

    子类不能直接继承父类中的 private 属性和方法。

    /**建立一个公共动物父类*/
public class Animal {
 private String name;
 private int id;
 /*由于name和id都是私有的,所以子类不能直接继承,
 需要通过有参构造函数进行继承*/
 public Animal(String myname,int myid) {
 name = myname;
 id = myid;
 }
 public void eat() {
 System.out.println(name+"正在吃");
 }
 public void sleep() {
 System.out.println(name+"正在睡");
 }
 public void introduction() {
 System.out.println("大家好!我是" +id+"号"+name +".");
 }
}

    子类 Penguin 需要通过关键字 super 进行声明

    public class Penguin extends Animal {
 public Penguin(String myname,int myid) {
 super(myname,myid); // 声明继承父类中的两个属性
 }
}

    具体通过有参构造函数进行继承。

    public class PenguinQQ {
 public static void main(String[] args) {
 // TODO Auto-generated method stub
 Penguin QQ = new Penguin("小冰",10086);
 //调用一个有参构造方法
 QQ.eat();
 QQ.sleep();
 QQ.introduction();
 }
}

    运行结果:

    小冰正在吃
小冰正在睡
大家好!我是10086号小冰.
    芳小酱

    芳小酱

    fan***[email protected]

    8年前 (2018年06月27日)
  7. #0

    nanjidifang

    322***[email protected]

    91

    Java 转型问题其实并不复杂,只要记住一句话:父类引用指向子类对象。

    什么叫父类引用指向子类对象,且听我慢慢道来。

    从 2 个名词开始说起:向上转型(upcasting) 、向下转型(downcasting)。

    举个例子:有2个类,Father 是父类,Son 类继承自 Father。

    Father f1 = new Son(); // 这就叫 upcasting (向上转型)
// 现在 f1 引用指向一个Son对象
Son s1 = (Son)f1; // 这就叫 downcasting (向下转型)
// 现在f1 还是指向 Son对象

    第2个例子:

    Father f2 = new Father();
Son s2 = (Son)f2; // 出错,子类引用不能指向父类对象

    你或许会问,第1个例子中:Son s1 = (Son)f1; 为什么是正确的呢。

    很简单因为 f1 指向一个子类对象,Father f1 = new Son(); 子类 s1 引用当然可以指向子类对象了。

    而 f2 被传给了一个 Father 对象,Father f2 = new Father(); 子类 s1 引用不能指向父类对象。

    总结:

    1、父类引用指向子类对象,而子类引用不能指向父类对象。

    2、把子类对象直接赋给父类引用叫upcasting向上转型,向上转型不用强制转换吗,如:

    Father f1 = new Son();

    3、把指向子类对象的父类引用赋给子类引用叫向下转型(downcasting),要强制转换,如:

    f1 就是一个指向子类对象的父类引用。把f1赋给子类引用 s1 即 Son s1 = (Son)f1;

    其中 f1 前面的(Son)必须加上,进行强制转换。

    更多内容请查看:Java 转型问题

    nanjidifang

    322***[email protected]

    8年前 (2018年08月01日)
  8. #0

    ToToXie

    wdt***@163.com

    参考地址

    56

    对理解继承来说,最重要的事情是,知道哪些东西被继承了,或者说,子类从父类那里得到了什么。答案是:所有的东西,所有的父类的成员,包括变量和方法,都成为了子类的成员,除了构造方法。构造方法是父类所独有的,因为它们的名字就是类的名字,所以父类的构造方法在子类中不存在。除此之外,子类继承得到了父类所有的成员。

    但是得到不等于可以随便使用。每个成员有不同的访问属性,子类继承得到了父类所有的成员,但是不同的访问属性使得子类在使用这些成员时有所不同:有些父类的成员直接成为子类的对外的界面,有些则被深深地隐藏起来,即使子类自己也不能直接访问。下表列出了不同访问属性的父类成员在子类中的访问属性:

    父类成员访问属性 在父类中的含义 在子类中的含义
    public 对所有人开放 对所有人开放
    protected 只有包内其它类、自己和子类可以访问 只有包内其它类、自己和子类可以访问
    缺省 只有包内其它类可以访问 如果子类与父类在同一个包内:只有包内其它类可以访问,否则:相当于private,不能访问
    private 只有自己可以访问 不能访问

    public的成员直接成为子类的public的成员,protected的成员也直接成为子类的protected的成员。Java的protected的意思是包内和子类可访问,所以它比缺省的访问属性要宽一些。而对于父类的缺省的未定义访问属性的成员来说,他们是在父类所在的包内可见,如果子类不属于父类的包,那么在子类里面,这些缺省属性的成员和private的成员是一样的:不可见。父类的private的成员在子类里仍然是存在的,只是子类中不能直接访问。我们不可以在子类中重新定义继承得到的成员的访问属性。如果我们试图重新定义一个在父类中已经存在的成员变量,那么我们是在定义一个与父类的成员变量完全无关的变量,在子类中我们可以访问这个定义在子类中的变量,在父类的方法中访问父类的那个。尽管它们同名但是互不影响。

    在构造一个子类的对象时,父类的构造方法也是会被调用的,而且父类的构造方法在子类的构造方法之前被调用。在程序运行过程中,子类对象的一部分空间存放的是父类对象。因为子类从父类得到继承,在子类对象初始化过程中可能会使用到父类的成员。所以父类的空间正是要先被初始化的,然后子类的空间才得到初始化。在这个过程中,如果父类的构造方法需要参数,如何传递参数就很重要了。

    ToToXie

    wdt***@163.com

    参考地址

    8年前 (2018年10月13日)
  9. #0

    战神阿伦第一

    116***[email protected]

    46

    构造器下面的实例,初学者可能迷惑的地方:

    输出结果为:

    SuperClass(int n)
SubClass
SuperClass()
SubClass(int n):200

    首先读一波程序,从主类下的主函数开始,对子类分别实例化了两个对象,sc 对象未赋值,sc2 赋值为 200。

    然后从上到下读一波程序,一个SuperClass父类下有一个成员变量,两个构造函数(一个不带参,一个带参);接下来是一个SubClass子类,子类继承父类,有一个成员变量,但要注意的是父类中的成员变量是私有的,所以子类中的私有成员变量并不是从父类继承过来的,而是重写了一遍。两个构造函数(一个不带参,一个带参);

    理解 this 和 super,this 指的是引用当前对象下东西,super 则是引用当前对象的父类。

    1. 第一个输出:SubClass 类实例化对象 sc 未赋值,故访问 SubClass 类下的第一个无参构造函数,super(300) 的含义是访问父类中的有参构造函数,故打印输出 SuperClass(int n)
    2. 第二个输出:还是接着第一个输出后面,程序继续往下执行,打印输出 SubClass,这就是第二个输出结果,此时对象 sc 结束对 SubClass 类下的第一个无参构造函数的访问
    3. 第三个输出:SubClass 类实例化对象 sc 赋值为 200,故访问 SubClass 类下的第二个有参构造函数,子类构造函数中第一条语句如未写带参或不带参的super(),则默认为 super(),所以访问父类中的无参构造函数,故打印输出 SuperClass()
    4. 第四个输出:还是接着第三个输出后,程序继续往下执行,由于传递给子类下的有参构造函数 int n=200,所以打印输出 SubClass(int n):200。

    战神阿伦第一

    116***[email protected]

    8年前 (2018年11月01日)
  10. #0
    299
    8年前 (2018年11月22日)
  11. #0

    关于成员内部类的继承问题。一般来说,内部类是很少用来作为继承用的。但是当用来继承的话,要注意两点:

    • 1)成员内部类的引用方式必须为 Outter.Inner。
    • 2)构造器中必须有指向外部类对象的引用,并通过这个引用调用super()。这段代码摘自《Java编程思想》
    class WithInner {
 class Inner{
 
 }
}
class InheritInner extends WithInner.Inner {
 
 // InheritInner() 是不能通过编译的,一定要加上形参
 InheritInner(WithInner wi) {
 wi.super(); //必须有这句调用
 }
 
 public static void main(String[] args) {
 WithInner wi = new WithInner();
 InheritInner obj = new InheritInner(wi);
 }
}
    5年前 (2021年01月31日)

点我分享笔记

  • 昵称 (必填)
  • 邮箱 (必填)
  • 引用地址

AltStyle によって変換されたページ (->オリジナル) /