類的定義和使用

類的定義格式

// 創(chuàng)建類
class ClassName{ field;    // 字段(屬性) 或者 成員變量method;    // 行為 或者 成員方法
}

class為定義類的關鍵字，ClassName為類的名字，{}中為類的主體。

class future {public int time;public void decreaseTime() {}
}

類名注意采用大駝峰定義
成員前寫法統(tǒng)一為public
此處寫的方法不帶 static 關鍵字

注意事項：
1. 一般一個文件當中只定義一個類,方便后期維護
2. main方法所在的類一般要使用public修飾(注意：Eclipse默認會在public修飾的類中找main方法)

class future {public int _time;public static void main(String[] args) {System.out.println("1");}public void decreaseTime() {}
}

此處的類未被public修飾,依舊可以使用main方法
3. public修飾的類必須要和文件名相同
4. 不要輕易去修改public修飾的類的名稱

類的實例化

用類類型創(chuàng)建對象的過程，稱為類的實例化，在java中采用new關鍵字，配合類名來實例化對象。

    public static void main(String[] args) {future date1 = new future();future date2 = new future();}

(地址隨便給的)

當你創(chuàng)建一個類的實例時，實際上是在內(nèi)存中分配了一塊空間來存儲這個實例，并返回一個指向該內(nèi)存空間的引用。這個引用指示了對象在內(nèi)存中的位置，而不是對象本身的內(nèi)容。通過這個引用，你可以訪問和操作對象的屬性和方法。

new 關鍵字用于創(chuàng)建一個對象的實例.
使用 . 來訪問對象中的屬性和方法.
同一個類可以創(chuàng)建多個實例.

類和對象的說明

類只是一種模板.類似于建筑圖紙,實例化就是把圖紙建造成高樓大廈
類是一種自定義類型,類可以實例化出多個對象,類似圖紙可以修建很多大廈,實例化的對象占用實際的物理空間,存儲成員變量,此處是普通成員變量,類的實例化會分配內(nèi)存空間來存儲對象的實例變量，并提供指向方法的引用，但靜態(tài)成員變量和靜態(tài)方法不會在實例化過程中分配新的空間

this引用

public class test {public static void main(String[] args) {stu a = new stu();stu b = new stu();a.InitStu(1,"ab",1);b.InitStu(2,"cd" ,2);}
}
class stu {public int age;public String name;public int index;public void InitStu(int age, String name, int index) {}
}

方法在類中是通過引用存在的,一個類創(chuàng)建的不同對象在調(diào)用同一個方法,而方法如何區(qū)分不同對象?

有寶子就很奇怪地會指出

調(diào)用函數(shù)之前不是會有對象嗎,這里還要再次重申一遍,方法在類中是以引用的形式存在的,方法不像成員變量,方法進行的是一種重復操作,沒必要每次實例化對象還要額外開辟空間,只需要開辟一次,之后調(diào)用之時去調(diào)用引用來進行方法調(diào)用,那么對于同一個方法,編譯器該如何區(qū)分呢?這里就要提到this引用了

對象a和b都有自己的引用,在函數(shù)調(diào)用時,系統(tǒng)會默認把this引用一起傳給方法.方法被調(diào)用時，this關鍵字將會引用調(diào)用該方法的對象，即a或b,來區(qū)分不同對象。

class stu {public int age;public String name;public int index;public void InitStu(int age, String name, int index) {age = age;name = name;index = index;}
}

對stu類里的InitStu方法進行如上操作,但是由于局部變量優(yōu)先的原則,方法內(nèi)的變量不會優(yōu)先識別方法之外的變量,而是優(yōu)先方法內(nèi)的局部變量,方法內(nèi)找不到才會到類中尋找,如上代碼可以得出,方法里修改的是形參,未對類里的成員變量進行修改

如果要對成語變量進行修改,使用this引用來指明,如下

this引用的特性

1. this的類型：對應類類型引用，即哪個對象調(diào)用就是哪個對象的引用類型
2. this只能在"成員方法"中使用
3. 在"成員方法"中，this只能引用當前對象，不能再引用其他對象
4. this是“成員方法”第一個隱藏的參數(shù)，編譯器會自動傳遞，在成員方法執(zhí)行時，編譯器會負責將調(diào)用成員方法,對象的引用傳遞給該成員方法，this負責來接收

對象的構造及初始化

    public static void main(String[] args) {int a;System.out.println(a);}

局部變量未初始化,打印會報錯,但是如果是成員變量則不一樣,成員變量未初始化在進行打印時不會報錯,因為類的對象在申請空間之后依舊設置好了初始化值,如下
數(shù)據(jù)類型 默認值
byte 0
char ‘\u0000’
short 0
int 0
long 0L
boolean false
float 0.0f
double 0.0
reference null

        stu a = new stu();System.out.println(a.index);System.out.println(a.age);System.out.println(a.name);

