[書籍選讀] 天下無賴

好久好久沒有看鮮網的小說了，打從天魔神譚、眾神故事出版的那個年代──

大概是距今七、八年有了吧；這年份大概也就是我看網路小說的時間吧。

[MEMO] Android R.java不見了! 怎麼辦?

先介紹一個還不錯的網站給學習Android的朋友，下面再來解救R.java的問題。

初學 Android

什麼是R.java？

會問這問題的話，你應該還沒碰到我的問題。

在一個正常的Android程式中，會有個資料夾 gen

gen : 放系統資源檔，元件存放的地方。

當中的 R.java 是由 Android Development Kit (ADK) 所自動產生的資源索引檔（resource index)。

R.java 是根據 main.xml (在 res.layout中) 所自動產生，並不是由程式設計師編寫的，切勿修改此檔案。

 

網路上針對這問題用很多詞彙去形容，什麼 Buide project ...etc

 

簡單一點，開啟你的Eclipse，叫出你那有很多紅色叉叉的project。

在 Eclipse 我們只要下這個指令 Ctrl+Shift+O 。

你就會看到有一條bar正在重新建立你的專案......

然後，正常來講一個你那個不知道打哪來的source code就可以正常使用了

[MEMO] Up/Down Casting & Java 字串比較

=======================Package 1==================================

public class ParsedResultType {
(中略)
public static final ParsedResultType ISBN = new ParsedResultType("ISBN");
/*

 *  向上轉型: 將子類別建構的物件指派給父類別宣告的參考變數，

 *  則該物件將會自動轉換為父類別的型別。

 *  掃描後的結果內容。注意! 這個最終型態並非 "String"

*/

public static String EEEE;
public static String toString2() {
Object ISBN = new String ("ISBN");
EEEE = (String)ISBN;
return EEEE;
}
//向下轉型：將向上轉型為父類別型別的物件，再轉回，稱之。
}

=======================Package 2==================================

 (前略)

  public static final String AAAA = com.(略).ParsedResultType.EEEE;
  public static final String CCCC = "9789862010228";

 

public void playBeepSoundAndVibrate()
      {
      
      if(CCCC.equals(AAAA))
          /*

          *不能用 if(AAAA.equals(CCCC))

          *因為AAAA可能為null值，會彈出,java.lang.NullPointerException,。

          *不能用 if (AAAA == CCCC)

          *這是在比較兩個是否均為字串型別,結果必為true,所以不能拿來當作條件式 

          */

      {
                  if (playBeep && mediaPlayer != null)
                  {
                      mediaPlayer.start();
                  }
      }
                  if (vibrate)
                  {
                      Vibrator vibrator = (Vibrator) getSystemService(VIBRATOR_SERVICE);
                      vibrator.vibrate(VIBRATE_DURATION);
                  }
      }
 

弔詭的地方來了，加入條件判斷之後他居然不會播放音效了......

準備來去看一下logcat = ="

[MEMO] Java import、package作用與用法

轉貼自：http://hi.baidu.com/franklee198/blog/item/8fd246fb6b4f9e68024f56ef.html/cmtid/febf8835742a2e1c91ef3986

讓我們先瞭解一下，Java 的 package 到底有何用處。

其實，package 名稱就像是我們的姓，而 class 名稱就像是我們的名字
。package 名稱有很多 . 的，就好像是複姓。比如說 java.lang.String，就
是複姓 java.lang，名字為 String 的類別；java.io.InputStream 則是複姓
java.io，名字為 InputStream 的類別。

Java 會使用 package 這種機制的原因也非常明顯，就像我們取姓名一樣
，光是一間學校的同一屆同學中，就有可能會出現不少同名的同學，如果不取
姓的話，那學校在處理學生資料，或是同學彼此之間的稱呼，就會發生很大的
困擾。相同的，全世界的 Java 類別數量，恐怕比台灣人口還多，而且還不斷
的在成長當中，如果類別不使用套件名稱，那在用到相同名稱的不同類別時，
就會產生極大的困擾。幸運的是，Java 的套件名稱我們可以自己取，不像人
的姓沒有太大的選擇 ( 所以有很多同名同姓的 )，如果依照 Sun 的規範來取
套件名稱，那理論上不同人所取的套件名稱不會相同 ( 請參閱 "命名慣例"
的相關文章 )，也就不會發生名稱衝突的情況。

