欧美性猛交XXXX免费看蜜桃,成人网18免费韩国,亚洲国产成人精品区综合,欧美日韩一区二区三区高清不卡,亚洲综合一区二区精品久久

打開(kāi)APP
userphoto
未登錄

開(kāi)通VIP，暢享免費電子書(shū)等14項超值服

開(kāi)通VIP

首頁(yè)

好書(shū)

留言交流

下載APP

聯(lián)系客服
Java編程思想讀書(shū)筆記－1（第2－7章）
一．所有對象都必須由你建立
1．    存儲在哪里
1.    寄存器：我們在程序中無(wú)法控制
2.    stack：存放基本類(lèi)型的數據和對象的reference，但對象本身不存放在stack中，而是存放在Heap中
3.    Heap：存放用new產(chǎn)生的數據
4.    Static storage：存放在對象中用static定義的靜態(tài)成員
5.    Constant storage：存放常量
6.    NON-RAM：硬盤(pán)等永久存儲空間
2．    特例：基本型別
基本類(lèi)型數據存放在Stack中，存放的是數據。而產(chǎn)生對象時(shí)，只把對象的reference存放在stack中，用于指向某個(gè)對象，對象本身存放在Heap中。
3．    Java中的數組
當你產(chǎn)生某個(gè)存儲對象的數組時(shí)，真正產(chǎn)生的其實(shí)是存儲reference的數組。引數組建立后，其中的每一個(gè)reference都會(huì )被自動(dòng)設為null，表示“不指向任何對象”。
二．建立新的數據型別：Class
1．    數據成員和函數
1.1    基本成員的缺省值
1）    當class的某個(gè)成員屬于基本型別時(shí)，即使你沒(méi)有為它提供初值，Java仍保證它有一個(gè)缺省值。
2）    只有當變量身份是“class內的成員時(shí)，Java才保證為該變量提供初值。
三．函數（Mehtods），引數（arguments），返回值（return values）
1．    引數列
當引數傳遞的是對象時(shí)，傳遞的是對象的reference。
四．注解用內嵌式文檔
Java提供兩種注解風(fēng)格：/*XXXX*/、//XXXX
第3章    控制程序流程
一．使用Java運算符
1.關(guān)系運算符
1.） 當對兩個(gè)對象運用關(guān)系運算符進(jìn)行比較時(shí)，比較的是object reference，如：
java/lang/Integer.java/lang/Integer.
java/lang/Integer.java/lang/Integer.
java/lang/System.
結果為false，因為兩個(gè)object reference（n1和n2）值是不同的
2） quals()的缺省行為也是拿referenct來(lái)比較。不過(guò)Java中的class覆寫(xiě)了equals方法，如：
java/lang/Integer.java/lang/Integer.
java/lang/Integer.java/lang/Integer.java/lang/System.2．    邏輯運算符
1）    只能將and、or、not施用于boolean值身上。如果邏輯運算符兩邊的值存在non-boolean值，將會(huì )出錯，如：
int test1 = 1;
java/lang/System.3．    位移運算符
如果所操作的位移對象是char、byte、short，位移動(dòng)作發(fā)生之前，其值會(huì )先被晉升為int，運算結果會(huì )是int。
二．流程控制
1．    迭代（iteration）
1.1    逗號運算符
逗號運算符只能用于for循環(huán)的控制表達式中的initialization和step兩部分中，如：for(int i=0, j=I+1; I<5; i++, j=I*2)
1.2    break和continue
break表示退出循環(huán)；continue表示退出本次循環(huán)，回來(lái)循環(huán)起始位置。
1.3    label
label只有放在迭代語(yǔ)句之前才起作用，在label和迭代語(yǔ)句之間插入任何語(yǔ)句都不會(huì )起作用。
2．    Switch
switch中的選擇器必須是int或char型，如：
float i = 2;
switch ( i )//將出錯，因為i不是int或char之一
3．    計算細節
1）    從float或double轉為整數值，總是以完全舍棄小數的方式進(jìn)行。
4．    Math.random()的輸出范圍是[0, 1]。
第4章    初始化和清理
一．以構造函數（constructor）確保初始化的進(jìn)行
如果某個(gè)class具備構造函數，Java便會(huì )在對象生成之際，使用者有能力加以操作之前，自動(dòng)調用其構造函數，于是便能名確保初始化動(dòng)作一定被執行。
二．函數重載（Method overloading）
1．    區分重載函數
由于只能從函數名和函數的引數列來(lái)區分兩個(gè)函數，而重載函數具有相同的函數名稱(chēng)，所以每個(gè)重載函數都必須具備獨一無(wú)二的引數列。
2．    Default構造函數
1）    default構造函數是一種不帶任何引數的構造函數。如果你所開(kāi)發(fā)的class不具任何構造函數，編譯器會(huì )自動(dòng)為你生成一個(gè)default構造函數。
2）    如果你自行定義了任何一個(gè)構造函數（不論有無(wú)引數），編譯器就不會(huì )為你生成default構造函數。
3）    如果定義了一個(gè)class，如
class Bush{
Bush(int I){}
}
當想用new Bush();來(lái)產(chǎn)生class的實(shí)例時(shí)，會(huì )產(chǎn)生錯誤。因為在定義class時(shí)已定義了構造函數，所以編譯器就不會(huì )為class生成default構造函數。當我們用new Bush()來(lái)產(chǎn)生實(shí)例時(shí)，會(huì )嘗試調用default構造函數，但在class中沒(méi)有default構造函數，所以會(huì )出錯。如：
class Sundae
{
Sundae(int i) {}
}
public class IceCream
{
public static void main(java/lang/String.{
//Sundae x = new Sundae();會(huì )編譯出錯，無(wú)構造函數Sundae()
Sundae y = new Sundae(1);
}
}
＊：在定義一個(gè)class時(shí)，如果定義了自己的構造函數，最好同時(shí)定義一個(gè)default構造函數
3．    關(guān)鍵字this
1）    this僅用于函數之內，能取得“喚起此一函數“的那個(gè)object reference。
2）    在構造函數中，通過(guò)this可以調用同一class中別的構造函數，如
public class Flower{
Flower (int petals){}
Flower(java/lang/String.Flower(int petals, Sting ss){
//petals++;調用另一個(gè)構造函數的語(yǔ)句必須在最起始的位置
this(petals);
//this(ss);會(huì )產(chǎn)生錯誤，因為在一個(gè)構造函數中只能調用一個(gè)構造函數
}
}
＊＊：1）在構造調用另一個(gè)構造函數，調用動(dòng)作必須置于最起始的位置
2）不能在構造函數以外的任何函數內調用構造函數
3）在一個(gè)構造函數內只能調用一個(gè)構造函數
4．    Static的意義
無(wú)法在static函數中調用non-static函數（反向可行）。為什么不能呢，我們看下面的例子。
例4.2.4.1
假設能在static函數中調用non-static函數，那么（a）處就將出錯。因為在沒(méi)有產(chǎn)生Movie class實(shí)例之前，在就不存在Movie class內的name實(shí)例，而在getName()中卻要使用name實(shí)例，顯然的錯誤的。
class Movie{
java/lang/String.Movie(){}
public Movie(java/lang/String.public static java/lang/String.}
public class Test{
public static void main(java/lang/String.//下面兩名先產(chǎn)生實(shí)例后再調用getName()沒(méi)有問(wèn)題
//Movie movie1 = new Movie(“movie1”);
//String name1 = movie1.getName();
//下面一名將出錯
//String name2 = Movie.getname(); （a）
}
}
三．清理（cleanup）：終結（finalization）與垃圾回收（garbage collection）
1）你的對象可能不會(huì )被回收
只有當程序不夠內存時(shí)，垃圾回收器才會(huì )啟動(dòng)去回收不再被使用的對象的內存空間。某個(gè)對象所占用的空間可能永遠不會(huì )被釋放掉，因為你的程序可能永遠不會(huì )逼近內存用完的那一刻，而垃圾回收器完全沒(méi)有被啟動(dòng)以釋放你的對象所占據的內存，那些空間便會(huì )在程序終止時(shí)才一次歸還給操作系統
3）    只有在采用原生函數（native methods）時(shí)，才使用finalize()。
四．成員初始化（member initialization）
1）    函數中的變量不會(huì )被自動(dòng)初始化，如
void f(){
int i;
i++;
}
將發(fā)生編譯錯誤，因為i沒(méi)有被初始化。
2）    class的數據成員會(huì )被自動(dòng)初始化，具體情況如下（見(jiàn)P220例子）：
基本型別：boolean：false、char：null（\u0000）、byte：0、short：0、int：0、
long：0 、float：0、double：0
對象（reference）：null
1．    初始化次序
1）    所有變量一定會(huì )在任何一個(gè)函數（甚至是構造函數）被調用之前完成初始化（見(jiàn)P233例子）
2）    在產(chǎn)生一個(gè)class的對象（包含static成員的class的代碼被裝載）時(shí)，首先自動(dòng)初始化class中的static成員變量，再執行所有出現于static數據定義處的初始化動(dòng)作，最后執行static block，所有這些初始化操作只在第一次生成該對象時(shí)進(jìn)行。
3）    自動(dòng)初始化class中的其它成員變量。
4）    執行所有出現于數據定義處的初始化動(dòng)作。如：int i=1；的執行順序是先把I自動(dòng)初始化為0，再執行數據定義處的初始化動(dòng)作，初始化為1。
5）    執行non-static block
6）    調用構造函數。
例：
class Cup{
Cup(int marker){
java/lang/System.}
void f(int marker){
java/lang/System.}
}
class Cups{
static Cup c1 = new Cup(11);
static Cup c2;
Cup c3 = new Cup(33);
Cup c4;
{
c3 = new Cup(3);
c4 = new Cup(4);
}
static{
c1 = new Cup(1);
c2 = new Cup(2);
}
Cups(){
java/lang/System.}
}
public class ExplicitStatic{
public static void main(java/lang/String.java/lang/System.Cups.c1.f(99);
}
static Cups x = new Cups();
static Cups y = new Cups();
}
結果為：
Cup(11)
Cup(1)
Cup(2)
Cup(33)
Cup(3)
Cup(4)
Cups()
Cup(33)
Cup(3)
Cup(4)
Cups()
Inside main()
f(99)
2．    Array的初始化
1）    定義數組時(shí)不能指定大小。如int[4] iArr = {0, 1, 2, 3};，由于指定了數組的大小，會(huì )編譯出錯。
2）    數組只是存放reference的數組。Array與non-array的結構圖如下：
a）對于基本型別數據，存放的是數據。如
int i = 5;
b）對于class變量，存放的是reference，這個(gè)reference指向一個(gè)存有class實(shí)例的內存空間。如
java/lang/String.變量s存放的是一個(gè)reference，這個(gè)reference指向一個(gè)存有String實(shí)例的內存空間。
c）對于基本型別數組，存放的是reference數組，數組中的每一個(gè)reference都指向一個(gè)class實(shí)例的內存空間。如
int[] ia = {10, 11, 12};
數組ia存放的是一個(gè)reference數組，數組中的每一個(gè)reference都指向一個(gè)的int實(shí)例的內存空間。
d）對于class數組，存放的是reference數組，數組中的每一個(gè)reference都指向一個(gè)的class實(shí)例的內存空間。如
java/lang/String.數組sa存放的是一個(gè)reference數組，數組中的每一個(gè)reference都指向一個(gè)的String實(shí)例的內存空間。
3）    任何數組都要進(jìn)行初始化，使用沒(méi)有進(jìn)行初始化的數組會(huì )產(chǎn)生運行時(shí)錯誤，如：
int[] iArr;
java/lang/System.數組初始化可在任何地方，可用以下方法來(lái)對數組進(jìn)行初始化：
a）    int[] iArr = {1,1,1,1};//數組的長(cháng)度為{}元素的個(gè)數
b）    int i = 10;
int[] iArr = new int[i];//數組的長(cháng)度可為變量（這在C/C++中不行）
java/lang/System.java/lang/Integer.java/lang/Integer.java/lang/System.I）    對于基本型別數組，new產(chǎn)生的是用于存放數據的數組；否則，產(chǎn)生的只是存放reference的數組。
II）    new可用來(lái)初始化基本型別的數組，但不能產(chǎn)生non-array的　　基本型別數據。
c）    int[] iArr = new int[]{1,1,1,1};
java/lang/Integer.java/lang/Integer.java/lang/Integer.java/lang/Integer.3．    多維數組（Multidimensional）arrays
多維數組每一維的大小可以不一樣，如：
java/lang/Integer.a5 = new java/lang/Integer.for(int i=0; i<a5.length; i++)
a5[i] = new java/lang/Integer.for(int j=0; j<a5[i].length
a5[i][j] = new java/lang/Integer.第5章    隱藏實(shí)現細節
一．Java訪(fǎng)問(wèn)權限飾詞（access specifiers）
Java有public、protect、friendly、private四種訪(fǎng)問(wèn)權限，并且這四訪(fǎng)問(wèn)權限的訪(fǎng)問(wèn)范圍越來(lái)越小。
1．    friendly
1）    果一個(gè)class內的數據成員或方法沒(méi)有任何權限飾詞，那么它的缺省訪(fǎng)問(wèn)權限就是friendly。同一個(gè)package內的其它所有classes都可以訪(fǎng)問(wèn)friendly成員，但對package以外的classes則形同private。
2）　　對于同一個(gè)文件夾下的、沒(méi)有用package的classes，Java會(huì )自動(dòng)將這些classes初見(jiàn)為隸屬于該目錄的default package，可以相互調用class中的friendly成員。如以下兩個(gè)class分別在同一個(gè)文件夾的兩個(gè)文件中，雖然沒(méi)有引入package，但隸屬于相同的default package。
class Sundae{
//以下兩個(gè)方法缺省為friendly
Sundae(){}
java/lang/Void.java/lang/System.}
public class IceCream{
public static void main(java/lang/String.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(java/lang/String.// Sundae class中構造函數Sundae()是private，
// 所以不能用它進(jìn)行初始化
//Sundae x = new Sundae();
Sundae y = new Sundae(1);//Sundae(int)是friendly，可以在此調用
Sundae z = Sundae.makASundae();
}
}
4．    protected：具有friendly訪(fǎng)問(wèn)權限的同時(shí)，又能被subclass（當然包括子孫類(lèi)，即子類(lèi)的子類(lèi)）所訪(fǎng)問(wèn)。即，既能被同一package中的classes訪(fǎng)問(wèn)，又能被protected成員所在class的subclass訪(fǎng)問(wèn)。
二．Class的訪(fǎng)問(wèn)權限
1．Class同樣具有public、protect、friendly、private四種訪(fǎng)問(wèn)訪(fǎng)問(wèn)權限：
1）public：在任何地方都可被使用
2）protect、private：除了它自己，沒(méi)有任何class可以使用，所以class不能是
protected或private（inner class除外）
3）    friendly：同一個(gè)package中的classes能用
2．    如何調用構造函數被聲明為private的class
1）    用static函數
2）    用Singteton模式
class Soup{
private Soup(){}
//（1）靜態(tài)函數方法
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(java/lang/String.java/lang/System.}
}
public class Lunch{
public static void main(java/lang/String.//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某個(gè)函數時(shí)，只能覆寫(xiě)base class中的接口，即base class中的public或protected或friendly函數。如果試圖overriding一個(gè)private函數，雖然編譯通過(guò)，但實(shí)際上你只是在derived class中添加了一個(gè)函數。如
class Cleanser{
private void prt(){//（b）
java/lang/System.}
}
public class ExplicitStatic extends Cleanser{
public void prt(){
java/lang/System.}
public static void main(java/lang/String.Cleanser x = new ExplicitStatic();
x.prt();//（a）
}
}
因為Cleanser中的prt()是private，所以不能在其derived　class中被覆寫(xiě)。ExplicitStatic中的prt()只是ExplicitStatic中的一個(gè)函數，所以當試圖在（a）處通過(guò)多態(tài)來(lái)調用prt()時(shí)，會(huì )發(fā)生錯誤。如果把（b）處的private去掉，則結果為
ExplicitStatic.prt()
2．    Super的使用
1）通過(guò)關(guān)鍵字super可以調用當前class的superclass（父類(lèi)）。
例6.1.1.1
class Base{
Base(){java/lang/System.public void scrub() { java/lang/System.}
class Cleanser extends Base{
private java/lang/String.java/lang/String.public void append(java/lang/String.public void dilute() { append(" dilute()"); }
public void apply() { append(" apply()"); }
public void scrub() { append(" scrub()"); }
public void print() { java/lang/System.Cleanser(){
java/lang/System.}
public static void testStatic(){
java/lang/System.}
public static void main(java/lang/String.Cleanser x = new Cleanser();
x.dilute(); x.apply(); x.scrub(); x.print();
}
}
public class ExplicitStatic extends Cleanser{
ExplicitStatic(){
java/lang/System.}
public void scrub(){
append(" Detergen.scrub()");
super.testStatic();
super.scrub();//調用的是Cleanser.scrub()
}
public void foam() { append(" foam()"); }
public static void main(java/lang/String.ExplicitStatic x = new ExplicitStatic();
x.dilute(); x.apply(); x.scrub(); x.foam();
x.print(); java/lang/System.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）通過(guò)super來(lái)調用superclass中的成員時(shí)，調用的是最近成員。
例6.1.1.2
class Base{
protected java/lang/String.//private String baseS = "Base";
Base(){java/lang/System.}
class Cleanser extends Base{
protected java/lang/String.public java/lang/String.java/lang/String.Cleanser(){
java/lang/System.}
Cleanser(java/lang/String.java/lang/System.}
}
public class ExplicitStatic extends Cleanser{
java/lang/String.java/lang/String.ExplicitStatic(){
super("ExplicitStatic");
java/lang/System.+ baseS + "super.baseS = " + super.baseS);
baseS = "ExplicitStatic";
java/lang/System.}
public static void main(java/lang/String.ExplicitStatic x = new ExplicitStatic();
}
}
結果1：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser,super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
在上面例子中，在三個(gè)class中都存在String bases實(shí)例。在ExplicitStatic中如果直接調用baseS，則實(shí)際調用的是當前類(lèi)ExplicitStatic中的baseS（即（c）處的成員）；如果通過(guò)super.bases來(lái)調用baseS，則調用的是離當前類(lèi)ExplicitStatic最近的baseS成員，即Cleanser class中的baseS實(shí)例（即（b）處），產(chǎn)生的結果如結果1所示。如果把（b）處語(yǔ)句注釋掉，則將調用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    當你產(chǎn)生derived class對象時(shí)，其中會(huì )包含base class子對象（subobject）。這個(gè)子對象就和你另外產(chǎn)生的base class對象一模一樣。
2.2    通過(guò)super()可調用base class的構造函數，但必須放在構造函數的第一行，并且只能在構造函數中運用。
2.3    初始化順序為：
1）    加載代碼（.class文件）
2）    初始化class的靜態(tài)成員，初始化順序了“從里到外”，即從base　class開(kāi)始。
3）    在derived class的構造函數中調用base class的構造函數。
如果在derived class的構造函數中沒(méi)有通過(guò)super()顯式調用調用base class的構造函數，編譯器會(huì )調用bass class的default構造函數并自動(dòng)生成相應的調用語(yǔ)句，從而產(chǎn)生一個(gè)base class實(shí)例。如果在derived class的構造函數中通過(guò)super()顯示調用了父類(lèi)的構造函數，則調用所指定的構造函數。調用構造函數的調用順序是“從里到外”。
4）    調用derived class的構造函數。
＊＊：當base class沒(méi)有default構造函數時(shí)，必須在derived class的構造函數中通過(guò)super顯示調用base class的構造函數。
例：下面代碼的初始化過(guò)程為：
1）    裝載ExplicitStatic的代碼（裝載ExplicitStatic.class文件）。
2）    發(fā)現ExplicitStatic有關(guān)鍵字extends，裝載ExplicitStatic的base　class的代碼（裝載Cleanser.class文件）。
3）    發(fā)現Cleanser有關(guān)鍵字extends，裝載Cleanser的base　class的代碼（裝載Base.class文件）。
4）    初始化Base class中的靜態(tài)成員。
5）    初始化Cleanser class中的靜態(tài)成員。
6）    初始化ExplicitStatic class中的靜態(tài)成員。
如果把（c）處的代碼注釋掉，那么初始化工作到此就結束了。
7）    為ExplicitStatic對象分配存儲空間，并把存儲空間初始化為0。
8）    在ExplicitStatic class的構造中調用super("ExplicitStatic")（在ExplicitStatic class的構造函數中顯式調用父類(lèi)的構造函數），試圖產(chǎn)生一個(gè)Cleanser class實(shí)例。
9）    為Cleanser對象分配存儲空間，并把存儲空間初始化為0。
10）    由于Cleanser class又是繼承自Base class，會(huì )在Cleanser class的構造函數中通過(guò)super()（由于沒(méi)有顯式調用父類(lèi)的構造函數，所以自動(dòng)調用父類(lèi)的default構造函數）調用父類(lèi)的構造函數，試圖產(chǎn)生一個(gè)Cleanser class實(shí)例。
11）    產(chǎn)生一個(gè)Base class實(shí)例。先初始化成員變量，再調用構造函數。
12）    回到Cleanser class，產(chǎn)生一個(gè)實(shí)例。首先初始化Cleanser class中的成員數據，再執行構造函數Cleanser(String a)中的其余部分。
13）    回到ExplicitStatic class，產(chǎn)生一個(gè)實(shí)例。首先初始化ExplicitStatic class中的成員數據，再執行構造函數ExplicitStatic ()中的其余部分（System.out.println(“ExplicitStatic()”)）。
class Base{
static int s1 = prt("s1 initialized.", 11);
int i1 = prt("i1 initialized.", 12);
Base(){
java/lang/System.java/lang/System.draw();//（d）
}
void draw(){
java/lang/System.}
static int prt(java/lang/String.java/lang/System.return num;
}
}
class Cleanser extends Base{
static int s2 = prt("s2 initialized.", 21);
int i2 = prt("i2 initialized.", 22);
Cleanser(){
java/lang/System.java/lang/System.}
Cleanser(java/lang/String.//super();（b）
java/lang/System.java/lang/System.}
void draw(){
java/lang/System.}
}
public class ExplicitStatic extends Cleanser{
static int s3 = prt("s3 initialized.", 31);
int i3 = prt("i3 initialized", 31);
ExplicitStatic(){
super("ExplicitStatic");//（a）
java/lang/System.java/lang/System.}
public static void main(java/lang/String.ExplicitStatic x = new ExplicitStatic();//（c）
}
}
結果：
s1 initialized.
s2 initialized.
s3 initialized.
//如果把（c）處的代碼注釋掉，輸出結果到此為止，不會(huì )輸出下面結果
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()時(shí)，Cleanser中的i2還未進(jìn)行初始化，而在為Cleanser對象分配存儲空間時(shí)，把存儲空間初始化為0，所以此時(shí)i2為0。
2.4    代碼及結果中的（a）說(shuō)明了是先產(chǎn)生當前class的base class的實(shí)例，否則在derived class中無(wú)法調用base class的成員。在調用Cleanser class的構造函數Cleanser(String a)時(shí)，在Cleanser(String a)中沒(méi)有用super顯式調用Base class的構造函數，所以系統會(huì )自動(dòng)生成調用Base class的default構造函數的語(yǔ)句，如（b）。
4．    組合與繼承之間的快擇
.    1）繼承表示的是一種“is-a（是一個(gè)）”的關(guān)系，如貨車(chē)是汽車(chē)中的一種；組合表示的是一種“has-a（有一個(gè)）”的關(guān)系，如汽車(chē)有四個(gè)輪子。
2）是否需要將新的class向上轉型為base class。
5．    在繼承中的訪(fǎng)問(wèn)權限
protect變量能被子孫類(lèi)所調用。如Base class中的baseS能被Cleanser class和ExplicitStatic class調用。
class Base{
protected java/lang/String.//private String baseS = "Base";
Base(){java/lang/System.}
class Cleanser extends Base{
protected java/lang/String.public java/lang/String.java/lang/String.Cleanser(){
java/lang/System.}
Cleanser(java/lang/String.java/lang/System.}
}
public class ExplicitStatic extends Cleanser{
java/lang/String.java/lang/String.ExplicitStatic(){
super("ExplicitStatic");
java/lang/System.+ baseS + "super.baseS = " + super.baseS);
baseS = "ExplicitStatic";
java/lang/System.}
public static void main(java/lang/String.ExplicitStatic x = new ExplicitStatic();
}
}
結果：
Base()
Cleanser(ExplicitStatic): s = Cleanser
ExplicitStatic():s2 = Cleanser, baseS = Cleanser, super.baseS = Cleanser
baseS = ExplicitStatic , super.baseS = Cleanser
二．關(guān)鍵字final
1．Final data
1.1　final data
1）當基本型別被定義為final，表示它的數據值不能被改變。如
final int i = 9;
i++;//編譯錯誤，不能改變I的值
2) 當object　reference被定義為final時(shí)，不能改變的只是reference而不是對象本身。如
class Value{
int i = 1;
}
public class ExplicitStatic extends Cleanser{
public static void main(java/lang/String.final Value v = new Value();//v.i = 1
v.i++;//v.i = 2
//v = new Value();
}
}
由于v為final，所以不能通過(guò)new Value()使v重新指向一個(gè)對象；但是v所指向的對象的值是可以改變的（v.i++）。
1.2　blank finals
我們可以將數據成員聲明為final但不給予初值，這就是blank　finals。但blank　finals必須且只能在構造函數中進(jìn)行初始化。
public class ExplicitStatic {
final int ib;
final int i = 1;
ExplicitStatic()
{
ib = 2;//（a）
//i = 3;?。╞）
java/lang/System.}
public static void main(java/lang/String.ExplicitStatic ex = new ExplicitStatic();
}
}
ib為blank　finals，所以可以在構造函數中進(jìn)行初始化。如果把（a）處的代碼注釋掉，則ib沒(méi)有初值，編譯出錯。而i在定義處已進(jìn)行了初始化，則不能改變i的值，（b）處的代碼編譯錯誤。
＊＊：非blank　finals成員即使在構造函數中也不能更改其值
2．Final　methods
1）被聲明為final的函數不能被覆寫(xiě)
2）class中所有private函數自然而然會(huì )是final。
3．    Final　classes
1）當一個(gè)class被聲明為final時(shí)，表示它不能被繼承，但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(java/lang/String.Dinosaur n = new Dinosaur();
n.f();
n.i = 40;//final class中的non-final數據成員可以被改變
n.j++;
}
}
2）final　class中的所有函數也都自然是final，因為沒(méi)有人能夠加以覆寫(xiě)。
第7章    多態(tài)
一．再探向上轉型（upcasting）
將某個(gè)object　reference視為一個(gè)“reference　to　base　type“的動(dòng)作，稱(chēng)為向上轉型。
1．    Upcasting后調用某個(gè)函數時(shí)，如果derived　class中覆寫(xiě)了該函數，則會(huì )調用derived　class中的函數；否則，會(huì )調用base　class中的函數。如
class First{
public void prt(){
java/lang/System.}
}
class Second extends First{
//（a）
public void prt(){
java/lang/System.}
}
public class ExplicitStatic{
public static void main(java/lang/String.First n = new Second();
n.prt();;
}
}
結果為Second。如果當Second　class中的prt()函數注釋掉，將輸出First。
2．    向上轉型后只能調用base　class中被derived　class覆寫(xiě)的函數。
/*
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(){
java/lang/System.}
}
class Second extends First{
//（a）
public void prt(){
java/lang/System.}
public void prt(int i){//（a）
java/lang/System.}
}
public class ExplicitStatic{
public static void main(java/lang/String.First n = new Second();
n.prt(3);
}
}
（a）處的函數只是Second　class中的函數，所以不能通過(guò)n.prt(3)進(jìn)行調用。
二．Abstract　class和Abstract　methods
1．    如果一個(gè)class中存在abstract　class，則class也必須被聲明為abstract　class。
2．    abstract　class不能被實(shí)例化。
3．    如果base　class是一個(gè)abstract　class，那么derived　class必須實(shí)現base　class中所有的abstract　methods；否則，derived　class也必須被聲明為abstract　class。
三．其它要點(diǎn)
1．    純粹繼承與擴充
純粹繼承：只有base　class所建議的函數，才被derived　class加以覆寫(xiě)。
擴充：除了覆寫(xiě)base　class的函數，還實(shí)現了自己的函數
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）    向下轉型時(shí)只能調用base　class中被覆寫(xiě)過(guò)的函數
2）    只有本來(lái)就為derived　class對象時(shí)才能正確向下轉弄。
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(java/lang/String.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();
}
}
-------------------------------------
本站僅提供存儲服務(wù)，所有內容均由用戶(hù)發(fā)布，如發(fā)現有害或侵權內容，請點(diǎn)擊舉報。
打開(kāi)APP，閱讀全文并永久保存 查看更多類(lèi)似文章
猜你喜歡
類(lèi)似文章
1.如何反射以及作用
Java 反射 使用總結
java核心技術(shù)之reflect(一)：一個(gè)系統學(xué)習r(shí)eflect的Demo(精)
java中的反射總結
Java 反射
Java學(xué)習之神奇的初始化
更多類(lèi)似文章 >>
生活服務(wù)
分享 收藏 導長(cháng)圖 關(guān)注 下載文章
綁定賬號成功
后續可登錄賬號暢享VIP特權！
如果VIP功能使用有故障，
可點(diǎn)擊這里聯(lián)系客服！

聯(lián)系客服

欧美性猛交XXXX免费看蜜桃,成人网18免费韩国,亚洲国产成人精品区综合,欧美日韩一区二区三区高清不卡,亚洲综合一区二区精品久久