0. 面向對象與面向過程的區別

面向對象 如：指揮者，人，筆記本等都可以是對象，“萬物皆對象”

面向過程 如：執行者

1. 面向對象的三個特征：封裝，繼承，多態。

以后的開發就是：找對象，建立對象，使用對象，維護對象的關系。(如找不到對象，就創建一個對象)

2.?類和對象的關系

類：對現實生活中事物的描述，對象中共性內容的提取，對具體的抽象

對象：就是這類事物，實實在在存在的個體

描述事物其實就是：描述事物的屬性和行為。

屬性對應類中變量，行為對應類中的函數(方法)。

其實定義類，就是在描述事物，就是在定義屬性和行為。

屬性和行為都為類中的成員，即成員變量和成員函數。

classCar

{

String?color="red";

intnum=4;

voidrun()

{

System.out.println(color+".."+num);

}

}

classDemo

{

publicstaticvoidmain(String[]?args)

{

Car?c?=newCar();//c是一個類類型變量位于棧內存，?new?Car()存在堆內存

System.out.println(c.color+"?"+c.num);//red?4

c.color="blue";

c.run();//blue?4

Car?c1=c;

c1.color="green";

c.run();//green?4

}

}

成員變量與局部變量區別

1.?作用范圍不同

成員變量作用于整個類中，

局部變量作用于函數中，或者語句中(如，if語句for(int i=0;...))

2.?在內存中的位置不同

成員變量：在堆內存中，因為對象的存在，才在內存中存在，

局部變量：存在棧內存中。

3.?是否有默認值

成員變量：有默認初始化值，如int型默認為0，

局部變量：在棧中，默認沒有初始化，必須初始化值后才能使用。

匿名對象

1. new Car().run();? //red 4 這稱為匿名對象

2.?它還可以作為實參傳入函數。

封裝

封裝：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。

好處：將變化隔離；便于使用；提高重用性；提高安全性。

封裝原則

1.?將不需要對外提供的內容隱藏起來；

2. 把屬性都隱藏，提供公共方法對其訪問。

private: 私有權限，用于修辭類中的成員(成員變量，成員函數)。

私有成員只能在類中訪問。

在類中對外提供訪問方式，就因為可以在里面加入邏輯判斷語句，對訪問的數據進行判斷，這樣可提高代碼的健壯性。

構造函數

特點：

1. 函數名與類名相同，

2. 不用定義返回值類型，

3. 不可以寫return語句。

new一個對象時，就會執行一次構造函數。

作用：可以用于給對象進行初始化。

當一個類中沒有定義構造函數時，系統會默認給該類加入一個空參數的構造函數。當在類中自定義了一個構造函數，則默認構造函數就沒有了。

構造函數也是函數，所以也具備了“可重載”特性。

classPerson

{

privateString?name;

privateintage;

/*Person()

{

System.out.println("name="+name+",age="+age);

}*/

Person(String?n)

{

name=n;

System.out.println("name="+name+",age="+age);

}

}

classDemo

{

publicstaticvoidmain(String[]?args)

{

Person?p?=newPerson(); ?//這樣寫的話，有錯誤

}

}

當new一個類對象時，要么執行默認構造函數，要么執行自定義構造函數。上面程序中已定義了一個構造函數，所以默認構造函數就不使用了，此時則找與它匹配的自定義構造函數，而在類Person中去沒有定義，所以出錯。

構造函數與一般函數區別：

1. 在寫法上不同，

2. 構造函數在對象一建立就運行，給對象初始；而一般函數是對象調用才執行，是給對象添加對象具備的功能，

3.?一個對象建立，構造函數只運行一次；而一般函數可以被該對象調用多次。

構造代碼塊??? 作用：

給對象進行初始化，對象一建立就運行，而且優先于構造函數執行。

和構造函數區別：

構造代碼塊：是給所有對象進行統一初始化，它總是會運行。

構造函數：是給相對應的對象初始化，根據傳入的參數，執行相對應的構造函數。

構造代碼塊中定義的是不同對象共性的初始化內容。

classPerson

{

privateString?name;

privateintage;

/*

構造代碼塊

*/

{

System.out.println("cry");

}

Person(String?n)

{

name=n;

System.out.println("name="+name+",age="+age);

}

Person(String?n,inta)

{

name=n;

age=a;

System.out.println("name="+name+",age="+age);

}

}