可是問題來了，因為很多套件的名稱非常的長，在寫程式時，會多打好多
字，花費不少時間，比如說：


java.io.InputStream is = java.lang.System.in;
java.io.InputStreamReader isr= new java.io.InputStreamReader(is);
java.io.BufferedReader br = new java.io.BufferedReader(isr);


實在是不美觀又麻煩。於是，Sun 想了一個辦法，就是 import。

這個 import 就是在程式一開頭的時候，先說明程式中會用到那些類別的
簡稱，也就是只稱呼名字，不稱呼他的姓。首先，在檔案開頭寫：


import java.lang.System;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;


這幾行說明了這四個姓名的類別，在程式中只用他的名字來稱呼，所以當程式
中提到 System 就是指 java.lang.System，而 InputStream 就是指
java.io.InputStream，依此類推。於是原來的程式就變成：


InputStream = System.in;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);


這樣看起來是不是清爽多了呢？如果這些類別用的次數很多，那就更能體會到
import 的好處了。可是這樣還是不夠，因為懶是人的天性，還是會有人覺得
打太多 import 了也很浪費時間，於是 Sun 又提供了一個方法：


import java.lang.*;
import java.io.*;


意思就是，等一下程式中提到的沒有姓名的類別，不是姓 java.lang，就是姓
java.io，如果這兩個裡面有同樣名字的類別，而不幸的你又只用名字稱呼這
個類別，那編譯器仍然會跟你抱怨，因為它還是不知道你說的這個類別指那一
個姓的類別。那可不可以再懶一點呢，只寫：


import java.*;


歷史告訴我們，人可以懶，但不能太懶，這樣是不行的。因為那些類別是姓
java.io 而不是姓 java。就像姓『諸葛』的人應該不會喜歡你稱他為『諸』
先生吧。

為甚麼我一開始說 import 跟 #include 不同呢？因為 import 的功能
到此為止，它不像 #include 一樣，會將檔案內容載入進來。import 只是請
編譯器幫你打字，讓編譯器把沒有姓的類別加上姓，並不會把別的檔案的程
式碼寫進來。如果你想練習打字，可以不要使用 import，只要在用到類別的
時候，用它的全部姓名來稱呼它就行了(就像例子一開始那樣)，跟使用
import 完全沒有甚麼兩樣。

另外，雖然人不可以太懶，但是 Sun 還是幫我們多偷了一點懶。因為
java.lang 這個套件實在是太常太常太常用到了，幾乎沒有程式不用它的，
所以不管你有沒有寫 import java.lang;，編譯器都會自動幫你補上，也就
是說編譯器只要看到沒有姓的類別，它就會自動去 java.lang 裡面找找看，
看這個類別是不是屬於這個套件的。所以我們就不用特別去
import java.lang 了。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

import導入聲明可分為兩中:
1>單類型導入(single-type-import)
例:import java.util.ArrayList;
2>按需類型導入(type-import-on-demand)
例:import java.util.*;

以這樣兩種方式導入包中的任何一個public的類和接口(只有public類和接口才能被導入)

*導入聲明僅導入類型而不導入子包;這就是為什麼稱它們為單類型導入和按需類型導入聲明的原因.

*導入的類或接口的簡名(simple name)具有編譯單元作用域.這表示該類型簡名可以在導入語句所在的編譯單元的任何地方使用.這並不意味著你可以使用該類型所有成員的簡名,而只能使用類型自身的簡名.
例如: java.lang包中的public類都是自動導入的,包括Math和System類.但是,你不能使用簡名PI()和gc(),而必須使用 Math.PI()和System.gc().你不需要鍵入的是java.lang.Math.PI()和java.lang.System.gc().

