Think In Java讀書筆記－1（第5——7章）- -
第5章 隱藏實現細節
一．Java訪問權限飾詞（access specifiers）
Java有public、protect、friendly、private四種訪問權限，并且這四訪問權限的訪問范圍越來越小。
1． friendly
1） 果一個class內的數據成員或方法沒有任何權限飾詞，那么它的缺省訪問權限就是friendly。同一個package內的其它所有classes都可以訪問friendly成員，但對package以外的classes則形同private。
2） 對于同一個文件夾下的、沒有用package的classes，Java會自動將這些classes初見為隸屬于該目錄的default package，可以相互調用class中的friendly成員。如以下兩個class分別在同一個文件夾的兩個文件中，雖然沒有引入package，但隸屬于相同的default package。
class Sundae{
//以下兩個方法缺省為friendly
Sundae(){}
Void f() {System.out.println("Sundae.f()");
}
public class IceCream{
public static void main(String[] args){
Sundae x = new Sundae();
x.f();
}
}
2． public：可以被任何class調用
3． private：private成員只能在成員所屬的class內被調用，如：
class Sundae{
private Sundae(){}//只能在Sundae class中被調用
Sundae(int i) {}
static Sundae makASundae() {
return new Sundae();
}
}
public class IceCream{
public static void main(String[] args){
// Sundae class中構造函數Sundae()是private，
// 所以不能用它進行初始化
//Sundae x = new Sundae();
Sundae y = new Sundae(1);//Sundae(int)是friendly，可以在此調用
Sundae z = Sundae.makASundae();
}
}
4． protected：具有friendly訪問權限的同時，又能被subclass（當然包括子孫類，即子類的子類）所訪問。即，既能被同一package中的classes訪問，又能被protected成員所在class的subclass訪問。
二．Class的訪問權限
1．Class同樣具有public、protect、friendly、private四種訪問訪問權限：
1）public：在任何地方都可被使用
2）protect、private：除了它自己，沒有任何class可以使用，所以class不能是
protected或private（inner class除外）
3） friendly：同一個package中的classes能用
2． 如何調用構造函數被聲明為private的class
1） 用static函數
2） 用Singteton模式
class Soup{
private Soup(){}
//（1）靜態函數方法
public static Soup makeSout(){
return new Soup();
}
//（2）The "Singleton" pattern:
private static Soup ps1 = new Soup();
public static Soup access(){
return ps1;
}
public void f(String msg){
System.out.println("f(" + msg + ")");
}
}
public class Lunch{
public static void main(String[] args){
//Soup priv1 = new Soup();編譯錯誤
Soup priv2 = Soup.makeSout();
Soup priv3 = Soup.access();
priv2.f("priv2");
priv3.f("priv3");
}
第6章 重復運用classes
一．繼承（inheritance）
1． 在derived class中overriding某個函數時，只能覆寫base class中的接口，即base class中的public或protected或friendly函數。如果試圖overriding一個private函數，雖然編譯通過，但實際上你只是在derived class中添加了一個函數。如
class Cleanser{
private void prt(){//（b）
System.out.println("Cleanser.prt()");
}
}
public class ExplicitStatic extends Cleanser{
public void prt(){
System.out.println("ExplicitStatic.prt()");
}
public static void main(String[] args){
Cleanser x = new ExplicitStatic();
x.prt();//（a）
}
}
因為Cleanser中的prt()是private，所以不能在其derived class中被覆寫。ExplicitStatic中的prt()只是ExplicitStatic中的一個函數，所以當試圖在（a）處通過多態來調用prt()時，會發生錯誤。如果把（b）處的private去掉，則結果為
ExplicitStatic.prt()
2． Super的使用
1）通過關鍵字super可以調用當前class的superclass（父類）。
例6.1.1.1
class Base{
Base(){System.out.println("Base()");}
public void scrub() { System.out.println(" Base.scrub()"); }
}
class Cleanser extends Base{
private String s = new String("Cleanser");
public void append(String a) { s+=a; }
public void dilute() { append(" dilute()"); }
public void apply() { append(" apply()"); }
public void scrub() { append(" scrub()"); }
public void print() { System.out.println(s); }
Cleanser(){
System.out.println("Cleanser(): " + s);
}
public static void testStatic(){
System.out.println("testStatic()");
}
public static void main(String[] args){
Cleanser x = new Cleanser();
x.dilute(); x.apply(); x.scrub(); x.print();
}
}
public class ExplicitStatic extends Cleanser{
ExplicitStatic(){
System.out.println("ExplicitStatic()");
}
public void scrub(){
append(" Detergen.scrub()");
super.testStatic();
super.scrub();//調用的是Cleanser.scrub()
}
public void foam() { append(" foam()"); }
public static void main(String[] args){
ExplicitStatic x = new ExplicitStatic();
x.dilute(); x.apply(); x.scrub(); x.foam();
x.print(); System.out.println("Test base class:");
Cleanser.main(args);
testStatic();
}
}
運行結果：
Base()
Cleanser(): Cleanser
ExplicitStatic()
testStatic()
Cleanser dilute() apply() Detergen.scrub() scrub() foam()
Test base class:
Base()
Cleanser(): Cleanser
Cleanser dilute() apply() scrub()
testStatic()
2）通過super來調用superclass中的成員時，調用的是最近成員。
例6.1.1.2
class Base{
protected String baseS = "Base";//（a）
//private String baseS = "Base";
Base(){System.out.println("Base()");}
}
class Cleanser extends Base{
protected String baseS = "Cleanser";//（b）
public String s = new String("Cleanser");
Cleanser(){
System.out.println("Cleanser(): " + s);
}
Cleanser(String a){
System.out.println("Cleanser(" + a + "): s = " + s );
}
}
public class ExplicitStatic extends Cleanser{
String s2 = s;
String baseS = super.baseS; //（c）
ExplicitStatic(){
super("ExplicitStatic");
System.out.println("ExplicitStatic():s2 = " + s2 + ", baseS = "+ baseS + "super.baseS = " + super.baseS);
baseS = "ExplicitStatic";
System.out.println("baseS = " + baseS + " , super.baseS = " + super.baseS);
}
public static void main(String[] args){
ExplicitStatic x = new ExplicitStatic();
}
}
結果1：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser,super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
在上面例子中，在三個class中都存在String bases實例。在ExplicitStatic中如果直接調用baseS，則實際調用的是當前類ExplicitStatic中的baseS（即（c）處的成員）；如果通過super.bases來調用baseS，則調用的是離當前類ExplicitStatic最近的baseS成員，即Cleanser class中的baseS實例（即（b）處），產生的結果如結果1所示。如果把（b）處語句注釋掉，則將調用Base class中的baseS，結果如結果2所示。
結果2：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Base,super.baseS = Base
baseS = ExplicitStatic , super.baseS = Base
3． Base class的初始化
2.1 當你產生derived class對象時，其中會包含base class子對象（subobject）。這個子對象就和你另外產生的base class對象一模一樣。
2.2 通過super()可調用base class的構造函數，但必須放在構造函數的第一行，并且只能在構造函數中運用。
2.3 初始化順序為：
1） 加載代碼（.class文件）
2） 初始化class的靜態成員，初始化順序了"從里到外"，即從base class開始。
3） 在derived class的構造函數中調用base class的構造函數。
如果在derived class的構造函數中沒有通過super()顯式調用調用base class的構造函數，編譯器會調用bass class的default構造函數并自動生成相應的調用語句，從而產生一個base class實例。如果在derived class的構造函數中通過super()顯示調用了父類的構造函數，則調用所指定的構造函數。調用構造函數的調用順序是"從里到外"。
4） 調用derived class的構造函數。
＊＊：當base class沒有default構造函數時，必須在derived class的構造函數中通過super顯示調用base class的構造函數。
例：下面代碼的初始化過程為：
1） 裝載ExplicitStatic的代碼（裝載ExplicitStatic.class文件）。
2） 發現ExplicitStatic有關鍵字extends，裝載ExplicitStatic的base class的代碼（裝載Cleanser.class文件）。
3） 發現Cleanser有關鍵字extends，裝載Cleanser的base class的代碼（裝載Base.class文件）。
4） 初始化Base class中的靜態成員。
5） 初始化Cleanser class中的靜態成員。
6） 初始化ExplicitStatic class中的靜態成員。
如果把（c）處的代碼注釋掉，那么初始化工作到此就結束了。
7） 為ExplicitStatic對象分配存儲空間，并把存儲空間初始化為0。
8） 在ExplicitStatic class的構造中調用super("ExplicitStatic")（在ExplicitStatic class的構造函數中顯式調用父類的構造函數），試圖產生一個Cleanser class實例。
9） 為Cleanser對象分配存儲空間，并把存儲空間初始化為0。
10） 由于Cleanser class又是繼承自Base class，會在Cleanser class的構造函數中通過super()（由于沒有顯式調用父類的構造函數，所以自動調用父類的default構造函數）調用父類的構造函數，試圖產生一個Cleanser class實例。
11） 產生一個Base class實例。先初始化成員變量，再調用構造函數。
12） 回到Cleanser class，產生一個實例。首先初始化Cleanser class中的成員數據，再執行構造函數Cleanser(String a)中的其余部分。
13） 回到ExplicitStatic class，產生一個實例。首先初始化ExplicitStatic class中的成員數據，再執行構造函數ExplicitStatic ()中的其余部分（System.out.println("ExplicitStatic()")）。
class Base{
static int s1 = prt("s1 initialized.", 11);
int i1 = prt("i1 initialized.", 12);
Base(){
System.out.println("Base()");
System.out.println("s1 = " + s1 + " ,i1 = " + i1);
draw();//（d）
}
void draw(){
System.out.println("base.draw：s1 = " + s1 + " ,i1 = " + i1);
}
static int prt(String s, int num) {
System.out.println(s);
return num;
}
}
class Cleanser extends Base{
static int s2 = prt("s2 initialized.", 21);
int i2 = prt("i2 initialized.", 22);
Cleanser(){
System.out.println("Cleanser()");
System.out.println("s2 = " + s2 + " ,i2 = " + i2);
}
Cleanser(String a){
//super();（b）
System.out.println("Cleanser(" + a + ")");
System.out.println("s2 = " + s2 + " ,i2 = " + i2);
}
void draw(){
System.out.println("Cleanser.draw：s2 = " + s2 + " ,i2 = " + i2);
}
}
public class ExplicitStatic extends Cleanser{
static int s3 = prt("s3 initialized.", 31);
int i3 = prt("i3 initialized", 31);
ExplicitStatic(){
super("ExplicitStatic");//（a）
System.out.println("ExplicitStatic()");
System.out.println("s3 = " + s3 + " ,i3 = " + i3);
}
public static void main(String[] args){
ExplicitStatic x = new ExplicitStatic();//（c）
}
}
結果：
s1 initialized.
s2 initialized.
s3 initialized.
//如果把（c）處的代碼注釋掉，輸出結果到此為止，不會輸出下面結果
i1 initialized.
Base()
s1 = 11 ,i1 = 12
Cleanser.draw：s2 = 21 ,i2 = 0//（d）處結果
i2 initialized.
Cleanser(ExplicitStatic)//（a）處結果
s2 = 21 ,i2 = 22
i3 initialized
ExplicitStatic()
s3 = 31 ,i3 = 31
由于在Base()中調用draw()時，Cleanser中的i2還未進行初始化，而在為Cleanser對象分配存儲空間時，把存儲空間初始化為0，所以此時i2為0。
2.4 代碼及結果中的（a）說明了是先產生當前class的base class的實例，否則在derived class中無法調用base class的成員。在調用Cleanser class的構造函數Cleanser(String a)時，在Cleanser(String a)中沒有用super顯式調用Base class的構造函數，所以系統會自動生成調用Base class的default構造函數的語句，如（b）。
4． 組合與繼承之間的快擇
. 1）繼承表示的是一種"is-a（是一個）"的關系，如貨車是汽車中的一種；組合表示的是一種"has-a（有一個）"的關系，如汽車有四個輪子。
2）是否需要將新的class向上轉型為base class。
5． 在繼承中的訪問權限
protect變量能被子孫類所調用。如Base class中的baseS能被Cleanser class和ExplicitStatic class調用。
class Base{
protected String baseS = "Base";
//private String baseS = "Base";
Base(){System.out.println("Base()");}
}
class Cleanser extends Base{
protected String baseS = "Cleanser";
public String s = new String("Cleanser");
Cleanser(){
System.out.println("Cleanser(): " + s);
}
Cleanser(String a){
System.out.println("Cleanser(" + a + "): s = " + s );
}
}
public class ExplicitStatic extends Cleanser{
String s2 = s;
String baseS = super.baseS;
ExplicitStatic(){
super("ExplicitStatic");
System.out.println("ExplicitStatic():s2 = " + s2 + ", baseS = "
+ baseS + "super.baseS = " + super.baseS);
baseS = "ExplicitStatic";
System.out.println("baseS = " + baseS + " , super.baseS = " + super.baseS);
}
public static void main(String[] args){
ExplicitStatic x = new ExplicitStatic();
}
}
結果：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser, super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
二．關鍵字final
1．Final data
1.1 final data
1）當基本型別被定義為final，表示它的數據值不能被改變。如
final int i = 9;
i++;//編譯錯誤，不能改變I的值
2) 當object reference被定義為final時，不能改變的只是reference而不是對象本身。如
class Value{ int i = 1;
}
public class ExplicitStatic extends Cleanser{
public static void main(String[] args){
final Value v = new Value();//v.i = 1
v.i++;//v.i = 2
//v = new Value();
}
}
由于v為final，所以不能通過new Value()使v重新指向一個對象；但是v所指向的對象的值是可以改變的（v.i++）。
1.2 blank finals
我們可以將數據成員聲明為final但不給予初值，這就是blank finals。但blank finals必須且只能在構造函數中進行初始化。
public class ExplicitStatic {
final int ib;
final int i = 1;
ExplicitStatic()
{
ib = 2;//（a）
//i = 3; （b）
System.out.println("i = " + i + ", ib = " + ib);
}
public static void main(String[] args){
ExplicitStatic ex = new ExplicitStatic();
}
}
ib為blank finals，所以可以在構造函數中進行初始化。如果把（a）處的代碼注釋掉，則ib沒有初值，編譯出錯。而i在定義處已進行了初始化，則不能改變i的值，（b）處的代碼編譯錯誤。
＊＊：非blank finals成員即使在構造函數中也不能更改其值
2．Final methods
1）被聲明為final的函數不能被覆寫
2）class中所有private函數自然而然會是final。
3． Final classes
1）當一個class被聲明為final時，表示它不能被繼承，但class的數據成員不是final，可以被改變。如
class SmallBrain{}
final class Dinosaur{
int i = 7;
int j = i;
SmallBrain x = new SmallBrain();
void f(){};
}
//不能繼承final函數
//class Further extends Dinosaur{}
public class ExplicitStatic{
public static void main(String[] args){
Dinosaur n = new Dinosaur();
n.f();
n.i = 40;//final class中的non-final數據成員可以被改變
n.j++;
}
}
2）final class中的所有函數也都自然是final，因為沒有人能夠加以覆寫。
第7章 多態
一．再探向上轉型（upcasting）
將某個object reference視為一個"reference to base type"的動作，稱為向上轉型。
1． Upcasting后調用某個函數時，如果derived class中覆寫了該函數，則會調用derived class中的函數；否則，會調用base class中的函數。如
class First{
public void prt(){
System.out.println("First");
}
}
class Second extends First{
//（a）
public void prt(){
System.out.println("Second");
}
}
public class ExplicitStatic{
public static void main(String[] args){
First n = new Second();
n.prt();;
}
}
結果為Second。如果當Second class中的prt()函數注釋掉，將輸出First。
2． 向上轉型后只能調用base class中被derived class覆寫的函數。
/*
abstract class First{
int i = 122;
public void prt(){
System.out.println("First.i = " + i);
}
public abstract void prt(First f);
}
class Second extends First{
public void prt(){
System.out.println("Second.i = " + i);
}
public void prt(First i)
{
}
public void prt(int i)
{
}
}
public class ExplicitStatic{
public static void main(String[] args){
First n = new Second();
n.prt(2);;
}
}
*/
class First{
public void prt(){
System.out.println("First");
}
}
class Second extends First{
//（a）
public void prt(){
System.out.println("Second");
}
public void prt(int i){//（a）
System.out.println("Second.i = " + i);
}
}
public class ExplicitStatic{
public static void main(String[] args){
First n = new Second();
n.prt(3);
}
}
（a）處的函數只是Second class中的函數，所以不能通過n.prt(3)進行調用。
二．Abstract class和Abstract methods
1． 如果一個class中存在abstract class，則class也必須被聲明為abstract class。
2． abstract class不能被實例化。
3． 如果base class是一個abstract class，那么derived class必須實現base class中所有的abstract methods；否則，derived class也必須被聲明為abstract class。
三．其它要點
1． 純粹繼承與擴充
純粹繼承：只有base class所建議的函數，才被derived class加以覆寫。
擴充：除了覆寫base class的函數，還實現了自己的函數
abstract class First{
public abstract void f();
public abstract void g();
}
//純粹繼承
class Second extends First{
public void f(){}
public void g(){}
}
//擴充
class Third extends First{
public void f(){}
public void g(){}
public void u(){}//base class不存在的函數
}
2． 向下轉型
1） 向下轉型時只能調用base class中被覆寫過的函數
2） 只有本來就為derived class對象時才能正確向下轉弄。
class First{
public void f(){}
public void g(){}
}
class Second extends First{
public void f(){}
public void g(){}
public void u(){}
public void v(){}
}
public class ExplicitStatic{
public static void main(String[] args){
First[] x = {new First(), new Second()};
x[0].f();
x[1].g();
//！x[1].u();class First中不存在函數u()
//((Second)x[0]).f();（a）
((Second)x[1]).u();
}
}