java 繼承

 

 

 

 

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("你們好！我是"         + id + "號" + name + "."); 
    } 
}



public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}



public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}



子類擁有父類非 private 的屬性、方法。
子類能夠擁有本身的屬性和方法，即子類能夠對父類進行擴展。
子類能夠用本身的方式實現父類的方法。
Java 的繼承是單繼承，可是能夠多重繼承，單繼承就是一個子類只能繼承一個父類，多重繼承就是，例如 A 類繼承 B 類，B 類繼承 C 類，因此按照關係就是 C 類是 B 類的父類，B 類是 A 類的父類，這是 Java 繼承區別於 C++ 繼承的一個特性。
提升了類之間的耦合性（繼承的缺點，耦合度高就會形成代碼之間的聯繫越緊密，代碼獨立性越差）。
在 Java 中，類的繼承是單一繼承，也就是說，一個子類只能擁有一個父類，因此 extends 只能繼承一個類
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{ 
}
使用 implements 關鍵字能夠變相的使java具備多繼承的特性，使用範圍爲類繼承接口的狀況，能夠同時繼承多個接口（接口跟接口之間採用逗號分隔）。
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關鍵字：指向本身的引用。
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();
  }
}
輸出
animal : eat
dog : eat
animal : eat



final 關鍵字
實例變量也能夠被定義爲 final，被定義爲 final 的變量不能被修改。
被聲明爲 final 的類的方法自動地聲明爲 final，可是實例變量並非 final



#構造函數
class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 類繼承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自動調用父類的無參數構造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 調用父類中帶有參數的構造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 類繼承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 調用父類中帶有參數的構造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自動調用父類的無參數構造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 類繼承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 類繼承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}
輸出
------SubClass 類繼承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 類繼承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200




final 的做用隨着所修飾的類型而不一樣

1、final 修飾類中的屬性或者變量
不管屬性是基本類型仍是引用類型，final 所起的做用都是變量裏面存放的"值"不能變。
這個值，對於基本類型來講，變量裏面放的就是實實在在的值，如 1，"abc" 等。
而引用類型變量裏面放的是個地址，因此用 final 修飾引用類型變量指的是它裏面的地址不能變，並非說這個地址所指向的對象或數組的內容不能夠變，這個必定要注意。
例如：類中有一個屬性是 final Person p=new Person("name"); 那麼你不能對 p 進行從新賦值，可是能夠改變 p 裏面屬性的值 p.setName('newName');
final 修飾屬性，聲明變量時能夠不賦值，並且一旦賦值就不能被修改了。對 final 屬性能夠在三個地方賦值：聲明時、初始化塊中、構造方法中，總之必定要賦值。

2、final修飾類中的方法
做用：能夠被繼承，但繼承後不能被重寫。

3、final修飾類
做用：類不能夠被繼承。