程序員有時會導入當前包或java.lang包,這是不需要的,因為當前包的成員本身就在作用域內,而java.lang包是自動導入的.java編譯器會忽略這些冗余導入聲明(redundant import declarations).即使像這樣
import java.util.ArrayList;
import java.util.*;
多次導入,也可編譯通過.編譯器會將冗余導入聲明忽略.

使用按需導入聲明是否會降低Java代碼的執行效率?絕對不會!
Java編譯器產生的類文件僅包含編譯單元實際使用到的類或接口的符號引用.

這是否意味著你總是可以使用按需導入聲明?是,也不是!
在類似Demo的非正式開發中使用按需導入聲明顯得很有用.
然而,有這四個理由讓你可以放棄這種聲明:
1>編譯速度:在一個很大的項目中,它們會極大的影響編譯速度.但在小型項目中使用在編譯時間上可以忽略不計.
2>命名衝突:解決避免命名衝突問題的答案就是使用全名.而按需導入恰恰就是使用導入聲明初衷的否定.
3>說明問題:全名的使用是自說性的.畢竟高級語言的代碼是給人看的.
4>無名包問題:如果在編譯單元的頂部沒有包聲明,Java編譯器首選會從無名包中搜索一個類型,然後才是按需類型聲明.如果有命名衝突就會產生問題.
Sun的工程師一般不使用按需類型導入聲明.這你可以在他們的代碼中找到:
在java.util.Properties類中的導入聲明:
import java.io.IOException;
import java.io.printStream;
import java.io.printWrite;
import java.io.InputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.util.Hashtable;

你可以看到有趣的是,她連java.util.Hashtable也導入,這可是在當前包中啊!

[MEMO] Java import、package作用與用法

轉貼自：Franklee

讓我們先瞭解一下，Java 的 package 到底有何用處。

其實，package 名稱就像是我們的姓，而 class 名稱就像是我們的名字
。package 名稱有很多 . 的，就好像是複姓。比如說 java.lang.String，就
是複姓 java.lang，名字為 String 的類別；java.io.InputStream 則是複姓
java.io，名字為 InputStream 的類別。

Java 會使用 package 這種機制的原因也非常明顯，就像我們取姓名一樣
，光是一間學校的同一屆同學中，就有可能會出現不少同名的同學，如果不取
姓的話，那學校在處理學生資料，或是同學彼此之間的稱呼，就會發生很大的
困擾。相同的，全世界的 Java 類別數量，恐怕比台灣人口還多，而且還不斷
的在成長當中，如果類別不使用套件名稱，那在用到相同名稱的不同類別時，
就會產生極大的困擾。幸運的是，Java 的套件名稱我們可以自己取，不像人
的姓沒有太大的選擇 ( 所以有很多同名同姓的 )，如果依照 Sun 的規範來取
套件名稱，那理論上不同人所取的套件名稱不會相同 ( 請參閱 "命名慣例"
的相關文章 )，也就不會發生名稱衝突的情況。

可是問題來了，因為很多套件的名稱非常的長，在寫程式時，會多打好多
字，花費不少時間，比如說：


java.io.InputStream is = java.lang.System.in;
java.io.InputStreamReader isr= new java.io.InputStreamReader(is);
java.io.BufferedReader br = new java.io.BufferedReader(isr);


實在是不美觀又麻煩。於是，Sun 想了一個辦法，就是 import。

這個 import 就是在程式一開頭的時候，先說明程式中會用到那些類別的
簡稱，也就是只稱呼名字，不稱呼他的姓。首先，在檔案開頭寫：


import java.lang.System;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;


這幾行說明了這四個姓名的類別，在程式中只用他的名字來稱呼，所以當程式
中提到 System 就是指 java.lang.System，而 InputStream 就是指
java.io.InputStream，依此類推。於是原來的程式就變成：


InputStream = System.in;
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);


這樣看起來是不是清爽多了呢？如果這些類別用的次數很多，那就更能體會到
import 的好處了。可是這樣還是不夠，因為懶是人的天性，還是會有人覺得
打太多 import 了也很浪費時間，於是 Sun 又提供了一個方法：


import java.lang.*;
import java.io.*;


