Java中继承

1.  继承：子类继承父类，可以扩展已有类的功能。

extends关键字：称为扩展，子类扩展一个类，子类有时候也称为派生类。

举例:

public class ExtDemo {

public static void main(String[] args) {

Student stu = new Student();

stu.setName("nishuibaichuan");

stu.setAge(18);

System.out.println("姓名：" + stu.getName() + ",年纪：" + stu.getAge() );

}

}

class Persons{

private String name;

private int age;

public Persons(){

System.out.println("nishuibaichuan");

}

public Persons(int age){

System.out.println("nishuibaichuan2");

}

public void setName(String name){

this.name = name;

}

public void setAge(int age){

this.age = age;

}

public String getName(){

return this.name;

}

public int getAge(){

return age;

}

}

class Student extends Persons{

}

2.  继承的限制

在java中只允许单继承，不能使用多重继承，即：一个子类只能继承一个父类。但是允许多层继承，即：一个子类可以有一个父类，一个父类还可以有一个父类。

单继承：一个孩子只能有一个父亲。

class A{

}

class B{

}

class C extends A,B{

}

以上代码错误，不能多重继承，但是允许多层继承。

如下：

    class A{

   }

class B extends A{

  }

class C extends B{

 }

以上代码正确，为多层继承。

3.  访问限制：

在使用继承的时候注意：子类是不能直接访问父类中的私有成员，但是子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员。

举例：

public class ExtDemo04 {

public static void main(String[] args) {

System.out.print("");

}

}

class Personer{

private String name;

private int age;

public void setName(String name){

this.name = name;

}

public void setAge(int age){

this.age = age;

}

public String getName(){

return this.name;

}

public int getAge(){

return this.age;

}

}

class Students extends Personer{

private String school;

public void setScool(String school){

this.school = school;

}

public String getSchool(){

return this.school;

}

public void fun1(){

System.out.println("姓名：" + name);

System.out.println("年纪：" + age);

}

}

以上的代码是错误的，错误发生在Students的fun()中他调用了父类中的私有属性！如果要用到的话，那么就通过setter()和getter()方法！

举例：

public class ExtDemo04 {

public static void main(String[] args) {

Students stu = new Students();

stu.fun();

}

}

class Personer{

private String name;

private int age;

public void setName(String name){

this.name = name;

}

public void setAge(int age){

this.age = age;

}

public String getName(){

return this.name;

}

public int getAge(){

return this.age;

}

}

class Students extends Personer{
  private String school;

public void setScool(String school){

this.school = school;

}

public String getSchool(){

return this.school;

}

public void fun(){

//这些输出System和调用这些方法都是在子类的方法中实现的

setName("nishuibaichuan");

System.out.println("" + getName());

 }

}

运行结果：nishuibaichuan

4.  掌握子类对象的实例化过程

在继承的操作中，对于子类对象的实例化也是有要求的：“子类对象在实例化之前必须首先调用父类中的构造方法之后再调用子类自己的构造方法”。

举例：

package Nisbc.club.csdn;

public class ExtDemo {

public static void main(String[] args) {

Student stu = new Student();

stu.setName("nishuibaichuan");

stu.setAge(18);

// stu.setSchool("齐大");

System.out.println("姓名：" + stu.getName() + ",年纪：" + stu.getAge() );

}

}

class Persons{

private String name;

private int age;

public Persons(){

System.out.println("父类构造方法：nishuibaichuan");

}

public Persons(int age){

System.out.println("nishuibaichuan2");

}

public void setName(String name){

this.name = name;

}

public void setAge(int age){

this.age = age;

}

public String getName(){

return this.name;

}

public int getAge(){

return age;

}

}

class Student extends Persons{

public Student(){

System.out.println("子类构造方法：NISHUIBAICHUAN");

// super();隐含的语句

       }

     private String school;

     public void setSchool(String school){

     this.school = school;

             }

public String getSchool(){

return this.school;

}

}

运行结果：

父类构造方法：nishuibaichuan
子类构造方法：NISHUIBAICHUAN
姓名：nishuibaichuan,年纪：18

