Java面向對象，繼承，多態

1,繼承

Java 中經過 extends 關鍵字能夠繼承一個類，implements能夠繼承多個接口。繼承容許建立等級層次的類。

繼承的機制提升了代碼的複用性，讓類與類之間產生了關係，有了這個關係，纔有了多態的特性。

注：Java支持單繼承，可是能夠多層繼承。

子類能夠擁有父類的非private的方法和屬性，子類能夠繼承父類的方法，也能夠重寫父類的方法，還能夠對父進行拓展。

增長了類之間的聯繫，即提升了耦合。

通常格式爲：

class 父類 { }

class 子類 extends 父類 { }

 

Demo1:

 1 package com.hpioneer.Demo;
 2 
 3 public class Test_Extends {
 4     public static void main(String[] args) {
 5         Zi z = new Zi();
 6         //z.show();
 7     }
 8 }
 9 class Fu {
10     static {
11         System.out.println("靜態代碼塊Fu");
12     }
13 
14     {
15         System.out.println("構造代碼塊Fu");
16     }
17 
18     public Fu() {
19         System.out.println("構造方法Fu");
20     }
21 }
22 
23 class Zi extends Fu {
24     static {
25         System.out.println("靜態代碼塊Zi");
26     }
27 
28     {
29         System.out.println("構造代碼塊Zi");
30     }
31 
32     public Zi() {
33         System.out.println("構造方法Zi");
34     }
35 }

Demo2:

super關鍵字能夠用來實現對父類成員的訪問，來引用當前對象的父類。this關鍵字用於指向本身。

super能夠調用父類的構造方法，方法（和子類相同的，被重寫）

 1 class Animal {
 2   void eat() {
 3     System.out.println("animal : eat");
 4   }
 5 }
 6  
 7 class Dog extends Animal {
 8   void eat() {
 9     System.out.println("dog : eat");
10   }
11   void eatTest() {
12     this.eat();   // this 調用本身的方法
13     super.eat();  // super 調用父類方法
14   }
15 }
16  
17 public class Test {
18   public static void main(String[] args) {
19     Animal a = new Animal();
20     a.eat();
21     Dog d = new Dog();
22     d.eatTest();
23   }
24 }

2,重載（Override）和重寫（Overload）

重寫是對父類容許的方法的實現從新編寫，返回值和參數都不能改變。

重載是一個類裏面，方法名相同，參數不一樣，返回值類型也能夠不一樣。

方法的重寫和重載是java多態性的不一樣表現，重寫是父類與子類之間多態性的一種表現，重載能夠理解成多態的具體表現形式。

　　(1)方法重載是一個類中定義了多個方法名相同,而他們的參數的數量不一樣或數量相同而類型和次序不一樣,則稱爲方法的重載(Overloading)。

　　(2)方法重寫是在子類存在方法與父類的方法的名字相同,並且參數的個數與類型同樣,返回值也同樣的方法,就稱爲重寫(Overriding)。

　　(3)方法重載是一個類的多態性表現,而方法重寫是子類與父類的一種多態性表現。

 3,多態

多態是同一行爲具備多個表現形式。

多態的前提：必需要有關係，好比繼承，實現等，一般會有覆蓋操做。

多態的實現方法：

　　一，重寫

　　二，接口

　　三，抽象方法和抽象類

 

4,抽象類

 

抽象類通常用於描述一個體系單元，將一組共性內容進行抽取，在Java語言中使用abstract class來定義抽象類。

特色：能夠在類中定義抽象內容讓子類實現，能夠定義非抽象內容讓子類直接使用。它裏面定義的都是一些體系中的基本內容。抽象類不能實例化對象，因此抽象類必須被繼承，才能被使用。

Demo:

 1 abstract class Animal{
 2   private int age = 10;
 3   public Animal(){
 4     System.out.println("初始化Animal");
 5   }
 6   public void move(){
 7     System.out.println("跑步數："+this.age);
 8   }
 9 }
10 
11 abstract class Dog extends Animal{
12   public Dog(int age){
13    // super(age);//去掉會報異常
14     System.out.println("初始化Dog");
15   }
16 
17 }
18 
19 public class BigDogs extends Dog{
20   public BigDogs(){
21     super(20);
22     System.out.println("初始化BigDog");
23   }
24 
25   public static void main(String[] args){
26     BigDogs a = new BigDogs();
27     a.move();
28   }
29 }