继承

继承是面向对象的第二大特征，继承是在已有的代码结构上扩充新的功能。

例子：观察下面的代码

  class Student{ 
   private int age;
   private String name;
   public void setAge(int age){ 
     this.age=age;
   } 
   public void setName(String name){ 
     this.name=name;
   }
   public int getAge(){ 
     return this.age;
   } 
   public String getName(){ 
     return this.name;
   } 
   public  String getInfo(){ 
      return "名字是："+this.name+", 年龄是："+this.age;
   } 
   public void readBook(){ 
      System.out.println("我会读书！");
   } 
 } 
class Worker{ 
   private int age;
   private String name;
   public void setAge(int age){ 
     this.age=age;
   } 
   public void setName(String name){ 
     this.name=name;
   }
   public int getAge(){ 
     return this.age;
   } 
   public String getName(){ 
     return this.name;
   } 
   public  String getInfo(){ 
      return "名字是："+this.name+", 年龄是："+this.age;
   } 
   public void moveBrik(){ 
      System.out.println("我会搬砖！");
   } 
 } 
 public class Demo{ 
    public static void main(String[] args){ 
       Student stu=new Student();
       stu.readBook();
       Worker wrk=new Worker();
       wrk.moveBrik();
       
    } 
}

以上代码出现了两个类中都有age,name，而且有相同的setter和getter方法，此外还有getInfo()方法相同，那么这样代码形式就出现了大量重复代码，于是我们可以考虑将这些重复的信息定义到一个共公的类中，然后让子类去继承这个公共的类，就解决了代码的重复，这个公共的类有人叫做基类、父类、超类。子类有人叫做派生类。
那么要实现继承就要使用关键字extends来实现，基本的语法如下：

· class 子类 extends 父类{}

例子：继承的使用

class Person{ //定义一个父类
   private int age;
   private String name;
   public void setAge(int age){ 
     this.age=age;
   } 
   public void setName(String name){ 
     this.name=name;
   }
   public int getAge(){ 
     return this.age;
   } 
   public String getName(){ 
     return this.name;
   } 
   public  String getInfo(){ 
      return "名字是："+this.name+", 年龄是："+this.age;
   } 
 } 
//---------------------------子类-------------------------------
 class Student extends Person{  //子类
   public void readBook(){ 
      System.out.println("我会读书！");
   } 
 } 
//---------------------------子类-------------------------------
class Worker extends Person{  //子类
   public void moveBrik(){ 
      System.out.println("我会搬砖！");
   } 
 } 
 public class Demo{ 
    public static void main(String[] args){ 
       Student stu=new Student();
       stu.readBook();
       Worker wrk=new Worker();
       wrk.moveBrik();
    } 
}

二、继承的局限性

单继承局限，一个子类只能有一个父类，但是继承可以实现多重继承。

class A{} //顶级父类
class B extends A{} //B类具有A的所有操作
classs C extends B{} //C类具有B和A的所有操作。

例子：调用父类的无参构造方法

 class A{ 
    public A(){ 
      System.out.println("这是A无参数构造方法");
    } 
 }
 class B extends A{ 
   public B(){ 
      System.out.println("这是B无参数构造方法");
   } 
 } 
 class C extends B{ 
   public C(){ 
      System.out.println("这是C无参数构造方法");
   } 
 } 
 public class Demo{ 
    public static void main(String[] args){ 
       new C();//输出多少
    } 
}       

打印：
这是A无参数构造方法
这是B无参数构造方法
这是C无参数构造方法

**结果： 实例化子类的时候先调用父类的构造方法。

例子：去掉无参构造方法

 class A{   
//----------------------去掉父类的无参构造方法----------------------------------
    public A(String name){ 
      System.out.println("这是A无参数构造方法");
    } 
 }
 class B extends A{ 
//----------------------- 父类的无参构造方法取掉之后，此处会报错-----------------
   public B(){ 
      System.out.println("这是B无参数构造方法");
   } 
 } 
 class C extends B{ 
   public C(){ 
      System.out.println("这是C无参数构造方法");
   } 
 } 
 public class Demo{ 
    public static void main(String[] args){ 
       new C();//输出多少
    } 
}

结果： 证明了“在实例化子类对象的时候默认调用父类的无参数构造方法“。
调用有参数的构造方法 使用 super（）来显示指定要调用的构造方法。

例子：调用有参的构造方法

 class A{   
    public A(){ 
      System.out.println("这是A无参数构造方法");
    } 
    public A(String name){ 
      System.out.println("这是A有一个参数构造方法");
    } 
    public A(String name,int age){ 
      System.out.println("这是A有2个参数构造方法");
    } 
 }
 class B extends A{ 
   public B(){ 
//-----------------------super 调用指定的构造方法---------------------------------

     super("阿萨德",123);//要放到构造方法中的第一行
      System.out.println("这是B无参数构造方法");
   } 
 } 
 class C extends B{ 
   public C(){ 
      System.out.println("这是C无参数构造方法");
   } 
 } 
 public class Demo{ 
    public static void main(String[] args){ 
       new C();//输出多少
    } 

打印：
这是A有2个参数构造方法 
这是B无参数构造方法
这是C无参数构造方法

三、私有属性的继承问题

疑问： private封装的属性是否可以被子类访问？是否可以被子类继承？怎么访问？？

子类要访问父类的属性要使用 ： “ super.属性名” 的方式实现

例子： 子类是否能访问父类的私有属性？

class Person{ //定义一个父类
   private int age=100;//这是私有属性
   public String name="阿强";//这是public修饰的属性
   public void setAge(int age){ 
     this.age=age;
   } 
   public void setName(String name){ 
     this.name=name;
   }
   public int getAge(){ 
     return this.age;
   } 
   public String getName(){ 
     return this.name;
   } 
   public  String getInfo(){ 
      return "名字是："+this.name+", 年龄是："+this.age;
   } 
 } 
 class Student extends Person{  
   public void readBook(){ 
      System.out.println("我会读书！");
//-----------------------子类访问父类的私有属性报错-----------------------------------
      System.out.println("访问父类中的属性：age="+super.age);  ／／
      System.out.println("访问父类中的属性：name="+super.name);
   } 
 } 
  
 public class demo{ 
    public static void main(String[] args){ 
       new Student().readBook();//输出多少
    } 
}

上面的例子中，子类访问父类的私有属性，报错。

结果： 父类的私有属性并不能被直接访问。

例子： 私有属性继承的问题

class Person{ //定义一个父类
   private int age=100;//这是私有属性
   private String name="阿强";//这是public修饰的属性
   public void setAge(int age){ 
     this.age=age;
   } 
   public void setName(String name){ 
     this.name=name;
   }
   public int getAge(){ 
     return this.age;
   } 
   public String getName(){ 
     return this.name;
   } 
   public  String getInfo(){ 
      return "名字是："+this.name+", 年龄是："+this.age;
   } 
 } 
 class Student extends Person{  
   public void readBook(){ 
      System.out.println("我会读书！"); 
   } 
 } 

 public class demo{ 
    public static void main(String[] args){ 
      Student stu=new Student();
//-------------------------------------------------------
      stu.setAge(123);  //如果不能被继承，那么123这一个值是不可能被保存的。
      System.out.println(stu.getAge());//看看有没有输出 123？
    } 
}

结果： 输出了123.

说明： 子类不能直接访问父类的私有属性
但是，子类可以继承父类的私有属性，称为隐式继承。