======================================= 華麗的分割線 ====================================2013-12-28 日 更新
我之前有看過孫鑫的JAVA視頻，雖然只看了前三集，但是孫鑫老師的視頻是壓縮講的，一個視頻兩個半鐘，設計到的知識點很多，
前三個視頻已經包含了《Java4Android》這套視頻前二十三集的內容，而且講的都是原理性的知識。只是孫鑫老師講的比較死板，
舉的例子不夠生動。而 《Java4Android》mars老師講的很生動，可惜都是表面性的東西，例如他的第十七集，對于靜態變量、
靜態函數的為什么不創建對象就能調用的解釋。而孫鑫老師在第二集中講的很明確。關于第十七集的心得就是看了孫鑫老師才知道的。
雖然說Java不是我日后的方向，但是既然日后會用上，現在又恰好在學，即使不精通JAVA也要達到熟練的程度吧？不然日后還怎么學
安卓編程。 所以我決定放棄《Java4Android》重學孫鑫老師的JAVA視頻。日后發布的也發布的也將是學孫鑫老師JAVA視頻的學習筆記。
唉，悲劇，這兩套視頻的教學思路不同，知識點的解析而理解也不同，只能重新學孫鑫老師的了。
翻到下面就能看到第21-22集的筆記。
======================================= 華麗的分割線 ====================================
這學期工作太忙，學單片機的時候總是被中斷，讓我很不爽。后來越來越忙就沒有再學了，這段時間還算緩下來了，不過我不想再在我非常認真學單片機的過程中被頻繁中斷，想著日后會用到安卓手機控制單片機，由于學安卓編程需要有JAVA基礎，就先接觸一下JAVA基礎知識，就當充實充實自己的業余生活。
本文記載一些心得中的重點部分，僅用于增強記憶和日后復習使用。 這視頻不錯，講的很生動。搞的我看的就像是看電影一樣總想一直看下去，缺點就算說的太詳細了。。。 第1集至第3集 講的是Java的一些歷史和一些基本的概念，如JDK、JRE、JVM這些。 這里有必要說一下，Java之所以能實現跨平臺是因為JVM虛擬機的存在。我們寫的源代碼（.java）不需要關心它會在什么平臺下執行，它會被編譯成中間文件（.calss），而這個中間文件是和平臺無關的，主要是給JVM解釋執行的。只要該平臺支持JVM，那么也就支持Java了，每一個平臺下的JVM都不一樣，但是它們都可以解釋并執行中間文件。Windows平臺有Windows平臺的JVM，Linux有Liunx下的JVM，說白了，只要能在某一平臺下設計出支持該平臺的JVM，那么該平臺就可以全面支持Java了，而JVM的設計是由Java公司自己完成，我們不需要關心。這就是Java跨平臺的秘密。 第4集： 有意思的變量解釋：（之所以提出來是因為該視頻講的很有意思） 1、計算機是一種極度精確的機器，容不得半點馬虎。 2、它很笨，要計算數據時，首先要指定數據存儲在內存的位置以及空間大小。 基于上述兩點，將一些常用的數據類型都固定大小，如整型(int)占用4個字節，字符型(int)占用2個字節，byte型占用1個字節等等，之所以整出這些基本數據類型都是為了方便寫程序，例如你要存放一個 1025 數值或者你要存放一個字符“夢”，就不需要自己指定要申請多大的內存空間了。 變量的聲明含義： int age; int：變量類型，也就是指明空間大小 age：變量名，存放在內存中的位置標識，這里具體放在哪個位置由系統負責，系統分配好空間后會將該位置與我們的變量關聯起來，相當于給這個位置起一個名字，我們要把數據存放到age，就表明把這個數據放到age所在的內存空間位置. 后面的分號是標識這條語句已經結束。 第5集到第11集 主要是一些基本的程序流向控制 如判斷語句 分支語句 循環語句等。 第12集至第15集 主要面向對象的一些概念： 這集主要解釋什么是面向對象。 這集給我的沖擊很大，以前我是用C語言寫代碼，使用的面向過程的思維去設計程序。面向對象對于我來說是一個全新編程思維。 剛接觸這種思維，可能是因為以前習慣性用面向過程的思維去設計程序，現在有些轉不過彎來。 1、首先確定誰來做，其次確定怎么去做。 2、首先考慮全局，再考慮局部。 3、首先考慮抽象，再考慮具體。 如： 我們用面向對象的思維去給一棟建筑設計一座電梯。首先我們先抽象有這個電梯，然后這個電梯有高度、寬度、有門、有按鍵的屬性，它還會有開門、關門、上升、下降等行為。確定好這些后，那么再考慮開門的方法（行為），這門要在什么時候開，怎么開才安全，門在什么時候后關，怎么關才安全，電梯什么時候上升、什么時候下降，怎么上升、怎么下降，要上升或下降到第幾層等這些行為（這時候相當于定義好這個類）。定義好這些后，再根據這棟建筑去具體化這個電梯，例如這建筑有幾層樓，每層樓高度是多少等，這關乎電梯的上升、下降的高度等。（這個時候相當于引用電梯這個類創建出這個對象，并初始化這個對象的一些參數）。不同的建筑需要具體化合適這棟建筑的電梯。 第13集 類和對象 類是抽象的，對象是具體的。 類里面有狀態、行為。 類里面的變量就是記錄狀態，而里面的函數則是行為（方法）。 舉個例子： 類相當于是指明狗這種種類的一系列特征：身高、體重、毛色等一些屬性，還有怎么吠叫、怎么吃飯等一些行為。它是一個抽象的東西，就好像我們說到狗，腦子里面就會想起狗的這些特征，滿足這些特征才會被我們認為是狗，但并不具體到是哪一種狗，哈巴狗？藏獒？還是流浪狗？它們都是狗。 而對象則是具體到哪一種狗，藏獒和哈巴狗叫的聲音不太一樣，跑的也不一樣，喜歡吃的食物也不同。 類和對象就好像我們需要一條狗（狗這種種類），這就選擇了狗這個類。至于是什么狗，要看自己的需求，假設我們要一條藏獒，那么它應該是很彪悍的，發出的叫聲應該是讓人很害怕的。那么這時候我們創建這個類的對象，設置這只狗的身高、體重、毛的顏色等一些屬性，然后我們要這只狗吠叫，就使用里面吠叫的方法。 定義類的方法： Class 類名 ｛ 屬性；—> 屬性也叫成員變量，用來描述類的狀態，如上面狗的身高、體重、毛色等。 方法；—> 方法也叫成員方法，用來描述類的行為，如上面狗的吠叫，吃飯等。。。 ｝ 生成對象的方法和流程。 例：Dog dog = new Dog(); Dog dog：系統會在棧內存空間創建Dog的一個引用名，為dog。 new Dog()：系統會在堆內存空間創建Dog的一個對象。 =：賦值號就是把在堆內存空間創建的Dog對象關聯到dog 這個引用名。 當我們使用的時候就是需要用引用名去操作這個對象。
第14集：
下面這個例子很形象的表現出類與對象的關系。
class Dog // 定義狗這一類 { String Zhonglei; // 狗的品種 String name; // 狗的名字 int age; // 狗的年齡 String color; // 狗的毛色 String Xingbie; // 性別 void jump（） ｛ System.out.Println(“跳啊跳啊。。。我拼命跳。。。”); ｝ } class Test { Public static void main(String args[]) { Dog Mydog = new Dog（）; // 創建一只狗 Mydog.Zhonglei = “牧羊犬”; // 我喜歡這品種 Mydog.name = “小黑”; // 這狗就叫小黑吧。 Mydog.colcr = “黑色”; // 它的毛色是黑色的 Mydog.age = 1; // 它1歲了
Mydog.Xingbie = “雄性”; // 公的 Mydog.jump(); // 這只1歲的黑色小黑跳起來了。 Dog Mydog1= new Dog（）; // 小黑太孤單了，給它創建個伴侶吧。 Mydog.Zhonglei = “牧羊犬”; Mydog.name = “小白”; // 這狗就叫小白吧。 Mydog.colcr = “白色”; // 它的毛色是白色的 Mydog.age = 1; // 它也是1歲。
Mydog.Xingbie = “雌性”; // 母的 Mydog.jump(); // 這只1歲的白色小狗也開心跳起來了。 } } 用著這種設計思想，感覺自己就像是上帝，哈哈。 Mydog 和 Mydog1 都是狗，但它們不是同一只狗，而是兩只不太一樣的狗。像上面的例子，還可以再創建一只藏獒（創建對象），藏獒和牧羊犬都是同一個物種，但卻不是同一個品種。很靈活。 Dog就是抽象的，而創建的對象則是具體的。就上面的例子來說，棧空間內會存放兩個對象名，堆空間內存放著兩個對象。 匿名對象： 如：new Dog().jump(); 因為沒有給引用名，所以它是一次性的，不知道匿名對象算不算是創建了一只狗又扔了它。。。真狠心。。。。。
第15集：
函數重載：一個類中的有多個函數名一樣，但參數數量、類型不同的函數。系統會根據我們所傳遞的參數去判斷我們要調用的是哪一個函數。 構造函數：必須和類名相同，利用函數重載，可以有多個構造函數。構造函數會在new創建一個對象時自動被調用，調用哪個構造函數取決自己new 類名(參數)所傳遞的參數，一般用于給成員變量賦初始值。如果沒有寫構造函數，編譯器會自動添加一個無參數、無函數體的空構造函數。構造函數是木有返回值滴。 第16集 （this的作用和使用方法）
this（參數）：調用本類中構造函數，只能寫在函數中的第一句。
this.變量：在函數中訪問本類中的變量，一般區分函數中有和類中同名的變量。
this.函數：調用本類中的函數。
第17集（關于靜態 static）
靜態變量和靜態函數可以在不new（創建）對象的情況下直接調用。 例： class Test { static int i ; static void fun() { System.out.println(“static fun Run....”); } } class main { public static void main(String args[]) { Test.i = 10; Test.fun(); } } 被聲明為static的變量或函數都會在該類被裝載時會被創建在堆棧里。也就是說不需要我們new，內存中已經有它們的存在。而且它們都是被所有這類的對象所共享。 靜態變量或靜態函數，之所以可以在未用new在堆空間里創建新的對象時，卻仍可以通過類名使用，是因為它在程序運行時已經在堆內存分配好空間，也就是說無論有沒有new，那空間都已經分配好并且不會變動。 如視頻中的例子：在Person類里面的static int i； 在類第一次被裝載時 i 這個變量已經在堆空間分配好并且不會變動，所以當我們使用這個靜態變量時不需要重新new對象，即使new了對象，也不會再為它在堆空間重新分配內存，無論我們new了多少個Person對象，它們都是共享同一個 i 空間。所以當改動 i 的值時，自然而然的看起來是像影響到其他對象里面 的 i 值。 而 int i；這種非靜態變量則必須是在調用new時才會在堆空間分配好內存。而且每次new的空間位置都不一樣，都是一份拷貝，每一份拷貝都關聯不同的Person對象，這樣就變成即使修改了第一個Person對象里的i，也不會影響第二個Person對象里面的i。
關于匿名靜態函數：
匿名靜態函數沒有名字的函數。 static { System.out.println(“我是匿名靜態函數”); } 匿名靜態函數在使用類的時候會被調用，而構造函數則是在new時被調用。
1、Test.i = 10 或 Test.fun() 匿名靜態函數會被調用
2、Test t = new Test() 匿名靜態函數會被調用后，構造函數才會被調用。
第18集 繼承
通過關鍵字 extends 來繼承某一類，被繼承的類為父類，繼承的類為子類。 子類擁有父類所有的成員變量和成員函數，但不擁有構造函數。 子類可以有自己的成員變量和函數，感覺是在父類的基礎上是增加狀態和行為。是父類的一種擴展。 例子：
class myzl extends Gog // myzi 是子類的名字，Gog是父類，是已經存在的類 { } 第19集super關鍵字
由于子類是不能繼承父類的構造函數，所以可以使用super這個關鍵字去調用父類的構造函數，當然這個super不但可以調用父類的構造函數還可以在父子類之間函數名、變量相同的情況下，在子類調用父類的函數或訪問父類的變量。super和this差不多，都是用于區分同名函數或變量。 super() ：調用父類的無參構造函數 super (參數)：調用父類的有參構造函數 super和this的異同：(網上資料)
1)super（參數）：調用基類中的某一個構造函數（應該為構造函數中的第一條語句）
2)this（參數）： 調用本類中另一種形成的構造函數（應該為構造函數中的第一條語句）
3)super：它引用當前對象的直接父類中的成員（用來訪問直接父類中被隱藏的父類中成員 數據或函數，基類與派生類中有相同成員定義時如：super.變量名，super.成員 函數據名（實參）
4)this：它代表當前對象名（在程序中易產生二義性之處，應使用this來指明當前對象；
如果函數的形參與類中的成員數據同名，這時需用this來指明成員變量名）
5）調用super()必須寫在子類構造方法的第一行，否則編譯不通過。每個子類構造方法
的第一條語句，都是隱含地調用super()，如果父類沒有這種形式的構造函數，那么
在編譯的時候就會報錯。
6）super()和this()類似,區別是，super()從子類中調用父類的構造方法，this()在同一類內
調用其它方法。
7）super()和this()均需放在構造方法內第一行。
8）盡管可以用this調用一個構造器，但卻不能調用兩個。
9）this和super不能同時出現在一個構造函數里面，因為this必然會調用其它的構造函數，
其它的構造函數必然也會有super語句的存在，所以在同一個構造函數里面有相同
的語句，就失去了語句的意義，編譯器也不會通過。
10）this()和super()都指的是對象，所以，均不可以在static環境中使用。包括：static變
量,static方法，static語句塊。
11）從本質上講，this是一個指向本對象的指針, 然而super是一個Java關鍵字。
第20集 函數的override（覆蓋、重寫） 需要滿足兩個條件： 1、在具有父子關系的兩個類當中。 2、父類和子類都有一個同定義的函數（返回值類型、函數名和參數列表等完全相同） 當父類中的某A函數完全無法滿足我們的要求時，我們可以在子類上重寫父類的A函數，這個A函數會完全覆蓋父類的A函數，當執行A函數時，父類的函數是不會被執行的。 當然，很少情況下會遇到父類A函數完全無法滿足我的要求，若是遇到還不如重新寫一個函數。當然，如果是修改以及完成的源碼，因為后面的代碼已經寫好調用了這個A函數名，那么這時候我們可以重寫A函數，而不必要修改后續的代碼調用。 一般遇到的是父類的A函數能滿足一些基本的要求，但還是缺少一些功能，這時候我們可以先通過super.A() 來直接調用父類的代碼，然后下面再添加需要的一些功能，這樣當子類的A函數被調用時，會執行super.A()，而super.A()會是調用父類的A函數，那么父類的A函數執行完后就會執行接下來我們寫的代碼了。 例： class Person { String name; int age; void OutMsg() { System.out.println("父類 OutMsg"); System.out.println("我的名字是" + name + "我的年齡是" + age); } } class Student extends Person { String address; void OutMsg() { // 若這里是和父類的代碼一樣則可以換成 super.OutMsg(); // 這樣就可以直接調用父類的OutMsg函數，避免重復代碼 System.out.println("子類 OutMsg"); System.out.println("名字是" + name + "年齡是" + age); // 這是子類新增加的代碼 System.out.println("我的地址是" + address); } } class Test { public static void main(String[] args) { Student s = new Student(); s.name = "張三楓"; s.age = 20; s.address = "廣東"; s.OutMsg(); } } 輸出： D:\MyJava>javac *.java D:\MyJava>java Test 子類 OutMsg 名字是張三楓年齡是20 我的地址是廣東
================================================ 華麗的分割線 ================================================
2013-12-28 日 更新
[color=#3306f9,strength=3)"]================================================ 華麗的分割線 ================================================[color=#3306f9,strength=3)"]
第21集 對象的轉型
這一集特讓我糾結！作者說的不是很詳細，而且給出的結論也跟我自己做實驗的不符。最最最重要的是，作者介紹了對象的轉型卻沒有舉個例子說明其有什么作用。讓我感覺這玩意是不是沒啥用的。。。
對象向上轉型：將子類的對象賦值給父類的引用。
如：Student（子類）繼承 Person（父類）
Student s = new Student(); // 創建一個子類對象 s指向這個對象
Person p = s; //通過子類的引用將Student對象賦值給父類的引用
此時s和p指向的是同一個對象。那么是否能把p當成s去使用呢？看下面的例子。
class Person
{
String name;
int age;
String yiyang;
// 父類有的
void Person_fun()
{
System.out.println("父類：Person_fun執行");
}
void OutMsg()
{
System.out.println("父類：OutMsgyiyang = "+yiyang);
System.out.println("父類：我的名字是" + name + "我的年齡是" + age);
}
}
class Studentextends Person
{
String address;
String yiyang; //和父類同名的
void Student_fun()
{
System.out.println("子類：Student_fun 執行super.yiyang = " + super.yiyang);
}
void OutMsg()
{
super.OutMsg(); // 調用父類的OutMsg函數
System.out.println("子類：我的地址是address=" +address + " yiyang=" + yiyang); //這是子類新增加的代碼
}
}
class Test
{
publicstatic void main(String[] args)
{
System.out.println("---------------邪惡的分割線-------------");
System.out.println("以下是父類的對象操作。。。。");
System.out.println("------------------------------------------");
Person p1 = new Person();
p1.yiyang = "父類yiyang";
p1.name = " 父類";
p1.age = 21;
//p1.address = "廣州"; // 由于Person類沒有這個變量 當然編譯報錯
p1.OutMsg(); //直接調用Person類的函數OutMsg();
//p1.Student_fun(); // 由于Person類沒有這個函數 當然編譯報錯
p1.Person_fun(); //直接調用Person類的函數OutMsg();
System.out.println("\n\n---------------邪惡的分割線-------------");
System.out.println("以下是子類的對象操作。。。。");
System.out.println("------------------------------------------\n");
Student s1 = new Student();
s1.yiyang = "子類yiyang"; // 與父類同名變量，賦值的是子類的變量
s1.name = " 子類"; // 子類沒有。賦值的是父類的變量
s1.age = 22; //同上
s1.address = "深圳"; // 父類沒有，賦值的是子類的變量
s1.OutMsg(); //該函數被重寫（覆蓋）所以調用的是子類的函數
s1.Student_fun(); //子類獨有，調用的是子類的
s1.Person_fun(); // 子類沒有，調用的是父類的
System.out.println("\n\n---------------邪惡的分割線-------------");
System.out.println("以下是對象向上轉型操作。。。。");
System.out.println("------------------------------------------\n");
Student s = new Student();
Person p = s; // 對象的向上轉型
p.yiyang = "上轉—yiyang"; // 與子類同名，實際上賦值的是父類的成員變量
p.name = " 對象向上轉型"; //只有父類有這個成員變量 賦值的是父類的成員變量
p.age = 23; //賦值的是父類的成員變量 賦值的是父類的成員變量
//p.address = "廣東"; // 在父類沒有這個成員變量，編譯會報錯這行
p.OutMsg(); // 被復寫(覆蓋)的函數，調用的是子類的OutMsg()
//p.Student_fun(); // 在父類沒有這個成員函數，編譯會報錯這行
p.Person_fun(); //可以調用父類的成員函數
}
}
用java編譯輸出:
如果沒有紅色字體沒有被注釋則輸出：
D:\MyJava>javacTest.java
Test.java:14: 錯誤: 找不到符號
p1.address = "廣州"; // 由于Person類沒有這個變量 當然編譯報錯
^
符號: 變量 address
位置: 類型為Person的變量 p1
Test.java:17: 錯誤: 找不到符號
p1.Student_fun(); // 由于Person類沒有這個函數 當然編譯報錯
^
符號: 方法 Student_fun()
位置: 類型為Person的變量 p1
Test.java:49: 錯誤: 找不到符號
p.address = "廣東"; // 在父類沒有這個成員變量，編譯會報錯這
行
^
符號: 變量 address
位置: 類型為Person的變量 p
Test.java:52: 錯誤: 找不到符號
p.Student_fun(); // 在父類沒有這個成員函數，編譯會報錯這
行
^
符號: 方法 Student_fun()
位置: 類型為Person的變量 p
4 個錯誤
如果注釋了紅色字體則成功被編譯。輸出的執行結果是：
D:\MyJava>java Test
--------------- 邪惡的分割線 -------------
以下是父類的對象操作。。。。
------------------------------------------
父類：OutMsgyiyang = 父類yiyang // 這個就不用解釋了，非常普通的類操作
父類：我的名字是 父類我的年齡是21
父類：Person_fun 執行
--------------- 邪惡的分割線 -------------
以下是子類的對象操作。。。。
------------------------------------------
父類：OutMsgyiyang = null // 這里的yiyang是父類的，沒給父類yiyang賦值自然是null
父類：我的名字是 子類我的年齡是22 //子類沒有同名變量，所以是給父類賦值
子類：我的地址是address=深圳 yiyang=子類yiyang
子類：Student_fun執行super.yiyang = null //同名變量，賦值的是子類的，而不是父類的
父類：Person_fun 執行
--------------- 邪惡的分割線 -------------
以下是對象向上轉型操作。。。。
------------------------------------------
父類：OutMsgyiyang = 上轉—yiyang
父類：我的名字是 對象向上轉型我的年齡是23
子類：我的地址是address=null yiyang=null //可以發現子類的變量并沒有被賦值
父類：Person_fun 執行
我們可以總結一下，對象的向上轉型，在訪問變量和函數的時候，和直接操作父類對象相比，當父類對象調用不存在的函數和變量時，編譯器直接報錯。向上轉型對象也是。唯一和直接操作父類對象不同的是，在調用被子類重寫（覆蓋）的函數時，向上轉型對象操作的是子類的函數，而操作父類對象則是直接調用父類的函數。
下面是作者給出的結論：
一個引用能夠調用哪些成員（變量和函數），取決于這個引用的類型
一個引用調用的是哪一個方法，取決于這個引用所指向的對象
（讓我郁悶的是，函數和方法不是指一樣東西么，很矛盾。而且第二個結論是有前提的，那就是那個方法（函數）要被子類重寫過才成立.）
下面我們看看對象的向下轉型，由于視頻并沒有做過多介紹，所以唯有自己做實驗。
向下轉型 – 將父類的對象賦值給子類的引用
例：Student s1 =new Student();
Personp = s1;
Students2 = (Student)p;
或：Person p =new Student();
Students2 = (Student)p;
在Test.java文件中加入以下代碼:
class Test
{
publicstatic void main(String[] args)
{
//......
//這代碼和上面的一樣，就不寫出了。
//......
System.out.println("\n\n---------------邪惡的分割線-------------");
System.out.println("以下是對象向下轉型操作。。。。");
System.out.println("------------------------------------------\n");
Studentss = new Student();
Personpx = ss;
Studentsx = (Student)px;
sx.yiyang= "下轉-yiyang";
sx.name= "對象向下轉型";
sx.age= 25;
sx.address= "惠州";
sx.OutMsg();
sx.Student_fun();
sx.Person_fun();
}
}
看看輸出的結果：
發現向下轉型和直接使用子類沒啥區別。。。擦......
| 
QQ好友和群
QQ空間
騰訊微博
騰訊朋友
收藏
淘帖
頂
踩
