[Java] 继承，隐藏，覆盖，重载，多态，抽象类，接口

1.子类

class SonClass extends ABC{...}

在子类定义后，子类中就可以直接隐式包含父类的成员变量和方法，而不用再写，这就是使用继承的优点。

子类包含父类的成员，不是子类和父类共享成员，而是子类和父类中都能各自开辟空间，产生性质相同但又独立的成员变量和方法。

1.1子类的构造方法

Java中，在子类创造对象时会执行子类的构造方法，因为子类继承自父类，所以在子类构造方法之前必须先执行父类的构造方法。

eg:

Public class Example{
 
　　public static void main(String[] args){
 
　　　　SonClass sc = new SonClass();
 
　　}
 
}
 
class SuperClass{
 
　　SuperClass(){
 
　　　　System.out.print("Supper");
 
　　}
 
}
 
class SonClass extends SuperClass{
 
　　SonClass(){
 
　　　　System.out.print("SubClass");
 
　　}
 
}

output:

Supper

SubClass

子类中构造方法是隐式调用父类构造方法。在程序中也可以显式调用父类构造方法。显示调用父类的构造方法是通过语句super()来完成。如果要调用父类的有参构造方法，则在super()的圆括号中加入所需的参数。

当在子类的构造方法中通过super()来调用父类的构造方法时，如果父类构造方法不带参数，则这样的显示调用可以省略，这种调用是由Java自动进行的。但是，如果父类中只有一个或多个有参构造方法，则程序找不到默认无参方法，默认调用会导致编译出错，必须显式调用

eg:

Public class Example{
 
　　public static void main(String[] args){
 
　　　　SonClass sc = new SonClass();
 
　　}
 
}
 
class SuperClass{
 
　　SuperClass(int a, int b){
 
　　　　System.out.print(a+b);
 
　　}
 
}
 
class SonClass extends SuperClass{
 
　　SonClass(){
 
　　　　System.out.print("SubClass");
 
　　}
 
}

应将程序修改为：

class SonClass extends SuperClass{
 
　　SonClass(){
 
　　　　super(1, 2);
 
　　　　System.out.print("SubClass");
 
　　}
 
}

2.多态

2.1隐藏

隐藏发生在子类与父类的成员变量发生冲突时。当子类中的成员变量与父类成员变量同名时，子类就会把父类的变量隐藏起来，这时该变量默认为子类的成员变量。如需强制使用父类成员变量，可以使用super关键字，如super.i等。

eg:

public class Example{
 
　　public static void main(String[] args){
 
　　　　SonClass sc = new SonClass();
 
　　　　System.out.println(sc.k);　　　　//子类本身定义的k
 
　　}
 
}
 
class SuperClass{
 
　　int k = 3;
 
}
 
class SonClass extends SuperClass{
 
　　int k = super.k * 2;　　　　　　　　//子类隐藏父类的成员k，调用时需要用super
 
}

 2.2重载与覆盖

当子类中有2个out方法，一个继承自父类，一个由自己创建。两个方法的参数不同，这种情况就属于重载

eg:

public class Example{
 
　　public static void main(String[] args){
 
　　　　SonClass sc = new SonClass();
 
　　　　sc.out();
 
　　　　sc.out(3);
 
　　}
 
}
 
class SuperClass{
 
　　public void out(){
 
　　　　System.out.print("SupperClass");
 
　　}
 
}
 
class SonClass extends SuperClass{
 
　　public void out(int i){
 
　　　　System.out.print("SupperClass" + i);
 
　　}
 
}

当子类中的成员方法与父类中的成员方法同名同参数时，出现覆盖，子类中的成员方法会屏蔽继承自父类的成员方法

eg:

public class Example{
 
　　public static void main(String[] args){
 
　　　　SonClass sc = new SonClass();
 
　　　　sc.out();　　　　　　　　//调用子类本身的方法，而不是父类的out 方法
 
　　}
 
}
 
class SuperClass{
 
　　public void out(){
 
　　　　System.out.print("SupperClass");
 
　　}
 
}
 
class SonClass extends SuperClass{
 
　　public void out(){
 
　　　　System.out.print("SonClass");
 
　　}
 
}

构造方法不能被覆盖，也不能继承。父类构造方法必须在子类构造方法中调用。如果想强制使用父类的构造方法，可以使用super 关键字。

若程序在需要显式调用父类构造方法二使用super()语句时，super()必须是构造方法中定义的第一条语句；若没有，则系统调用默认的super()语句。

eg:

public class Example{
 
　　public static void main(String[] args){
 
　　　　SonClass sc = new SonClass();
 
　　}
 
}
 
class SuperClass{
 
　　SuperClass(int i){
 
　　　　System.out.print("SupperClass");
 
　　}
 
}
 
class SonClass extends SuperClass{
 
　　SonClass(){
 
　　　　super(1);
 
　　　　System.out.print("SonClass");
 
　　}
 
}

3.抽象类

abstract 所修饰的类为抽象类。抽象类是只有定义而无法实现对象的类。抽象类无法产生对象。

abstract 所修饰的方法为抽象方法。抽象方法在形式上仅有方法的方法头部分，而没有方法体，方法头后面有分号，例如：

abstract void();

抽象类中可以没有抽象方法，但抽象方法所在的类必须是抽象类

在写大型程序时，一般先设计最顶层、最抽象的类和方法，然后逐步实现细节化的类和方法。这种设计方法由粗到细，容易分析和理解

 4.接口

我们在分析问题时，往往遇到有的类既要继承自一个父类，又需要继承自另一个父类。而Java不允许多重继承。为此，Java 中定义了一种特殊类型的类，称之为接口。接口实质上是一种特殊的抽象类。接口中的常量默认为public static final 类型

interface 接口名{

　　//类体：只能由静态常量或抽象方法组成

}

eg:

interface infa{
 
　　double PI = 3.14;
 
　　abstract void out();
 
}

子接口继承父接口是通过关键字extends 来声明的，

eg:

interface 子接口 extends 父接口1，父接口2，...

在Java 中，要让接口发挥其功能，需定义一个子类，实现并覆盖掉接口中的所有抽象方法，这称之为接口的实现。实现接口是通过关键字 implements 来声明的

eg:

class SonClass implements infa{
 
　　public void out(){
 
　　　　System.out.print(PI);
 
　　}
 
}