就地初始化

在聲明成員變量時，就直接給出了初始值

class stu {public int age = 1;public String name = null;public int index = 1;public void InitStu(int age, String name, int index) {this.age = age;this.name = name;this.index = index;}
}

構造方法

構造方法(也稱為構造器)是一個特殊的成員方法，名字必須與類名相同，在創(chuàng)建對象時，由編譯器自動調(diào)用，并且在整個對象的生命周期內(nèi)只調(diào)用一次

對象的產(chǎn)生一是需要為對象分配內(nèi)存,二是調(diào)用合適的構造方法,而剛才類里沒有構造方法為什么對象會產(chǎn)生,那是因為系統(tǒng)在發(fā)現(xiàn)類里沒有構造方法的情況下會自動生成一個構造方法,如下

    public class Animal {/*public Animal() {}系統(tǒng)默認生成這樣的構造函數(shù)來進行調(diào)用*/String name;int age;}

但是在你依舊有構造方法的時候,系統(tǒng)就不會生成默認構造方法,防止沖突,如下代碼就會報錯,因為不會生成默認構造方法

class Animal {public Animal(String name, int age) {this.age = age;this.name = name;}public String name;public int age;
}public class test {public static void main(String[] args) {Animal pig = new Animal();System.out.println(pig.age);System.out.println(pig.name);}
}

你還可以在你定義的構造方法調(diào)用另一個自己的構造方法

class Animal {public Animal(String name, int age) {this.age = age;this.name = name;}public Animal() {this("pig",1);}public String name;public int age;
}

但是需要注意在public Animal() 中this(“pig”,1)只能當?shù)谝粭l語句,后面可以添加其他語句
不能成環(huán)

    public Animal(String name, int age) {this();}public Animal() {this("pig",1);}

遞歸套娃的感覺,反正成環(huán)就噠嘜

封裝

面向對象程序三大特性：封裝、繼承、多態(tài)

public class things {
//這里把成員變量給密封在類里,外界無法訪問private String name;private int year;private String color;public things() {}public things(String name, int year, String color) {this.name = name;this.year = year;this.color = color;}public void show() {System.out.println(this.color);System.out.println(this.year);System.out.println(this.name);}
}

public class test02 {public static void main(String[] args) {things book = new things("book",1,"red");book.show();}
}

封裝：將數(shù)據(jù)和操作數(shù)據(jù)的方法進行有機結合，隱藏對象的屬性和實現(xiàn)細節(jié)，僅對外公開接口來和對象進行 交互
注意:這里的接口包括方法,也包括之后學的接口

包

在面向對象體系中，提出了一個軟件包的概念，即：為了更好的管理類，把多個類收集在一起成為一組，稱為軟件包。

包是對類,接口等的封裝機制的體現(xiàn),是一種對類或者接口等的很好的組織方式
在同一工程允許存在相同名稱的類,只要處在不同的包中即可

導入包中的類

可以使用java.util.Arrays導入java.util包中的Arrays類

    public static void main(String[] args) {int[] arr = {1,2,3};System.out.println(java.util.Arrays.toString(arr));}

這樣的寫法比較麻煩,可以使用import語句導入包

import java.util.Arrays;
public class test03 {public static void main(String[] args) {int[] arr = {1,2,3};System.out.println(Arrays.toString(arr));}
}

導入包時也可以使用import java.util.;.;
*是通配符,表示所有的意思,就是導入ijava.util所有的類
建議使用顯式的指定要導入的類名,否則會出現(xiàn)沖突

使用import static導入包中靜態(tài)的方法和字段

