瘋狂Java之學習筆記（25）-------------修飾符">瘋狂Java之學習筆記（25）-------------修飾符
893
2025-04-04
瘋狂Java之學習筆記（18）-------------繼承
瘋狂Java之學習筆記（18）-------------繼承
Java：類與繼承
Java 的基本概念
Java繼承是面向對象的最顯著的一個特征。繼承是從已有的類中派生出新的類，新的類能吸收已有類的數據屬性和行為，并能擴展新的能力。 [1]
Java繼承是使用已存在的類的定義作為基礎建立新類的技術，新類的定義可以增加新的數據或新的功能，也可以用父類的功能，但不能選擇性地繼承父類。這種技術使得復用以前的代碼非常容易，能夠大大縮短開發周期，降低開發費用。比如可以分隔符先定義一個類叫車，車有以下屬性：車體大小，顏色，方向盤，輪胎，而又由車這個類派生出轎車和卡車兩個類，為轎車添加一個小后備箱，而為卡車添加一個大貨箱。
類和類之間的繼承關系可以用 UML符號表示，其中父類又叫 超類或 基類，子類又叫 派生類。父類是子類的一般化，子類是父類的特化（具體化)。
JAVA不支持 多繼承，單繼承使JAVA的繼承關系很簡單，一個類只能有一個父類，易于管理程序，同時一個類可以實現多個接口，從而克服單繼承的缺點。
在 面向對象程序設計中運用繼承原則，就是在每個由一般類和特殊類形成的一般——特殊結構中，把一般類的對象實例和所有特殊類的對象實例都共同具有的屬性和操作一次性地在一般類中進行顯式的定義，在特殊類中不再重復地定義一般類中已經定義的東西，但是在語義上，特殊類卻自動地、隱含地擁有它的一般類(以及所有更上層的一般類)中定義的屬性和操作。
特殊類的對象擁有其一般類的全部或部分屬性與方法，稱作特殊類對一般類的繼承
繼承所表達的就是一種對象類之間的相交關系，它使得某類對象可以繼承另外一類對象的 數據成員和成員方法。若類B繼承類A，則屬于B的對象便具有類A的全部或部分性質(數據屬性)和功能(操作)，我們稱被繼承的類A為 基類、父類或 超類，而稱繼承類B為A的 派生類或子類。
繼承避免了對一般類和特殊類之間共同特征進行的重復描述。同時，通過繼承可以清晰地表達每一項共同特征所適應的概念范圍——在一般類中定義的屬性和操作適應于這個類本身以及它以下的每一層特殊類的全部對象。運用繼承原則使得 系統模型比較簡練也比較清晰。
對于面向對象的程序設計語言來說，類毫無疑問是其最重要的基礎。抽象、封裝、繼承、多態這四大特性都離不開類，只有存在類，才能體現面向對象編程的特點，今天我們就來了解一些類與繼承的相關知識。首先，我們講述一下與類的初始化相關的東西，然后再從幾個方面闡述繼承這一大特性。以下是本文的目錄大綱：
一.你了解類嗎？
二.你了解繼承嗎？
三.常見的面試筆試題
一.你了解類嗎？
在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中，類是按需加載，只有當需要用到這個類的時候，才會加載這個類，并且只會加載一次。看下面這個例子就明白了：
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"只會被打印一次。
在生成對象的過程中，會先初始化對象的成員變量，然后再執行構造器。也就是說類中的變量會在任何方法（包括構造器）調用之前得到初始化，即使變量散步于方法定義之間。
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進行繼承。比如下面這段代碼：
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關鍵字，系統會自動調用父類的無參構造器。看下面這個例子就清楚了：
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.下面這段代碼的輸出結果是什么？
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.下面這段代碼的輸出結果是什么？
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方法，其他所有的方法都是動態綁定。因此，就會出現上面的輸出結果。
以上借鑒http://www.cnblogs.com/dolphin0520/
繼承的初始化塊
Java初始化順序
1在new B一個實例時首先要進行類的裝載。（類只有在使用New調用創建的時候才會被java類裝載器裝入）
2，在裝載類時，先裝載父類A，再裝載子類B
3，裝載父類A后，完成靜態動作（包括靜態代碼和變量，它們的級別是相同的，安裝代碼中出現的順序初始化）
4，裝載子類B后，完成靜態動作
類裝載完成，開始進行實例化
1，在實例化子類B時，先要實例化父類A
2，實例化父類A時，先成員實例化（非靜態代碼）
3，父類A的構造方法
4，子類B的成員實例化（非靜態代碼）
5，子類B的構造方法
先初始化父類的靜態代碼--->初始化子類的靜態代碼-->初始化父類的非靜態代碼--->初始化父類構造函數--->初始化子類非靜態代碼--->初始化子類構造函數
測試代碼：
abstract class base
{
public int age=getNumber(100);
static{
System.out.println("base static block");
}
{
System.out.println("base nonstatic block");
}
static int sage=getNumber(50);
base(){
System.out.println(age);
System.out.println("base start");
draw();//會調用子類覆蓋后的方法，這兒是0！
System.out.println("base end");
}
static int getNumber(int base){
System.out.println("base.getNumber int"+base);
return base;
}
public void draw(){
System.out.println("base.draw");
}
}
public class initializeOrder extends base{
public int age=getNumber(1001);
private int _radius=getNumber(10);
static int sage=getNumber(250);
static{
System.out.println("subclass static block");
}
{
System.out.println("subclass nonstatic block");
}
initializeOrder(int radius){
_radius=radius;
System.out.println(age);
draw();//這兒是1000
System.out.println("initializeOrder initialized");
}
public void draw(){
System.out.println("initializeOrder.draw "+_radius);
}
public static void main(String[] args) { // TODO Auto-generated method stub
new initializeOrder(1000);
}
}
輸出為：
base static block
base.getNumber int50
base.getNumber int250
subclass static block
base.getNumber int100
base nonstatic block
100
base start
initializeOrder.draw 0
base end
base.getNumber int1001
base.getNumber int10
subclass nonstatic block
1001
initializeOrder.draw 1000
initializeOrder initialized
java中類/對象的初始化順序以及靜態代碼塊的使用
一、對象的初始化順序:(java類加載器加載類的順序：
(1)加載父類（以下序號相同，表明初始化是按代碼從上到下的順序來的）
1.為父類的靜態屬性分配空間并賦于初值
1.執行父類靜態初始化塊;
(2)加載子類
2.為子類的靜態屬性分配空間并賦于初值
2.執行子類的靜態的內容;
(3)加載父類構造器
3.初始化父類的非靜態屬性并賦于初值
3.執行父類的非靜態代碼塊;
4.執行父類的構造方法;
(4)加載子類構造器
5.初始化子類的非靜態屬性并賦于初值
5.執行子類的非靜態代碼塊;
6.執行子類的構造方法.
總之一句話，靜態代碼塊內容先執行（父先后子），接著執行父類非靜態代碼塊和構造方法，然后執行子類非靜態代碼塊和構造方法。
二、靜態變量和靜態代碼塊的初始化順序：
誰在前面先初始化誰（這個也比較容易理解，初始化的時候，不可能跳著去初始化吧，比如說靜態代碼塊在靜態變量的前面，不可能先跳過靜態代碼塊的初始化先去執行靜態變量的初始化吧。）
注意:子類的構造方法，不管這個構造方法帶不帶參數，默認的它都會先去尋找父類的不帶參數的構造方法。如果父類沒有不帶參數的構造方法，那么子類必須用supper關鍵子來調用
父類帶參數的構造方法，否則編譯不能通過。
三、類裝載步驟
在Java中，類裝載器把一個類裝入Java虛擬機中，要經過三個步驟來完成：裝載、鏈接和初始化，其中鏈接又可以分成校驗、準備和解析三步，除了解析外，其它步驟是嚴格按照順序完成的，各個步驟的主要工作如下：
裝載：查找和導入類或接口的二進制數據；
鏈接：執行下面的校驗、準備和解析步驟，其中解析步驟是可以選擇的；
校驗：檢查導入類或接口的二進制數據的正確性；
準備：給類的靜態變量分配并初始化存儲空間；
解析：將符號引用轉成直接引用；
初始化：激活類的靜態變量的初始化Java代碼和靜態Java代碼塊。
初始化類中屬性是靜態代碼塊的常用用途，但只能使用一次。
對象的初始化順序測試代碼
StaticIniBlockOrderTest
class Parent {
static String name ="hello";
{
System.out.println("parent block");
}
static {
System.out.println("parent static block");
}
public Parent() {
System.out.println("parent constructor");
}
}
class Child extends Parent {
static String childName ="hello";
{
System.out.println("child block");
}
static {
System.out.println("child static block");
}
public Child() {
System.out.println("child constructor");
}
}
publicclass StaticIniBlockOrderTest {
publicstaticvoid main(String[] args) {
new Child();// 語句(*)
}
}
運行結果：
parent static block
child static block
parent block
parent constructor
child block
child constructor
靜態變量和靜態代碼塊的初始化順序測試代碼
TestOrder
publicclass TestOrder {
//靜態變量
publicstatic TestA a =new TestA();
//靜態初始化塊
static {
System.out.println("靜態初始化塊");
}
//靜態變量
publicstatic TestB b =new TestB();
publicstaticvoid main(String[] args) {
new TestOrder();
}
}
class TestA {
public TestA() {
System.out.println("Test--A");
}
}
class TestB {
public TestB() {
System.out.println("Test--B");
}
}
運行結果：
Test--A
靜態初始化塊
Test--B
再加一個經典的測試代碼
package static測試;
class insect{
int i=9;
int j;
static {
prt("static block first,because it's begin of the static variable");
}
insect(){
System.out.println("insect initialized");
prt("i= "+i+" j="+j);
j=39;
}
static int x1=prt("static insect x1 initialized");
static int prt(String s){
System.out.println(s);
return 47;
}
}
public class Wps extends insect{
Wps(){
System.out.println("wps initialized");
prt("k="+k);
prt("j="+j);
}
int k=prt("the member k in wps be initialized");
static int x2=prt("static wps x2 initialized");
static int prt(String s){
System.out.println(s);
return 63;
}
public static void main(String[] args){
insect.prt("initialized constructor");
// Wps w=new Wps();
}
}
C++ Java
版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。
版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。
相關文章
