類和對象的初步認識

定義類和對象

java程序基本的單位是類（class）。

在面向對象中，類也是它的重要內容。

Java數據類型：基本數據類型；引用數據類型。

引用數據類型：String、Scanner……，他們都是預先寫好的類，把他們當做數據類型來使用。一定意義上來說，類也可以稱為引用類型。

String str =new String();
定義類的格式：[修飾符] class 類名{         //定義屬性         //定義方法         //定義構造器方法}
練習：定義一個類Person，將這個類作為引用數據類型，再定義測試類，測試Person引用數據類型。
class Test{public static void main(String[] args){Person p = new Person();//設置屬性p.name = "zhangsan";p.age = 18;//調用方法p.getInfo();}}class  Person{//定義屬性String name; int age; //定義方法void getInfo(){System.out.PRintln("name"+name+"/n age"+age); }}
 
什么是對象？
         對象，是一個具體存在的事物，他具有屬性和行為（方法）。如：人，電腦，食物。
類和對象的關系：
類：說明書，圖紙；
如果對象是建筑的話，類就是建筑的圖紙；
對象是食物的話，類就是菜譜；
類就是用來描述對象的，描述對象具有什么屬性，什么行為，類定義了對象。
類是：抽象的，對象就是具體的。
類與對象存在的關系：
         對象是通過類創造的，那么類是優先于對象存在而存在。換句話說，類存在，對象不一定存在，但是對象存在了，類一定存在。
         注意：“對象存在，類不存在”是不可能的，如果圖紙都沒有，那么怎么去蓋房？
靜態修飾符 static：
static只能修飾類的成員。
static 修飾變量：
static 類型 變量名；
static 返回值 方法名(){}
Static修飾的成員：是靜態的，直接屬于類，而不屬于類創造出來的對象，隨著類的創建而創建，隨著類的消失而消失。
當類存在的時候，被static修飾的成員就一起存在了。
沒有用static修飾的成員，當類存在的時候，這些成員并不存在。
這個時候，使用類名.靜態成員是OK的，但是使用類名.非靜態成員，是錯誤的，因為非靜態成員并不是與類一起產生，那么使用一個存在的東西去訪問一個不存在的東西，肯定是不行的！
怎么訪問沒有被static修飾的非靜態成員？
可以通過new關鍵字創建該類對象，使用對象.非靜態成員方式調用，沒有被static修飾的非靜態修飾的成員只屬于創造出來的對象本身。
 
存在的順序：類、靜態成員優先于對象、非靜態成員存在。
提示：按照存在順序可以得出，靜態成員只能調用、訪問靜態成員，不能訪問非靜態成員；非靜態成員可以訪問靜態成員。
class%20Test{%20%20%20%20publicstatic%20void%20main(String[]%20args){%20%20%20%20%20%20%20%20//靜態成員是與對象一起存在，所以可以通過類名.靜態成員方式調用%20%20%20%20%20%20%20%20System.out.println(Animal.zhonglei);%20%20%20%20%20%20%20%20//cat是非靜態成員，Aniaml調用這個時候還不存在的成員，會報錯%20%20%20%20%20%20%20%20System.out.println(Animal.cat);%20%20%20%20%20%20%20%20Animalani%20=%20new%20Animal();%20%20//創建對象后，可以使用對象.非靜態成員方式調用，也就是說，非靜態成員屬于對象%20%20%20%20%20%20%20%20System.out.println(ani.cat);%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20//使用對象.靜態成員%20不報錯，因為靜態成員優先于對象而存在。%20%20%20%20%20%20%20%20System.out.println(ani.zhonglei);%20%20%20%20%20%20%20}}class%20Animal{%20%20%20%20staticString%20zhonglei%20=%20"動物";%20%20%20%20Stringcat="貓";}%20class%20%20Person{%20%20%20%20String%20a%20="aa";%20%20%20%20staticString%20b%20="bb";%20%20%20%20//驗證靜態成員調用非靜態成員%20%20%20%20//靜態方法，調用非靜態成員是錯誤的！%20%20%20%20/*staticvoid%20m1(){%20%20%20%20%20%20%20%20a%20="abc";%20%20%20%20}*/
%20%20%20%20//驗證非靜態成員調用靜態成員.%20%20%20%20void%20m2(){%20%20%20%20%20%20%20%20b%20="abc";%20%20%20%20}}
直接類名調用成員和創建對象調用成員的區別：
類名調用成員，只能調用靜態成員，不能調用非靜態成員。
對象調用成員，既可以調用非靜態成員，也可以調用靜態成員，也就是說，非靜態成員只屬于它們的對象。
 
對象與對象之間的關系與區別：
使用同一個類Dog創建出來的對象，是兩個具體存在的事物，不是同一個，他們雖然類型和屬性相同，但是互不影響，他們都是獨立存在的個體。
N個對象與靜態成員之間的關系：
靜態成員直接屬于類，是唯一的。對象也可以直接訪問靜態成員，所以說，N多個該類的實例對象訪問的靜態成員其實是同一個，換句話說，靜態成員被N多個實例對象共享。
 
 
 
 
特殊的成員：構造器方法
構造器方法：是用來構造對象的，當我們使用new關鍵字創建對象的時候，這個創建過程是一個行為、動作。其實他也是一個方法，只不過我們以前是沒有注意過這個方法。
定義格式：
public%20類名([參數類型%20參數名]){
   %20//代碼
}%20
使用方式：
構造器方法，當我們使用new關鍵字創建對象的時候調用。
new%20Animal();//這個時候，實際上是調用了對象的構造器方法。如果我們在定義對象的時候，沒有寫構造器方法，就會隱式的存在一個無參的構造器方法。class%20Animal{%20%20%20%20staticString%20zhonglei%20=%20"動物";%20%20%20%20Stringcat;%20%20%20%20Stringage;}%20
當我們定義了構造器方法，那么這個無參構造器就消失了。
class%20Animal{%20%20%20%20%20publicAnimal(String%20a){%20%20%20%20%20%20%20%20age%20=a;%20%20%20%20}%20%20%20%20staticString%20zhonglei%20=%20"動物";%20%20%20%20Stringcat;%20%20%20%20Stringage;}%20
當我們定義了構造器，并且指定了構造器需要的傳參參數，之前隱式的空構造器方法就會消失。
對象創建后，對象的成員的默認值：
Int:0
Byte:0
Long :0
Short :0
Double:0.0
Float:0.0
Char:’’//編碼表里面編碼為0的那個字符
Boolean:false
 
引用數據類型：null
對象的引用和生命周期：
對象的創建：
使用new關鍵字創建對象，在堆空間中，開辟一塊區域用來存放這個對象的數據，然后將這個對象的門牌號（地址值）賦值給棧空間中該類型變量。
引用：棧空間中的變量指向堆空間中的對象。
用手機號綁定QQ賬號，使用手機號登陸QQ和使用QQ號登陸QQ，登陸的是同一個賬戶。那么使用手機號登陸QQ后，發了一條朋友圈，再使用QQ賬號登陸，那條朋友圈信息還在。
棧空間中的變量可以有N個同時指向堆空間中的同一個對象。那么使用這幾個引用變量去訪問數據，其實訪問的是同一個數據。
   %20
 
%20%20%20%20%20%20%20%20//dog1存儲的是指向dog對象的地址Dogdog1%20=%20new%20Dog();%20%20%20%20%20%20%20%20dog1.name=%20"哈士奇";%20%20%20%20%20%20%20%20dog1.age=%203;%20%20%20%20%20%20%20%20Dogdog1_1%20=%20dog1;%20%20%20%20%20%20%20%20System.out.println(dog1_1.name);%20%20%20%20%20%20%20%20dog1_1.name=%20"泰迪";%20%20%20%20%20%20%20%20System.out.println(dog1.name);
分析：定義dog1指向一個對象，將他存儲的地址賦值給dog1_1，那么使用dog1_1和dog1去訪問、操作的其實是同一個對象。
對象的消失：
        %20當沒有引用（變量）指向對象時候，對象無法被訪問和操作了。那么在堆空間中的對象就是垃圾。
        %20Java提供一個垃圾回收機制，GC，通過該線程不定時的回收垃圾（沒有引用指向的對象）。
      
  //對象沒用了，那么怎么回收對象所占用的內存空間        //將引用指向對象的連接中斷就可以了。        dog1 =null;        //System.out.println(dog1.name);空指針異常        dog1_1=null;        /*這個時候，已經沒有任何引用指向之前定義的對象        那么之前的那個對象就是垃圾了，java的GC會不定時        清理垃圾        */
構造器：
用來創建對象，使用new關鍵字創建對象，實際上就是調用該對象的構造器方法。
構造器方法與普通方法區別：
1、  沒有返回值，不能使用return
2、  調用方式是使用new關鍵字調用，而方法是通過 類名.方法名調用。
3、如果沒有定義構造器方法，那么java會有一個隱藏的無參構造器，如果定義了構造器方法，那么該隱藏的無參構造器就消失。
構造器除了用來創建對象，還可以做一些對象初始化動作。
class Test{    publicstatic void main(String[] args){        Dogdog1 = new Dog();        System.out.println(dog1.name);    }   }class Dog{    //在創建Dog類型對象時，對象的屬性就有初始值。    publicDog(){        name ="哈士奇";    }    staticString aixinjiayuan = "愛心家園";    Stringname;}還可以傳參給構造器，用來初始化數據。class Test{    publicstatic void main(String[] args){        Dogdog1 = new Dog("金毛");        System.out.println(dog1.name);        Dogdog2 = new Dog("哈士奇");        System.out.println(dog2.name);    }   }class Dog{    //在創建Dog類型對象時，對象的屬性就有初始值。    publicDog(String str){        name =str;    }    staticString aixinjiayuan = "愛心家園";    Stringname;}
this 關鍵字：
代表所在的類中創建出來的對象本身。
class Dog{    //在創建Dog類型對象時，對象的屬性就有初始值。    //遇到局部變量與外部變量重名，可以使用this找到外部變量。    //this代表當前創建的對象本身。    publicDog(String name){        this.name= name;    }    staticString aixinjiayuan = "愛心家園";    Stringname;}
方法的定義：具有一定功能的代碼塊，有返回值，也可以傳參。
定義格式：
[修飾符] 返回值方法名([參數類型參數名稱]){
         //0到多行代碼塊
}
方法的重載：
         在一個類里面，可以定義n多個同名方法，只需要參數列表不同即可。
重載只與形參列表有關，與返回值、修飾符無任何關系。
 
    publicstatic int add(int a , int b){        returna+b ;    }    publicstatic int add(int a , int b, int c){        returna+b+c ;    }    publicstatic int add(int a , int b, int c,int d){        returna+b+c+d ;    }構造器是特殊的方法，那么構造器也可以重載：    publicDog(String name){        this.name= name;    }    publicDog(String name ,int age){        this.name= name;        this.age= age;    }    staticString aixinjiayuan = "愛心家園";    Stringname;    int age;
參數列表的可變長參數：
當我們遇到需要傳遞同一種參數類型的數據，但是參數個數較多，這個時候如果依次重載不同參數列表的方法，就顯得代碼臃腫。
如：遇到如下情況，就需要重載4個add方法。
result=AddMethod.add(1,2);         System.out.println(result);        result=AddMethod.add(1,2,3);         System.out.println(result);        result=AddMethod.add(1,2,3,4);         System.out.println(result);        result=AddMethod.add(1,2,3,4,5); 
解決這個問題，可以使用可變參數。
作用：接收同一種數據類型的數據，但是接收的參數個數是可以變化的。
接收過來以后，java自動將接收的數據封裝到數組里面，在方法的代碼塊中，這個參數就是一個該類型的數組。我們將它當成普通數組使用即可。
 
問題：數組是一個不可改變長度的容器，為什么在使用的時候，可以傳遞不同長度的數據？
這里的可變參數數組的定義，是根據傳遞過來的參數來定義。
定義格式：
[修飾符] 返回值類型方法名(參數類型…參數名){
         //參數名就是一個該參數類型的數組。
}
 
注意：可變參數，放置的位置只能是在方法參數列表的最后一個參數的位置。并且，一個方法參數列表中只能有一個可變參數。
    publicstatic int add(String str, int ...arr){         intresult =0;        for(inti = 0;i < arr.length ; i++){            result+=arr[i];        }        returnresult;    }
特殊的方法調用：遞歸
遞歸：自己調用自己。方法內部代碼調用方法本身。
 
class%20Test2{static%20int%20method(int%20i){%20%20%20%20if(i%20==1){%20%20%20%20%20%20%20%20returni%20;%20%20%20%20}%20%20%20%20int%20result=%20method(i%20-%201);%20%20%20%20returnresult;}%20public%20static%20void%20main(String[]%20args){%20%20%20%20int%20%20result%20=%20method(5);%20%20%20%20System.out.println(result);}}
案例：階乘
階乘：5的階乘是%201*2*3*4*5   %206的階乘是1*2*3*4*5*6%20從1到它本身的整數相乘。
使用for循環求階乘：
使用遞歸算法求階乘：
class JieCheng{public static void main(String[] args){int result = jiecheng(3);System.out.println(result);}public static int jiecheng(int num){    if(num ==1){        returnnum;    }     num = num * jiecheng(num -1) ;    return num;    }}
成員變量和局部變量：
成員變量：在成員位置，屬于對象或者是類。隨著類或對象的創建而創建，消失而消失。
局部變量：定義在方法中，隨著方法的創建而創建，隨著方法的消失而消失。
    //成員變量    Stringchengyuan;    //成員方法    publicvoid method(){    //局部變量    Stringjubu;    } 
 
 
 
 
 
 
 
 
 
形參：定義在方法參數列表中，表示一個參數的類型和參數名。
實參：方法執行時候，傳遞進來的實際參數（值）。
 
變量在內存中的生命周期：
類變量：與類同時創建，與類同時消失。
實例變量：創建對象時，創建實例變量，對象被回收，屬于該對象的實例變量消失。
局部變量：方法被調用，局部變量被創建，方法執行完成，局部變量被回收。
代碼塊
 
 
 
 
 
 
 
 
 
代碼塊：執行一段代碼，沒有名稱，沒有返回值，沒有參數，不能被調用。
靜態代碼塊：類存在了（類加載到內存當中），執行靜態代碼塊中的代碼，并且只會執行一次。
class Test{    //類加載到內存中就執行該代碼塊    static {        System.out.println("靜態代碼塊執行了");    }    publicstatic void main(String[] args){     }   } 第二種情況：class Test{    publicstatic void main(String[] args){    Dog dog1 =new Dog();    }   }class Dog{    //類加載到內存中就執行該代碼塊    static {        System.out.println("靜態代碼塊執行了");    }}  構造代碼塊：對象創建（new Dog()）,執行一遍構造代碼塊，并且只會執行一次。class Test{    publicstatic void main(String[] args){    Dog dog1 =new Dog();    Dog dog2 =new Dog();    }   }class Dog{    //對象一旦創建就執行該代碼塊    {        System.out.println("普通代碼塊執行了");    }}  
代碼塊的作用：就是初始化對象、初始化類時候做一個初始化動作，如:賦值操作。
 
類、對象產生的順序及在內存中的存儲：
類加載到內存，通過類名調用靜態方法，如：類名.靜態方法；通過類創建對象，new 對象（）。
對象加載到內存，就是new關鍵字創建后加載到內存。
 
 
 
 
靜態成員、靜態代碼塊、實例變量、構造代碼塊、構造方法
以new對象為例，說明類和對象中數據以及代碼塊執行的順序：
class Test{    publicstatic void main(String[] args){    Dog dog1 =new Dog();    //當我執行new Dog()會發生了什么事情？    /*        1、加載類到靜態區域        2、先創建靜態成員        3、執行靜態代碼塊        4、創建實例變量        5、構造代碼塊        6、構造方法    */     }}class Dog{    //如果不給靜態成員初始化值，會有默認初始值    staticString aixinjiayuan = "abc";    Stringname = "泰迪";    staticvoid jingtai(){        intnum = 0;    }    voidshili(){        Stringstr = "";    }    //靜態代碼塊    static {        System.out.println(aixinjiayuan);        System.out.println("普通代碼塊執行了");    }    //對象一旦創建就執行該代碼塊    {        System.out.println(name);        System.out.println("普通代碼塊執行了");    }    publicDog(){        System.out.println("構造方法執行了");    }}