靜態(tài)方法

    public static void main(String[] args) {int[] arr = {2,33,3};sort(arr);//可以直接寫方法for (int x:arr) {System.out.println(x+" ");}}

自定義包

基本規(guī)則

• 在文件的最上方加一個package語句指定該代碼在哪個包中
• 包名需要盡量指定成唯一的名字,通常會用公司的域名顛倒形式
• 包名要和代碼路徑相匹配
• 如果一個類沒有package語句,則該類被放到一個默認包
  
  (子類要等到后面再展開)
  先提一下default,他就是不加任何訪問限定符的狀態(tài)
  
  上圖創(chuàng)建一個A包,包里有B和C包,B包里有testB類,C包里有testC類
  

public class testC {int tem;//不加訪問修飾限定符public int tem1;
}

在另一個包B里實例化testC這個類,對象名叫a,上圖可以看出我們可以訪問tem1,但是default也就是不加訪問限定符的情況下,無法訪問tem這個變量

static成員

public class person {public int time;public String name;
}

定義person這個類,變量time對于每個person都一樣的(前提),但是如果你每次實例化一個對象都要開辟空間給變量time,本來一個就夠了,但是你每次都要開辟空間,就會造成空間浪費
如果time屬性對于所有的person對象都是相同的，那么將其設置為static是合適的。這樣，這個屬性就不會與每個person對象實例關聯(lián)，而是與類本身關聯(lián)。這樣，無論創(chuàng)建多少個person對象，都只會有一個time屬性，所有對象都會共享這個屬性

public class person {public static int time;public String name;
}

static修飾成員變量

靜態(tài)成員變量在方法區(qū)中存儲 ,被static修飾的只能是成員變量,不能是局部變量

static修飾的成員變量，稱為靜態(tài)成員變量，靜態(tài)成員變量最大的特性：不屬于某個具體的對象，是所有對象所共享的

1. 不屬于某個具體的對象，是類的屬性，所有對象共享的，不存儲在某個對象的空間中
2. 既可以通過對象訪問，也可以通過類名訪問，但一般更推薦使用類名訪問
3. 類變量存儲在方法區(qū)當中
4. 生命周期伴隨類的一生(即：隨類的加載而創(chuàng)建，隨類的卸載而銷毀)

static修飾成員方法

Java中，被static修飾的成員方法稱為靜態(tài)成員方法，是類的方法，不是某個對象所特有的。靜態(tài)成員一般是通過靜態(tài)方法來訪問的。

【靜態(tài)方法特性】

1. 不屬于某個具體的對象，是類方法
2. 可以通過對象調(diào)用，也可以通過類名.靜態(tài)方法名(…)方式調(diào)用，更推薦使用后者
3. 不能在靜態(tài)方法中訪問任何非靜態(tài)成員變量
4. 靜態(tài)方法中不能調(diào)用任何非靜態(tài)方法，因為非靜態(tài)方法有this參數(shù)，在靜態(tài)方法中調(diào)用時候無法傳遞this引用

代碼塊

代碼塊概念及分類

使用{}定義一段代碼稱為代碼段.根據(jù)代碼塊定義的位置以及關鍵字,又可分為以下四種

• 普通代碼塊(少見)
• 構造塊
• 靜態(tài)塊
• 同步代碼塊(期待后續(xù))

構造代碼塊

構造塊：定義在類中的代碼塊(不加修飾符)。也叫：實例代碼塊。構造代碼塊一般用于初始化實例成員變量。

靜態(tài)代碼塊

使用static定義的代碼塊稱為靜態(tài)代碼塊。一般用于初始化靜態(tài)成員變量
注意事項
靜態(tài)代碼塊不管生成多少個對象，其只會執(zhí)行一次
靜態(tài)成員變量是類的屬性，因此是在JVM加載類時開辟空間并初始化的
如果一個類中包含多個靜態(tài)代碼塊，在編譯代碼時，編譯器會按照定義的先后次序依次執(zhí)行(合并)
實例代碼塊只有在創(chuàng)建對象時才會執(zhí)行

public class test {public static void main(String[] args) {person tem1 = new person();System.out.println("================");person tem2 = new person();}
}
class person {public static int time;public String name;person() {System.out.println("構造方法");person.time = 1;this.name = "張三";}public void show() {System.out.println(this.name);System.out.println(person.time);}//靜態(tài)代碼塊static {System.out.println("靜態(tài)代碼塊");}//構造代碼塊{System.out.println("構造代碼塊");}
}

匿名對象

舉個栗子:

public class test {public static void main(String[] args) {String tem;System.out.println(tem);}
}

思維有些混淆的寶子會說不是有默認值嗎,我們再說一下,是類里的成員變量在未初始化的時候會有默認值,tem是局部變量,需要初始化

類里的成員變量：
當你在類中聲明一個變量，這個變量是類的成員變量。如果這些變量沒有被初始化，它們會有默認值。例如，對于引用類型（如String），默認值是null。對于數(shù)值類型，默認值是相應的默認值（例如，int的默認值是0）。
局部變量：
局部變量是在方法內(nèi)部聲明的變量。它們只在方法的作用域內(nèi)存在，并且沒有默認值。在聲明之后必須顯式地初始化它們，否則編譯器會報錯。

public class test {String tem;public static void main(String[] args) {System.out.println(tem);//依舊報錯}
}

有寶子又要說:這也不行啊,上面的代碼main方法被static修飾,是個類方法,他的調(diào)用不依賴于對象,但是tem這個成員變量屬于類,不能直接調(diào)用,因為靜態(tài)的里面不能訪問非靜態(tài)的,如果你非要調(diào)用就給一個對象即可

public class test {String tem;public static void main(String[] args) {test a = new test();System.out.println(a.tem);}
}

public class test {String tem;public static void main(String[] args) {System.out.println(new test().tem);//匿名對象的方式}
}

匿名對象的缺點:
只能使用一次,不能重復使用