意思就是，等一下程式中提到的沒有姓名的類別，不是姓 java.lang，就是姓
java.io，如果這兩個裡面有同樣名字的類別，而不幸的你又只用名字稱呼這
個類別，那編譯器仍然會跟你抱怨，因為它還是不知道你說的這個類別指那一
個姓的類別。那可不可以再懶一點呢，只寫：


import java.*;


歷史告訴我們，人可以懶，但不能太懶，這樣是不行的。因為那些類別是姓
java.io 而不是姓 java。就像姓『諸葛』的人應該不會喜歡你稱他為『諸』
先生吧。

為甚麼我一開始說 import 跟 #include 不同呢？因為 import 的功能
到此為止，它不像 #include 一樣，會將檔案內容載入進來。import 只是請
編譯器幫你打字，讓編譯器把沒有姓的類別加上姓，並不會把別的檔案的程
式碼寫進來。如果你想練習打字，可以不要使用 import，只要在用到類別的
時候，用它的全部姓名來稱呼它就行了(就像例子一開始那樣)，跟使用
import 完全沒有甚麼兩樣。

另外，雖然人不可以太懶，但是 Sun 還是幫我們多偷了一點懶。因為
java.lang 這個套件實在是太常太常太常用到了，幾乎沒有程式不用它的，
所以不管你有沒有寫 import java.lang;，編譯器都會自動幫你補上，也就
是說編譯器只要看到沒有姓的類別，它就會自動去 java.lang 裡面找找看，
看這個類別是不是屬於這個套件的。所以我們就不用特別去
import java.lang 了。

。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

import導入聲明可分為兩中:
1>單類型導入(single-type-import)
例:import java.util.ArrayList;
2>按需類型導入(type-import-on-demand)
例:import java.util.*;

以這樣兩種方式導入包中的任何一個public的類和接口(只有public類和接口才能被導入)

*導入聲明僅導入類型而不導入子包;這就是為什麼稱它們為單類型導入和按需類型導入聲明的原因.

*導入的類或接口的簡名(simple name)具有編譯單元作用域.這表示該類型簡名可以在導入語句所在的編譯單元的任何地方使用.這並不意味著你可以使用該類型所有成員的簡名,而只能使用類型自身的簡名.
例如: java.lang包中的public類都是自動導入的,包括Math和System類.但是,你不能使用簡名PI()和gc(),而必須使用 Math.PI()和System.gc().你不需要鍵入的是java.lang.Math.PI()和java.lang.System.gc().

程序員有時會導入當前包或java.lang包,這是不需要的,因為當前包的成員本身就在作用域內,而java.lang包是自動導入的.java編譯器會忽略這些冗余導入聲明(redundant import declarations).即使像這樣
import java.util.ArrayList;
import java.util.*;
多次導入,也可編譯通過.編譯器會將冗余導入聲明忽略.

使用按需導入聲明是否會降低Java代碼的執行效率?絕對不會!
Java編譯器產生的類文件僅包含編譯單元實際使用到的類或接口的符號引用.

這是否意味著你總是可以使用按需導入聲明?是,也不是!
在類似Demo的非正式開發中使用按需導入聲明顯得很有用.
然而,有這四個理由讓你可以放棄這種聲明:
1>編譯速度:在一個很大的項目中,它們會極大的影響編譯速度.但在小型項目中使用在編譯時間上可以忽略不計.
2>命名衝突:解決避免命名衝突問題的答案就是使用全名.而按需導入恰恰就是使用導入聲明初衷的否定.
3>說明問題:全名的使用是自說性的.畢竟高級語言的代碼是給人看的.
4>無名包問題:如果在編譯單元的頂部沒有包聲明,Java編譯器首選會從無名包中搜索一個類型,然後才是按需類型聲明.如果有命名衝突就會產生問題.
Sun的工程師一般不使用按需類型導入聲明.這你可以在他們的代碼中找到:
在java.util.Properties類中的導入聲明:

import java.io.IOException;
import java.io.printStream;
import java.io.printWrite;
import java.io.InputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.util.Hashtable;

你可以看到有趣的是,她連java.util.Hashtable也導入,這可是在當前包中啊!

