java静态代码块的作用域_java基础之面向对象
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基础之面向对象的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： java对象工厂池_[转载]Java对象
- 下一篇： java pid 获取句柄_获取进程pi