【【Object】】類
/*
*是所有類直接或者間接的父類 （超類 （最上層的類。
*該類中定義的肯定是所有對象都具備的功能
* （所有對象都具備比較功能。
*
*Object類中已經提供了對對象是否相同的比較方法
*
*如果自定義類中也有比較相同功能，沒有必要自己再定義
*只要沿襲父類中的功能，建立自己特有的比較內容即可，這就是覆蓋/複寫。
*
*【應用技能】
*1、向下轉型，
*2、instanceof 類型比較關鍵字
*3、方法的複寫/覆蓋
*4、多態
*5、equals
*6、toString（）和hashCode()
哈希值
*/
class Demo_a { //extend Object {
public int num;
Demo_a(int num){
this.num=num;
}
public boolean equals(Object obj){//Object obj=new Dem(); //複寫 方法一模一樣
/*針對傳入不同類型比較時，必然是false
*/
if(!(obj instanceof Demo)){//類型比較 ，instanceof關鍵字。
return false; //不是同一個類型直接返回：
}
Demo_a de=(Demo_a )obj;
return this.num==de.num;
/*
*個人總結：在多態中，可以通過向下轉換/強制轉換的方式，使父類擁有子類的成員變量和方法。
*就比較而言，想比較其他的，而這些功能父類已經定義了，子類只需要覆蓋就可以，
* 在這裏只需要對傳入的類型進行判斷，然後進行向下轉換即可完成功能。
*/
}
//public boolean equals(Demo d ){ //重載 參數列表不同
//}
}
class Person_a{
//建立一個人的類，也可以傳入複寫的比較方法中比較，只不過不同類型，必然是false；
}
public class Demo_Object {
public static void main(String []args){
//1 【equals】 任何對象都具備比較的功能。
/*
Demo d1=new Demo();
Demo d2=new Demo();
Demo d3=d1;
System.out.println(d1.equals(d3));
System.out.println(d1==d2);
System.out.println(d1==d3);
*/
/*
* d1d2d3都指向一個地址，進行比較的時候，equals比較的是對象的值
* 而==是比較的是地址
*/
Demo_a d1=new Demo_a(4);
Demo_a d2=new Demo_a(6);
System.out.println(d1.equals(d2));
//[toString]
System.out.println(d1.toString());//打印的是該對象的哈希值。
}
}
/*API裏面：
* boolean ||||||| equals(Object obj)
*/
-----------------------------------------------------------------------------------------------------------------
【內部類】
* 【內部類】
*1、將一個類定義在另外一個類裏面，對立面那個類就稱爲內部類（內置類，嵌套類）
*2、訪問特點：
* 2.1、內部類可以直接訪問外部類中的成員、私有成員
* 之所以可以直接訪問外部類中的成員，是因爲內部類中持有一個外部類的引用，格式： 外部類名.this 具體看【a】
* 2.2、外部類要訪問內部類中的成員必須要建立內部類對象。
*內部類是屬於外部類的成員變量，是可以私有化的
*
*【1，內部類在main方法中格式，2內部類爲什麼可以直接訪問外部類】
*訪問格式：
*1、當內部類定義在外部類的成員位置上，而且非私有，可以在外部其他類中直接建立內部類對象。
* 格式：外部名.內部類名 變量名=new 外部類對象（）.new 內部類對象（）；
* Outer.Inner in=new Outer().new Inner();
*
*2、當內部類在成員位置上，就可以被成員修飾符所修飾。
* 比如，private 將內部類在外部類中進行封裝
* static ：內部類就具備了static的特性；
* 當內部類被static修飾後，只能訪問外部類中的static成員，出現了局限性。
*
* 在外部類中，如何直接訪問內部類的非靜態成員呢？
* new Outer.Inner().Function（）;
*
* 在外部類中，如何直接訪問內部類的靜態成員呢？
* new Outer.Inner.Function2（）;
*注意：當內部類中定義了靜態成員，該內部類必須是static的。
* 當外部類中的靜態方法訪問內部類時，內部類也必須是靜態的。【b】
*【b】
*在定義一個內部類：
*
*當描述事物時，事物的內部還有事物，該事物用內部類來描述，
*因爲內部事物在使用外部事物的內容。
*
*包含關係的時候就使用內部類。
*【c】
*內部類可以寫在外部類的任意位置；【成員】或者【局部】。
*【c】中屬於局部內部類，但是訪問規則沒有改變，
* 該類不能在被static修飾，因爲static只修飾成員變量不能修飾局部成員
*內部類定義在局部時
*1,不可以被成員修飾符修飾
*2,可以直接訪問外部類中的成員變量，因爲還持有外部類中的引用
* 但是不可以訪問它所在的局部中的變量，只能訪問被final修飾的局部變量。
*靜態內部類出現的並不多
*/
class Outer{
int x=3;
//class Inner{ //內部類
static class Inner{ //靜態內部類
int x=4;
void Funtion(){
int x=5;
//內部類使用外部類成員和方法，可以直接調用
System.out.println("內部類成員變量："+this.x);
System.out.println("內部類局部變量："+x);
//當內部類定義爲靜態內部類的時候，非靜態的變量就不能訪問了
//System.out.println("外部類成員變量："+Outer.this.x);
//注意看上面的結果，有3個x成員的值得【a】
}
static void funtion2(){
System.out.println("funtion2");
}
}
void method(){
System.out.println("show "+x);
//外部類使用內部類成員和功能 必須創建內部類對象
Inner in=new Inner();
in.Funtion();
}
//【b】又一個內部類：
class Inner2{
void show(){
System.out.println("inner222");
}
}
public static void method2(){
Inner.funtion2();
//new Inner2().show();
/*發現，該靜態方法調用靜態內部類可以編譯
* 而調用非靜態內部類編譯出錯。
*
*/
}
//【c】
//void method3(int a){ 【mm】對應下列【mm】
void method3(final int a){
int x=3;
final int y=4;
class Inner3{
void function3(){
//System.out.println(x); //不能訪問該類所在的局部的變量
System.out.println(y); //而只能訪問局部中final修飾的變量
System.out.println(a); //傳入int a是編譯錯誤，傳入final
修飾的纔可以通過【mm】
System.out.println("該內部類屬於局部內部類，但是訪問規則沒有改變。" +
"該類不能在被static修飾因爲static只修飾成員變量不能修飾局部成員");
}
}
new Inner3().function3();
}
}
public class Demo_Neibulei {
public static void main(String[] args) {
//Outer ou=new Outer();
//ou.method();
//面試時候用：內部類想要在main方法中創建對象格式：
//Outer.Inner in=new Outer().new Inner();
//in.Funtion();
//使用很少，面試可能出現。
// 在外部類中，如何直接訪問靜態內部類非靜態成員呢？
new Outer.Inner().Funtion();
// 在外部類中，如何直接訪問靜態內部類靜態成員呢？
Outer.Inner.funtion2();
}
}
黑馬官網： http://edu.csdn.net/heima