java类的继承（基础）

---恢复内容开始---

这篇随笔和大家讲讲java中类的继承是什么？希望对你们有所帮助。

目录

• 一、java继承是什么？
• 二、为什么使用java继承
• 三、java继承的实现　　
  • 1.1  java继承的基本语法
  • 1.2  super的用法　　　　

 

一、Java继承是什么？

简单来讲，Java中的继承是一个对象获取父对象的所有属性和行为的机制。它是面向对象编程系统（OOP）的重要组成部分。Java中继承的思想是，创建基于现有类的新类。从现有类中继承，可以重用父类的方法和字段。此外，还可以在当前类中添加新方法和字段

继承表示IS-A关系，也称为父子关系。

二·、为什么使用继承？

继承就是 比如，你和你的父亲，你可以继承你父亲身上的基因，但继承基因的同时你可以除了继承你父亲基因的同时再创造新的基因，就比如你父亲不高，但是你想变高，就可以在基础的同时使用重写来改变你的身高。

那为什么要使用继承呢？

1、可以实现方法重写（这样可以实现运行时多态性）。提高了代码的复用性。

2、继承允许我们重用代码，它提高了Java应用程序的可重用性。

三、继承的实现

　1.java继承的基本语法

 package pkg12;
 //Son是子类 ，Father是父类   所以就是子类继承（extends）父类
 public class Son extends Father{
     //方法......

 }

如果要继承一个类的话，就要使用extends关键字

提示：继承按时着成员在派生类中课访问，而不是仅仅限于当前定义的类，要在包含基类的包的外部派生一个类，这个基类就必循声明为public ，如果没有声明为public 这个类就不能直接地扩展到包的外部。

　　2、继承的特点：

• • • 子类会把父类所以的属性和方法都继承下来。（先不考虑final）
    • 如果父类包含了共同的属性和方法，我们可以使用继承来设计程序
    • 子类使用extends关键字继承父类的共同属性以外，子类话可以有自己特有的属性和方法。
    • 父类更通用，子类更具体。
    • 子类只能获得父类中的非private的属性，如果想要继承就得提供公共的set和get的方法，私有的方法是无法继承的。　　

用一个习题，来解释一下什么叫做继承，代码如下：

 package pkg11;

 //定义了一个老师类 同时都有两个属性和两个方法
 class TeachJava{
     String name;
     int age;

     public void TeachJava(){
         System.out.println(this.name+"在上java课");
     }
     public void sleep(){
         System.out.println(this.name+"在休息");
     }
 }

 //定义了二个老师类 同时都有两个属性和两个方法
 class TeachHtml{
     String name;
     int age;
     public void TeachHtml(){
         System.out.println(this.name+"在上Html课");
     }
     public void sleep(){
         System.out.println(this.name+"在休息");
     }
 }

 public class TextExtends{
     public static void main(String args[]){
         //实例化出第一个老师
         TeachJava  tj = new TeachJava();
         tj.name = "张三";
         tj.age = 18 ;
         tj.TeachJava();
         tj.sleep();
         //实例化出第二个老师
         TeachHtml th = new TeachHtml();
         th.name = "李四";
         th.age = 34;
         th.TeachHtml();
         th.sleep();
     }
 }

运行效果：

看到我们定义两个老师类，大家有没有发现一个问题呢？就是我定义了两个老师类， 两个老师类里面发现两个相同的属性和一个方法 ，这时我们就可以采用继承的方式来设计这个案例。

那我们应该怎么设计呢？ 遵循上面说到的继承语法：子类 继承 父类。

 package pkg11;
 //我们可以把相同的属性和方法放在一个类中，定义为  父类

 //父类
 class Teacher{
     String name;
     int age;

     public void sleep(){
         System.out.println(this.name+"在睡觉");
     }
 }

 //子类

 //        子类     继承     父类
 class TeachJava extends Teacher{
     public void TeachJava(){
         System.out.println(this.name+"在讲java课程");
     }
 }

 //        子类     继承     父类
 class TeachHtml extends Teacher{

     public void TeachHtml(){
         System.out.println(this.name+"在讲HTML课程");
     }
 }

 public class TextExtends1{
     public static void main(String args[]){
         TeachJava tj = new TeachJava();
         tj.name = "张三";//调用父类中的属性
         tj.age = 20;
         tj.TeachJava();//钓鱼自己的方法
         tj.sleep();//调用父类的方法。
         TeachHtml th = new TeachHtml();
         th.name="李四";//调用父类中的属性
         th.age = 25;
         th.TeachHtml();//调用自己的方法
         th.sleep();//调用父类的方法。
     }
 }