classDemo

{

publicstaticvoidmain(String[]?args)

{

Person?p?=newPerson();

}

}

this指針(this即代表對象)

作用：用于區分局部變量和成員變量同名情況

特點：代表本類的對象，但一個類可以定義很多對象，到底代表哪個對象呢？

this代表的是它所在函數所屬對象。

簡單說：哪個對象調用了this所在的函數，那this就代表哪個對象。

this應用有兩方面：

1. 用于局部變量與成員變量重名時，

2. 用于構造函數之間的相互調用

classPerson

{

privateString?name;

privateintage;

Person(String?name)//當形參和成員變量重名時

{

name=name;//錯誤不能成功賦值，

}

Person(String?name)

{

this.name=name;//成功賦值，

}

Person(String?name,intage)

{

this.name=name;

this.age=age;

}

publicvoidspeak()

{

System.out.println("name="+name+",age="+age);

//其實這里的this被省略了，成員間相互調用都是通過對象通用的。

System.out.println("name="+this.name+",age="+this.age);

show();

this.show();//這里this也是被省略。

}

publicvoidshow()

{

System.out.println(this.name);

}

}

classDemo

{

publicstaticvoidmain(String[]?args)

{

Person?p?=newPerson();

}

}

this的第一個應用舉例：

classPerson

{

privateString?name;

privateintage;

/*Person(String?name)??//當形參和成員變量重名時

{

name=name;??//錯誤不能成功賦值，

}*/

Person(String?name)

{

this.name=name;//成功賦值，

}

Person(String?name,intage)

{

this.name=name;

this.age=age;

}

publicvoidspeak()

{

System.out.println("name="+name+",age="+age);

//其實這里的this被省略了，成員間相互調用都是通過對象通用的。

System.out.println("name="+this.name+",age="+this.age);

show();

this.show();//這里this也是被省略。

}

publicvoidshow()

{

System.out.println(this.name);

}

/*

需求：與某人是否為同年齡人

*/

publicboolean?compare(Person?p)

{

returnthis.age?==?p.age;//用this代表調用該函數的對象。

}

}

classDemo

{

publicstaticvoidmain(String[]?args)

{

Person?p1?=newPerson("li",20);

Person?p2?=newPerson("zhang",20);

boolean?b?=?p1.compare(p2);

System.out.println(b);

}

}

this的第二個應用舉例：

classPerson

{

privateString?name;

privateintage;

Person(String?name)

{

this.name=name;

}

/*

this語句：用于構造函數之間的相互調用

this語句：只能定義在構造函數中的第一行，因為初始化要先執行。

*/

/*Person(String?name,int?age)

{

Person(name);??//這樣不可

this.age=age;

}*/

Person(String?name,intage)

{

this(name);//相當于p(name)

this.age=age;

}

publicvoidspeak()

{

System.out.println("name="+this.name+",age="+this.age);

this.show();//這里this也是被省略。

}

publicvoidshow()

{

System.out.println(this.name);

}

}

classDemo

{

publicstaticvoidmain(String[]?args)

{

Person?p1?=newPerson("li",20);

Person?p2?=newPerson("zhang",20);

p1.speak();

}

}

static關鍵字 (特有與共有)用法：是一個修飾符，用于修飾成員(成員變量，成員函數)

特點：

1. static修飾的成員不在堆內存中，并不是并個對象都擁有一份，而是被對象所共享。

2. 當成員被靜態修飾后，不但可被對象調用外，而且可以被類名調用。

3. ?特有內容隨著對象存儲，共享內容隨著類的加載而加載，隨著類的消失而消失。即靜態成員(也叫類成員)屬于類。而非靜態變量，即成員變量，也叫實例變量，只有創建對象后，才會存在。

4. 優先于對象存在。靜態是先存在，對象是后存在。

好處：

1.?節省空間；

2.?可直接被類名調用。

弊端：

1.?生命周期過長；

2. 訪問出現局限性。(靜態雖好，只能訪問靜態)

實例變量與類變量的區別：

1. 存放位置

實例變量隨著對象的建立而存在堆內存中；

類變量隨著類的加載而存在于方法區中。

2.?生命周期