由以上代码可知:子类不能继承父类的构造方法，而是子类默认的构造方法中的隐含了一个super()语句，从而实现了调用父类的无参构造方法的过程。有时候也将父类称为超类。

5. 方法的覆写（也称为重写）

在继承的关系中也存在着方法覆写的概念，所谓的覆写就是指子类定义了和父类中同名的方法，但是在方法覆写时，必须考虑到权限，即：子类覆写的方法不能拥有比父类方法更加严格的访问权限！

注：关于访问权限，实际上读者都知道有四种：

private(最小的访问权限) ,default(默认的访问权限)  ,protected  (次大的访问权限),  public (最大的访问权限)，这四种访问权限的大小关系为：private  <  default <  protected < public .

所以，如果在父类中使用public 定义的方法，子类的访问权限必须是public， 否则程序则无法编译 。

举例：

public class ExtDemo01 {

public static void main(String[] args) {

Son son = new Son();

son.fun();

}

}

class Father{

protected void fun(){

System.out.println("父类hello");

}

}

class Son extends Father{

public void fun(){//子类重写父类方法

System.out.println("子类hello");

}

}

运行结果： 子类hello

总结：由运行结果可知,如果子类覆写父类的方法，那么就会运行子类的方法，如果没有 覆写的话，则调用继承来的父类中的方法。

举例：

public class ExtDemo01 {

public static void main(String[] args) {

Son son = new Son();

son.fun();

}

}

class Father{

protected void fun(){

System.out.println("父类hello");

}

}

class Son extends Father{

public void fun1(){

System.out.println("子类hello");

}

}

运行结果：父类hello

6.从之前的正确操作中可以发现，如果现在子类将父类中的方法覆写了，调用的时候肯定是调用被覆写过的方法，那么如果现在非要调用父类的方法该怎么办啊？

我们可以通过super()关键字完成功能，super关键字可以从子类访问父类中的内容，如果要访问被覆写过的方法：super.方法();

举例：

public class ExtDemo01 {

public static void main(String[] args) {

Son son = new Son();

son.fun();

}

}

class Father{

void fun(){

System.out.println("父类hello");

}

}

class Son extends Father{

public void fun(){//子类重写父类方法

super.fun();

System.out.println("子类hello");

}

}

如果要使用super不一定非要在方法覆写之后使用，也可以明确的表示某个方法是从父类中继承而来的。使用super只是更加明确的说，要从父类中查找，就不从子类中找了。

举例：

public class ExtDemo01 {

public static void main(String[] args) {

Son son = new Son();

son.fun();

}

}

class Father{

void fun(){

System.out.println("父类hello");

}

}

class Son extends Father{

public void fun1(){

this.fun();//this代表当前对象：当前正在调用此方法的对象;

//也就是子类对象son 等价于 this 。

//他先在本类中寻找fun()方法，找不到，再跑去父类中寻找

System.out.println("子类hello");

}

}

运行结果：父类hello

7.  如果现在将父类的一个方法定义成private 访问权限，在子类中将此方法声明为default访问权限，这样不算覆写。而是相当于在子类中又重新定义了一个新的方法。

举例：

public class ExtDemo03 {

public static void main(String[] args) {

Son1 son1 = new Son1();

son1.fun1();

}

}

class Father1{

private void print(){

System.out.println("父类hello");

}

public void fun1(){//定义一个fun()方法

this.print();

}

}

class Son1 extends Father1{

void print(){

//super.print();//父类中的print()方法为私有的，外部不可访问

System.out.println("子类hello");

}

}

8.  属性的覆盖

方法覆写有很多要求，属性的覆盖，主要指的是在子类中声明了和父类同名的属性。

举例：

public class ExtDemo05 {

public static void main(String[] args){

Son2 son2 = new Son2();

son2.fun();

}

}

class Father2{

public String info = "父类Nishuibaichuan";

}

class Son2 extends Father2{

public String info = "子类Hello";

void fun(){

System.out.println("调用 的属性为：" + info) ;

}

}

运行结果：

调用 的属性为：子类Hello