两个老师类的中重复的属性和方法，我没个把他归结为一个类当中作为 父类  ，因为我们继承的父类的属性和方法，所以我们就有和父类相同的属性和方法，所以继承的最明显的优点就是减少了代码的重复性。

这样继承和我们之前写的代码运行效果会一样吗？运行效果如下：

子类只能获得父类中的非private的属性，如果想要继承就得提供公共的set和get的方法，私有的方法是无法继承的。

这句特点要这样理解呢  为什么说要继承就的使用set和get方法呢？先看代码：　

package pkg11;
//我们可以把相同的属性和方法放在一个类中，定义为  父类

//父类
class Teacher{
    private String name;
    int age;

    public void sleep(){
        System.out.println(this.name+"在睡觉");
    }
}
//子类
//        子类     继承     父类
class TeachJava extends Teacher{
    public void TeachJava(){
        System.out.println(name+"在讲java课程");
    }
}
//        子类     继承     父类
class TeachHtml extends Teacher{

    public void TeachHtml(){
        System.out.println(this.name+"在讲HTML课程");
    }
}
public class TextExtends1{
    public static void main(String args[]){
        TeachJava tj = new TeachJava();
        tj.name = "张三";
        tj.age = 20;
        tj.TeachJava();
        tj.sleep();
        TeachHtml th = new TeachHtml();
        th.name="李四";
        th.age = 25;
        th.TeachHtml();
        th.sleep();
    }
}

在我父类属性中加了一个private，这样我们再运行运行程序看看会发生什么？

这里发生了报错，都在name的报错，所以上面的特点 说的真是这点私有的方法是无法继承的。

如果想在继续继承父类的话，那么我们就的使用封装的方法，get和set

 //父类
 class Teacher{
     private String name;
     int age;

     //封装
     public void setName(String name){
         this.name = name;
     }
     public void getName(){
         return name;
     }
     public void sleep(){
         System.out.println(this.name+"在睡觉");
     }
 }

之后调用方法就可以进行继承了。 1 package pkg11; 2 //我们可以把相同的属性和方法放在一个类中，定义为 父类 3

 //父类
 class Teacher{
     private String name;
     int age;

     //封装
     public void setName(String name){
         this.name = name;
     }
     public void getName(){
         return name;
     }
     public void sleep(){
         System.out.println(this.name+"在睡觉");
     }
 }
 //子类
 //        子类     继承     父类
 class TeachJava extends Teacher{
     public void TeachJava(){
         System.out.println(this.getName+"在讲java课程");
     }
 }
 //        子类     继承     父类
 class TeachHtml extends Teacher{

     public void TeachHtml(){
         System.out.println(this.getName()+"在讲HTML课程");
     }
 }
 public class TextExtends1{
     public static void main(String args[]){
         TeachJava tj = new TeachJava();
         //tj.getName = "张三";　　　　　　　tj.getName("张三");
         tj.age = 20;
         tj.TeachJava();
         tj.sleep();
         TeachHtml th = new TeachHtml();
         //th.getName="李四";　　　　　　　th.getName("李四")；
         th.age = 25;
         th.TeachHtml();
         th.sleep();
     }
 }

运行效果：

以上继承是单一继承，java还有多极继承

多级继承： 在多级继承中，派生类将继承基类，并且派生类也充当其他类的基类。在下面的图像中，类A用作派生类B的基类，后者又用作派生类C的基类。在Java中，类不能直接访问祖父母的成员。

就是可以继承多个

package pkg11;
//多极继承
class A{

}

class B extends A{

}

class C extends B{

}

public class TextExtends1{
    public static void main(String args[]){

    }
}

运行效果：

但是不支持多继承，它可以支持继承多个类，但不支持同时继承两个类。

这样是不支持的

 package pkg11;
 //错误展示

 class A{

 }

 class B{

 }

 class C extends A,B{

 }

 public class TextExtends3{
     public static void main(String args[]){

     }
 }

运行效果：

总结：

继承的优缺点
　优点：1、代码共享，减少创建类的工作量，每个子类都拥有父类的方法和属性。　　　　

　　　　2、提高代码的重用性，子类可以形似父类，但又异于父类。

　　　　3、提高代码的可扩展性。

　缺点：

　　　　1、只要继承，就必须拥有父类的所有属性和方法；
　　　　2、降低代码的灵活性。子类必须拥有父类的属性和方法，让子类多了约束；
　　　　3、增强了耦合性，当父类的常量、变量和方法被修改时，需要考虑子类的修改，而且在缺乏规范的环境下，修改可能会造成严重的后果。