類變量生命周期最長，隨著類的消失而消失。

實例變量生命周期隨著對象的消失而消失。靜態使用注意事項：??????? 1. 靜態方法只能訪問靜態成員；非靜態方法即可以訪問靜態成員，也可以訪問非靜態。

2.?靜態方法中不可以定義this，super關鍵字；因為靜態優先于對象存在，所以靜態方法中不可以出現this。??????3. 主函數是靜態的

主函數：是一個特殊的函數，作為程序的入口，可以被jvm調用。

主函數的定義：? public:?代表著該函數訪問權限是最大的。

static: 代表著主函數隨著類的加載就已經存在了。

void: 主函數沒有具體的返回值。

main: 不是關鍵字，但是一個特殊單詞，可以被jvm識別。

(String[] arr): 函數參數，字符串類型數組。?jvm在調用主函數時，傳入的是new String[0]

什么時候使用靜態？??????? 靜態變量：當對象中出現共享數據時用；

靜態函數：靜態函數中只能訪問靜態變量，不可以訪問非靜態變量；非靜態方法即可以訪問靜態成員，也可以訪問非靜態。

每個應用程序中都有共性的功能，可以將這些功能進行抽取，獨立封裝，以便復用。

靜態的應用-----工具類??????? a. 建立兩個文件：ArrayTool.java和Demo.java

/*??ArrayTool.java??*/

classArrayTool

{

privateArrayTool(){};

publicstaticintgetMax(int[]?arr)

{

intmax=0;

for(intx=1;?x

{

if(arr[x]>arr[max])

max=x;

}

returnarr[max];

}

publicstaticintgetMin(int[]?arr)

{

intmin=0;

for(intx=1;?x

{

if(arr[x]

min=x;

}

returnarr[min];

}

publicstaticvoidselectSort(int[]?arr)

{

for(inti=0;?i

for(intj=i+1;j

if(arr[i]>arr[j])

swap(arr,i,j);

}

publicstaticvoidbubbleSort(int[]?arr)

{

for(inti=0;i

for(intj=0;j

if(arr[j]>arr[j+1])

swap(arr,j,j+1);

}

privatestaticvoidswap(int[]?arr,inti,intj)

{

inttemp;

temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

/*??Demo.java???*/

classDemo

{

publicstaticvoidmain(String[]?args)

{

int[]?arr={2,13,45,68,99};

intmax=ArrayTool.getMax(arr);

System.out.println(max);

}

}

b.?javac Demo.java? 和 java Demo

程序說明：

1. 將類ArrayTool中的成員函數定義為static，這樣就可以直接用類調用，不需再定義類對象了。

2. 將類ArrayTool中的構造函數私有化，強制讓該類不能建立對象，這樣更嚴謹了。

靜態代碼塊作用: 給類進行初始化

情形1：

/*

靜態代碼塊

格式：

static

{

靜態代碼塊中的執行語句

}

特點：

隨著類的加載而執行，只執行一次,并優先于主函數執行。

用于給類進行初始化

*/

classStaticCode

{

static

{

System.out.println("a");

}

}

classStaticCodeDemo

{

static

{

System.out.println("b");

}

publicstaticvoidmain(String[]?args)

{

newStaticCode();

newStaticCode();

System.out.println("over");

}

static

{

System.out.println("c");

}

}

/*

所以運行結果為?b?c?a?over

*/

情形2：

classStaticCode

{

static

{

System.out.println("a");

}

publicstaticvoidshow()

{

System.out.println("show?run");

}

}

classStaticCodeDemo

{

static

{

System.out.println("b");

}

publicstaticvoidmain(String[]?args)

{

//StaticCode?s=null;?//?這種情形不會輸出：a?,因為此時對象s?并沒有指向

//s=new?StaticCode();?//會輸出：a??????//此時用到了類的構造函數

StaticCode.show();//會輸出：a

}

static

{

System.out.println("c");

}

}

對象的初始化過程?Person p=new Person("zh");

該句都做了什么事情

1.?因為new用到了Person.class,所以會先找到Person.class文件并加載到內存中。

2.?執行該類中的static代碼塊，如果有的話，給Person.class類進行初始化。

3. d

總結

以上是生活随笔為你收集整理的java静态代码块的作用域_java基础之面向对象的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。