[MEMO] JAVA的18個基本概念

轉貼自:http://www.java1995.cn/article/926




關於Java的基礎知識，實踐證明學習OO，最終領悟「父類控制流程，子類實現具體的業務邏輯」的OO思想，需要的不是智商而是基礎，也就是說，基礎越好越快領悟，所以請每位S1學習Java的學員請牢記以下Java領域的基礎知識，最後祝各位學員在開發項目前可以領悟OO的真諦，老師也會竭盡全力助你們打通這道通向Java的極速大門。

　　1、 OO三大特性：繼承、封裝、多態（主要用於搭建程序框架，以此來提高代碼的重用性與解藕業務邏輯）。

　　2、 Java中的首字母大寫與命名規範：在Java中只有兩個地方會用到大寫的字母做為命名的第一個字母，一個是類，別一個是靜態變量。如：類Test、靜態 變量STATIC_NAME，如果Java使用的命名由幾個英文組成，則第二個開始的每個詞使用大寫隔開，如：userGroupId、 studentName。切忌：在Java中命名不能用中文與拼音，以及只有類名與靜態變量開頭的字母是使用大與，其他的命名如方法名、變量名一律開頭使 用小寫。

　　3、包(package):Java裡面的類太多了,你寫,我寫,大家寫,我們用的類名相同,不可能放在一起,怎麼辦?把它們放在不同的包裡面,就不會衝突了，包名為網址倒過來寫，請不要使用拼音來命名包名，以及包名不要過長（包的結構就是程序框架的結構）.

　　4、 抽像類(abstract class): 前面加了 abstract 關鍵字修飾的類就是抽像類，抽像類不能生成實例（不能使用New關鍵字）只能拿來繼承，抽像類中一般包含抽像方法（作為債務產生）,就是沒有具體實現的方法體（只做標示），一個類中如果定義了一個抽像方法這個類也就自動變成抽像類。

　　5、 抽像方法. 前面加了abstract 關鍵字修飾,沒有方法體.也就是方法什麼事也沒幹,像個空頭支票（產生債務方法之一）.

　　6、 接口(interface): 接口可以理解為純抽像的類，它的每個方法都是未實現的，它就像一個產品的說明書（產生債務方法之一）。

　　7、 對像: 對象是存在的具體實體,就是按照類(汽車設計圖紙),做出來的真正的看得見摸得著的汽車（註：聲明一個對象就像一個變量名，如果使用了New關鍵字就已在內存中分配了地址）.

　　8、 抽像：分析問題時抽出重要的因素,忽略掉不重要的（我們每天都在抽像身邊的事物，如：判斷一個人是好人還是壞人）。

　　9、靜態變量與方法（Static）：所謂的靜態變量就是在定義時加一個Static的關鍵字，被定義為靜態的方法與變量是唯一的，也就是說不 管這個類有多少個實例化對像它們都共用這個類中的靜態變量或方法，這也是為什麼使用靜態變量或方法是用類名來直接調用的原因，而非靜態變量或方法等於每個 實例化對象都有自己的方法與變量，這樣就會互不影響。舉個例子：老師相當於靜態的，因為被所有學員所共有，而學員就是非靜態的，因為每個學員都是獨立的。

　　10、 Java的四種類型：

　　１．Public : 公共類型，在繼承時，父類定義為公共類型的方法或變量子類可以全部繼承過去，而且別的類可以隨意調用公共類型的方法和變量。

　　２．Private: 私用類型，在繼承時，父類定義為私用類型的函數或變量子類不能繼承，而且別的類不可調用私有類型的方法和變量。

　　３．Protected：保護類型，在繼承時，父類定義為保護類型的函數或變量子類可以全部繼承過去，只有它的子類可以在不同的包調用它的方法（與Default唯一不同的地方，Default不可以），在一個包下面可以全部被調用。

　　４．Default:默認類型，不加類型關鍵字會自動變成默認類型，繼承時父類定義為默認類型的函數或變量子類會全部繼承過去，但只有在一個包下面的類才能調用。

