十七 Java继承

一时失言乱红尘 2021-09-26 08:22 297阅读 0赞

# 概念 #

*  继承是Java面向对象编程技术的一块基石，因为它允许创建等级层次的类。
 *  继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

格式如下：

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

## 继承的特性 ##

*  子类拥有父类非private的属性、方法。
 *  子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
 *  子类可以用自己的方式实现父类。
 *  Java是单继承，可以多继承。
 *  提高了类间的耦合性（缺点）

## 继承的关键字 ##

继承可以使用extends和implemlents俩个关键字来实现。

### extends关键字 ###

Java中，类的继承是单一的，也就是一个子类只能由一个父类。  
eg.

public class Animal {  
        private String name;   
        private int id; 
        public Animal(String myName, String myid) { 
            //初始化属性值
        } 
        public void eat() {  //吃东西方法的具体实现 } 
        public void sleep() { //睡觉方法的具体实现 } 
    } 
    
    public class Penguin extends Animal{  
    }

**注意：Java为什么不支持多继承**

*  若子类继承的父类中拥有相同的成员变量，子类在引用该变量时将无法判别使用哪个父类的成员变量。
 *  若一个子类继承的多个父类拥有相同方法，同时子类并未覆盖该方法（若覆盖，则直接使用子类中该方法），那么调用该方法时将无法确定调用哪个父类的方法。
    
    **解决办法：接口，下面介绍**

### implements关键字 ###

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

public interface A { 
        public void eat();
        public void sleep();
    }
    
    public interface B { 
        public void show();
    }
    
    public class C implements A,B { 
    }

### super 与 this 关键字 ###

*  **super关键字**：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
 *  **this关键字**：指向自己的引用。

eg.

class Animal { 
      void eat() {
        System.out.println("animal : eat");
      }
    }
    
    class Dog extends Animal { 
      void eat() {
        System.out.println("dog : eat");
      }
      void eatTest() {
        this.eat();   // this 调用自己的方法
        super.eat();  // super 调用父类方法
      }
    }
    
    public class Test { 
      public static void main(String[] args) {
        Animal a = new Animal();
        a.eat();
        Dog d = new Dog();
        d.eatTest();
      }
    }

### final关键字 ###

*  声明类可以把类定义为不能继承的，即最终类；
 *  或者用于修饰方法，该方法不能被子类重写;
 *  实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final.

### 构造器 ###

*  子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
 *  如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。

eg.

package file;
    
    
    
    public class SubClass extends SuperClass{ 
        private int n;
    
          SubClass(){
            super(300);
            System.out.println("SubClass");
          }  
    
          public SubClass(int n){
            System.out.println("SubClass(int n):"+n);
            this.n = n;
          }
    
         public static void main (String args[]){
                SubClass sc = new SubClass();
                SubClass sc2 = new SubClass(200); 
        }
    
    }   
    
    class SuperClass {
          private int n;
          SuperClass(){
            System.out.println("SuperClass()");
          }
          SuperClass(int n) {
            System.out.println("SuperClass(int n)");
            this.n = n;
          }
        }

结果为：

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

--------------------