Java:類與繼承
對於面向對象的程序設計語言來說,類毫無疑問是其最重要的基礎。抽象、封裝、繼承、多態這四大特性都離不開類,只有存在類,才能體現面向對象編程的特點,今天我們就來了解一些類與繼承的相關知識。首先,我們講述一下與類的初始化相關的東西,然後再從幾個方面闡述繼承這一大特性。以下是本文的目錄大綱:
一.你瞭解類嗎?
二.你瞭解繼承嗎?
三.常見的面試筆試題
若有不正之處,請多多諒解並歡迎批評指正。
請尊重作者勞動成果,轉載請標明原文鏈接:
http://blog.csdn.net/lijun2247900158/article/details/50014925
一.你瞭解類嗎?
在Java中,類文件是以.java爲後綴的代碼文件,在每個類文件中最多隻允許出現一個public類,當有public類的時候,類文件的名稱必須和public類的名稱相同,若不存在public,則類文件的名稱可以爲任意的名稱(當然以數字開頭的名稱是不允許的)。
在類內部,對於成員變量,如果在定義的時候沒有進行顯示的賦值初始化,則Java會保證類的每個成員變量都得到恰當的初始化:
1)對於 char、short、byte、int、long、float、double等基本數據類型的變量來說會默認初始化爲0(boolean變量默認會被初始化爲false);
2)對於引用類型的變量,會默認初始化爲null。
如果沒有顯示地定義構造器,則編譯器會自動創建一個無參構造器,但是要記住一點,如果顯示地定義了構造器,編譯器就不會自動添加構造器。注意,所有的構造器默認爲static的。
下面我們着重講解一下 初始化 順序:
當程序執行時,需要生成某個類的對象,Java執行引擎會先檢查是否加載了這個類,如果沒有加載,則先執行類的加載再生成對象,如果已經加載,則直接生成對象。
在類的加載過程中,類的static成員變量會被初始化,另外,如果類中有static語句塊,則會執行static語句塊。static成員變量和static語句塊的執行順序同代碼中的順序一致。記住,在Java中,類是按需加載,只有當需要用到這個類的時候,纔會加載這個類,並且只會加載一次。看下面這個例子就明白了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
public class Test
{ public static void main(String[]
args) throws ClassNotFoundException
{ Bread
bread1 = new Bread(); Bread
bread2 = new Bread(); } } class Bread
{ static { System.out.println( "Bread
is loaded" ); } public Bread()
{ System.out.println( "bread" ); } } |
運行這段代碼就會發現"Bread is loaded"只會被打印一次。
在生成對象的過程中,會先初始化對象的成員變量,然後再執行構造器。也就是說類中的變量會在任何方法(包括構造器)調用之前得到初始化,即使變量散步於方法定義之間。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
public class Test
{ public static void main(String[]
args) { new Meal(); } } class Meal
{ public Meal()
{ System.out.println( "meal" ); } Bread
bread = new Bread(); } class Bread
{ public Bread()
{ System.out.println( "bread" ); } } |
輸出結果爲:
bread
meal
二.你瞭解繼承嗎?
繼承是所有OOP語言不可缺少的部分,在java中使用extends關鍵字來表示繼承關係。當創建一個類時,總是在繼承,如果沒有明確指出要繼承的類,就總是隱式地從根類Object進行繼承。比如下面這段代碼:
1
2
3
4
5
6
7
8
9
10
11
|
class Person
{ public Person()
{ } } class Man extends Person
{ public Man()
{ } } |
類Man繼承於Person類,這樣一來的話,Person類稱爲父類(基類),Man類稱爲子類(導出類)。如果兩個類存在繼承關係,則子類會自動繼承父類的方法和變量,在子類中可以調用父類的方法和變量。在java中,只允許單繼承,也就是說 一個類最多隻能顯示地繼承於一個父類。但是一個類卻可以被多個類繼承,也就是說一個類可以擁有多個子類。
1.子類繼承父類的成員變量
當子類繼承了某個類之後,便可以使用父類中的成員變量,但是並不是完全繼承父類的所有成員變量。具體的原則如下:
1)能夠繼承父類的public和protected成員變量;不能夠繼承父類的private成員變量;
2)對於父類的包訪問權限成員變量,如果子類和父類在同一個包下,則子類能夠繼承;否則,子類不能夠繼承;
3)對於子類可以繼承的父類成員變量,如果在子類中出現了同名稱的成員變量,則會發生隱藏現象,即子類的成員變量會屏蔽掉父類的同名成員變量。如果要在子類中訪問父類中同名成員變量,需要使用super關鍵字來進行引用。
2.子類繼承父類的方法
同樣地,子類也並不是完全繼承父類的所有方法。
1)能夠繼承父類的public和protected成員方法;不能夠繼承父類的private成員方法;
2)對於父類的包訪問權限成員方法,如果子類和父類在同一個包下,則子類能夠繼承;否則,子類不能夠繼承;
3)對於子類可以繼承的父類成員方法,如果在子類中出現了同名稱的成員方法,則稱爲覆蓋,即子類的成員方法會覆蓋掉父類的同名成員方法。如果要在子類中訪問父類中同名成員方法,需要使用super關鍵字來進行引用。
注意:隱藏和覆蓋是不同的。隱藏是針對成員變量和靜態方法的,而覆蓋是針對普通方法的。(後面會講到)
3.構造器
子類是不能夠繼承父類的構造器,但是要注意的是,如果父類的構造器都是帶有參數的,則必須在子類的構造器中顯示地通過super關鍵字調用父類的構造器並配以適當的參數列表。如果父類有無參構造器,則在子類的構造器中用super關鍵字調用父類構造器不是必須的,如果沒有使用super關鍵字,系統會自動調用父類的無參構造器。看下面這個例子就清楚了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
class Shape
{ protected String
name; public Shape(){ name
= "shape" ; } public Shape(String
name) { this .name
= name; } } class Circle extends Shape
{ private double radius; public Circle()
{ radius
= 0 ; } public Circle( double radius)
{ this .radius
= radius; } public Circle( double radius,String
name) { this .radius
= radius; this .name
= name; } } |
這樣的代碼是沒有問題的,如果把父類的無參構造器去掉,則下面的代碼必然會出錯:
改成下面這樣就行了:
4.super
super主要有兩種用法:
1)super.成員變量/super.成員方法;
2)super(parameter1,parameter2....)
第一種用法主要用來在子類中調用父類的同名成員變量或者方法;第二種主要用在子類的構造器中顯示地調用父類的構造器,要注意的是,如果是用在子類構造器中,則必須是子類構造器的第一個語句。
三.常見的面試筆試題
1.下面這段代碼的輸出結果是什麼?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
public class Test
{ public static void main(String[]
args) { new Circle(); } } class Draw
{ public Draw(String
type) { System.out.println(type+ "
draw constructor" ); } } class Shape
{ private Draw
draw = new Draw( "shape" ); public Shape(){ System.out.println( "shape
constructor" ); } } class Circle extends Shape
{ private Draw
draw = new Draw( "circle" ); public Circle()
{ System.out.println( "circle
constructor" ); } } |
shape draw constructor
shape constructor
circle draw constructor
circle constructor
這道題目主要考察的是類繼承時構造器的調用順序和初始化順序。要記住一點:父類的構造器調用以及初始化過程一定在子類的前面。由於Circle類的父類是Shape類,所以Shape類先進行初始化,然後再執行Shape類的構造器。接着纔是對子類Circle進行初始化,最後執行Circle的構造器。
2.下面這段代碼的輸出結果是什麼?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
public class Test
{ public static void main(String[]
args) { Shape
shape = new Circle(); System.out.println(shape.name); shape.printType(); shape.printName(); } } class Shape
{ public String
name = "shape" ; public Shape(){ System.out.println( "shape
constructor" ); } public void printType()
{ System.out.println( "this
is shape" ); } public static void printName()
{ System.out.println( "shape" ); } } class Circle extends Shape
{ public String
name = "circle" ; public Circle()
{ System.out.println( "circle
constructor" ); } public void printType()
{ System.out.println( "this
is circle" ); } public static void printName()
{ System.out.println( "circle" ); } } |
shape constructor circle constructor shape this is circle shape
這道題主要考察了隱藏和覆蓋的區別(當然也和多態相關,在後續博文中會繼續講到)。
覆蓋只針對非靜態方法(終態方法不能被繼承,所以就存在覆蓋一說了),而隱藏是針對成員變量和靜態方法的。這2者之間的區別是:覆蓋受RTTI(Runtime type identification)約束的,而隱藏卻不受該約束。也就是說只有覆蓋方法纔會進行動態綁定,而隱藏是不會發生動態綁定的。在Java中,除了static方法和final方法,其他所有的方法都是動態綁定。因此,就會出現上面的輸出結果。