　　11、 封裝（Encapsulation ）將重要的信息隱藏起來,或者將不需要使用者知道的很麻煩的信息全部藏起來,就像全自動洗衣機,只提供給用戶一個簡單的按鈕,把裡面具體的實現藏起來,使 用戶感覺操作很簡單（封裝有兩種方法接口與抽像類也叫基類，其中接口的封裝效果最好）。

　　12、 繼承（extends）:子類可以繼承父類非私有的屬性和方法,就像兒子繼承老爸的財產,兒子可以少奮鬥二十年。

　　13、 多態(Polymorphism): 多態性是指「多種形式」也叫「動態綁定」它使用不同的子類來執行不同的操作，前提是子類中相關方法名必須是一樣，這樣通過New一個不同的子類，通過接口 或者父類就可以做到只修改一行代碼而做到實現不同的功能，因為對於子類來講方法名大家都是一樣的，就好像「畫圖」這個方法，每個不同形狀的圖形都 有，New一個圓進去就是畫圓，New一個正方型進去就是畫正方型，這是因為在這些不同形狀的圖中，他們都有一個一樣的方法叫「畫圖」，不同形狀的圖形在 自己的「畫圖」方法中實現自己的特色，這樣使用動態綁定，只需要修改很少的代碼就可以做到New什麼就畫什麼，這些就是多態。

　　14、 重載:當多個方法具有相同的名字而含有不同的參數個數或類型時,便發生重載.

　　15、重寫：子類繼承父類，子類和父類的方法具有相同的名稱和類型，但子類幹的事和父類幹的事不一樣。就像你和你老爸都有個方法叫—工作,但工作的內容不一樣,你搞軟件開發,你老爸是醫生.

　　16、 final 類:當一個類定義為 final 後，它將不能被其他類所繼承，在定義靜態變量時，一般 final 和 static 共同使用，這樣這個靜態變量就是不可變的。

　　17、父債子還：這是Java中關於方法重寫的一種硬性規定，就像欠賬還錢一樣。在這裡有兩種方法會產生債務，一個是抽像方法，另一個是接口中 的方法，大家會發現這兩種都有一個特性：它們定義的方法體都是空的，這就是產生了債務，所謂的償還債務只是繼承這個抽像類的子類或實現了某個接口的類，它 們必須要重寫這些空的方法體，否則編譯器會報錯。在這裡只有定義為抽像類才不用還債，空的方法是一定要重寫的，就像你不還錢，你的兒子也要還錢，你兒子不 還，你的孫子就要還，一直到錢還清了，這個時候你的子類才不用強制重寫任何方法。

　　1８、 不能實例化：以下情況定義的類不可實例化（不能使用New關鍵字）：抽像類、構造函數聲明為 private（私有）（不能繼承）

[MEMO] Java中this、super用法簡談

通過用static來定義方法或成員，爲我們編程提供了某種便利，從某種程度上可以說它類似于C語言中的全局函數和全局變量。

但是，並不是說有了這種便利，你便可以隨處使用，如果那樣的話，你便需要認真考慮一下自己是否在用面向對象的思想編程，自己的程序是否是面向對象的。

好了，現在開始討論 this&super這兩個關鍵字的意義和用法。

　　在Java中，this通常指當前對象，super則指父類別。

當你想要引用當前對象的某種東西，比如當前對象的某個方法，或當前對象的某個成員，你便可以利用this來實現這個目的。

當然，this的另一個用途是調用當前對象的另一個 構造函數，這些馬上就要討論。

如果你想引用父類的某種東西，則非super莫屬。

      由於this與super有如此相似的一些特性和與生俱來的某種關系，所 以我們在這一塊兒來討論，希望能幫助你區分和掌握它們兩個。

　　在一般方法中最普遍的情況就是，在你的方法中的某個形參名與當前對象 的某個成員有相同的名字，這時爲了不至于混淆，你便需要明確使用this關鍵字來指明你要使用某個成員，使用方法是“this.成員名”，而不帶this 的那個便是形參。另外，還可以用“this.方法名”來引用當前對象的某個方法，但這時this就不是必須的了，你可以直接用方法名來訪問那個方法，編譯 器會知道你要調用的是那一個。下面的代碼演示了上面的用法：

==============================================================

　　public class DemoThis{
　　private String name;
　　private int age;
　　DemoThis(String name,int age){
　　setName(name);
//你可以加上this來調用方法，像這樣：this.setName(name);但這並不是必須的
　　setAge(age);
　　this.print(); br }
　　public void setName(String name){
　　this.name=name;
//此處必須指明你要引用成員變量
　　} public void etAge(int age){
　　this.age=age;
　　}
　　public void print(){
　　System.out.println("Name="+name+" ge="+age);
//在此行中並不需要用this，因爲沒有會導致混淆的東西
　　}
　　public static void main(String[] args)
{
　　DemoThis dt=new DemoThis("Kevin","22");

==============================================================

　　這段代碼很簡單，不用解釋你也應該能看明白。在構造函數中你看到用this.print(),你完全可以用print()來代替它，兩者效果一樣。下面我們修改這個程序，來演示super的用法。

==============================================================

　　class Person{
　　public int c;
　　private String name;
　　private int age; protected void setName(String name){
　　this.name=name;
　　}
　　protected void setAge(int age){
　　this.age=age;
　　} protected void print(){
　　System.out.println("Name="+name+" Age="+age); }}public class DemoSuper extends Person{
　　public void print(){
　　System.out.println("DemoSuper:");
　　super.print();}
　　public static void main(String[] args){
　　DemoSuper ds=new DemoSuper();
　　ds.setName("kevin");
　　ds.setAge(22);
　　ds.print(); }}

==============================================================

　　在DemoSuper中，重新定義的print方法覆寫了父類的print方法，它首先做一些自己的事情，然後調用父類的那個被覆寫了的方法。輸出結果說明了這一點：
　　DemoSuper:Name=kevin Age=22
　　這樣的使用方法是比較常用的。另外如果父類的成員可以被子類訪問，那你可以像使用this一樣使用它，用“super.父類中的成員名”的方式，但常常你並不是這樣來訪問父類中的成員名的。
　　在構造函數中構造函數是一種特殊的方法，在對象初始化的時候自動調用。在構造函數中，this和super也有上面說的種種使用方式，並且它還有特殊的地方，請看下面的例子：

==============================================================

class Person
{
　　public static void prt(String s)
{System.out.println(s);}
　　Person()
{prt("A Person."); }
Person(String name)
{prt("A person name is:"+name); }
}

public class Chinese extends Person{
　　Chinese()
{
　　super();
　　//調用父類構造函數（1）
　　prt("A chinese.");//(4)
}
　　Chinese(String name)
{
　　super(name);
//調用父類具有相同形參的構造函數（2）
　　prt("his name is:"+name);
}
Chinese(String name,int age)
{
　　this(name);
//調用當前具有相同形參的構造函數（3）
　　prt("his age is:"+age); }
public static void main(String[] args)
{
　　Chinese cn=new Chinese();
　　cn=new Chinese("kevin");
　　cn=new Chinese("kevin",22);
}
}

==============================================================

　　在這段程序中，this和super不再是像以前那樣用“.”連接一個方法或成員，而是直接在其後跟上適當的參數，因此它的意義也就有了變化。 super後加參數的是用來調用父類中具有相同形式的構造函數，如1和2處。this後加參數則調用的是當前具有相同參數的構造函數，如3處。當然，在 Chinese的各個重載構造函數中，this和super在一般方法中的各種用法也仍可使用，比如4處，你可以將它替換爲“this.prt”(因爲它繼承了父類中的那個方法）或者是“super.prt”（因爲它
是父類中的方法且可被子類訪問），它照樣可以正確運行。但這樣似乎就有點畫蛇添足的味道
了。
　　最後，寫了這麽多，如果你能對“this通常指代當前對象，super通常指代父類”這句話牢記在心，那麽本篇便達到了目的，其它的你自會在以後的編程實踐當中慢慢體會、掌握。另外關于本篇中提到的繼承，請參閱相關Java教程。

　　(王朝網絡 wangchao.net.cn)