黑馬程序員--面向對象（一）封裝、成員變量與局部變量、匿名對象、構造函數、this關鍵字

時間 2019-11-09

原文原文鏈接

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS開發</a>、<a href="http://edu.csdn.net"target="blank">.Net培訓</a>、期待與您交流！ ----------------------java

面向對象安全

l 理解面向對象函數

l 面向對象是相對面向過程而言學習

l 面向對象和麪向過程都是一種思想this

l 面向過程：強調的是功能行爲spa

l 面向對象：將功能封裝進對象，強調具有了功能的對象.net

l 面向對象是基於面向過程的code

面向對象的三大特徵：對象

封裝，繼承，多態blog

之後開發：其實就是找對象使用，沒有對象，就建立對象

找對象，創建對象，使用對象，維護對象

類和對象的關係：

類就是：對現實生活中事物的描述

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

例：

現實生活中的對象：張三，李四

想要描述：提取對象中的共性內容，對事物的抽象

描述時：這些對象的共性有：姓名，年齡，性別，學習功能

映射到Java中，描述就是class定義的類

具體對象就是對應java在堆內存中用new創建的實體

描述事物其實就是在描述事的屬性與行爲。

屬性：對應是類中變量，行爲：對應的類中的函數（方法），

其實定義類就是在描述事物，就是在定義屬性和行爲，屬性和行爲共同成爲類中的成員（成員變量和成員方法）

例：描述汽車（顏色，輪胎數）

 1 class  car
 2 {
 3     //描述顏色
 4     String color="紅色"；
 5     //描述輪胎數
 6     int num=4;
 7     //運行行爲
 8     void run(){
 9         System.out.println(color+".."+num);
10     }
11 }
12 class CarDemo
13 {
14     public void static main(Stirng [] args){
15         //生產汽車，在java中經過new操做符來完成
16         //其實就是在對內存產生一個實體
17         Car c=new Car();//就是一個類類型變量，記住：類類型變量指向對象
18         //需求：將已有的顏色改爲藍色，指揮該對象作,使用.在java指揮方式是：對象.成員
19         c.color="bule";
20         c.run();
21 
22         Car c1=new Car();//新的車
23         c1.run();
24     }
25 }

成員變量和局部變量的區別

成員變量做用於整個類中

局部變量做用於函數中，或者語句中

在內存中的位置

成員變量在堆內存中，由於對象的存在，纔在內存中存在

局部變量在棧內存中

匿名對象：

匿名對象是對象的簡化形式

匿名對象兩種使用狀況

匿名對象使用方式一：當對對象方法只調用一次時，能夠用匿名對象來完成，這樣寫比較簡化，若是對一個對象進行多個成員調用，必須給這個對象起個名字

例：

Car c=new Car ();

c.num=5;

這兩句話能夠簡寫成一句換：

new Car ( ).num=5;

匿名對象使用方式二：匿名對象能夠做爲實際參數進行傳遞

例：

Car q=new Car();

show(q);

public static void show(Car c){

c.num=3;

c.color=」black」;

c.run();

}

使用匿名類簡化

Show(new Car());

public static void show(Car c){

c.num=3;

c.color=」black」;

c.run();

}

封裝（Encapsulation）

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

好處：

將變化隔離

便於使用

提升重用性

提升安全性

封裝原則：

將不須要對外提供的內容都隱藏起來

把屬性都隱藏，提供公共方式對其訪問

如何封裝：

可使用private形式：注意：私有僅僅是封裝的一種表現形式

Private :私有，權限修飾符，用於修飾類中的成員（成員變量，成員函數）

（私有隻在本類中有效）

當使用private修飾成員後，其餘類不能訪問被private修飾的成員，因此這是須要一些對外提供的方法，能夠進行訪問與修改

之因此對外提供訪問方式，就由於能夠在訪問方式中加入邏輯判斷等語句，對訪問的數據進行操做，提升代碼健壯性

例：

 1 class  Person
 2 {
 3     private int age;
 4     //定義對外提供的方法，用於對age的修改
 5     public void setAge(int a){
 6         if(a>0&&a<130){
 7             age=a;
 8             speak();
 9         }
10         else{
11             System.out.println("年齡錯誤");
12         }
13     }
14     public int getAge(){
15         return age;
16     }
17     void speak(){
18         System.out.println("age="+age);
19     }
20 }
21 class PersonDemo
22 {
23     public static void main(String[] args) {
24         Person p=new Person();
25         p.setAge(20);
26     }
27 }

構造函數：

特色：

函數名與類名相同
不用定義返回值類型
不能夠寫return語句

 1 例：
 2 class  Person
 3 {
 4     Person(){
 5         System.out.println("Person run");
 6     }
 7 }
 8 class PersonDemo2
 9 {
10     public static void main(String []args){
11         Person p=new Person();
12     }
13 }

結果：Person run

結論：對象一創建就會調用與之對應的構造函數

做用：

能夠用於給對象進行初始化

注意：

默認構造函數的特色：

當一個類中沒有定義構造函數時，那麼系統會默認給該類加一個空參數的構造函數

Person (){}

當在類中定義了構造函數後，默認的構造函數就沒有了

這個默認的構造函數的權限和所屬類一致

若是類被public修飾，那麼默認的構造函數也帶public修飾符

若是類沒有被public修飾，那麼默認的構造函數，也沒有public修飾

默認構造函數的權限是隨着類的變化而變化的

2. 構造函數在運行上與通常方法的不一樣：

構造方法是在對象一創建就運行，給對象初始化，而通常方法是對象調用才執行，給對象添加對象具有的功能

一個對象創建，構造函數只運行一次，而通常方法能夠被該對象調用屢次

3.多個構造函數是以重載的形式存在的

例：

 1 class Person 
 2 {
 3     private String name;
 4     private int age;
 5     //默認的構造函數
 6     Person(){
 7         System.out.println("A：name="+name+",,age="+age);
 8     }
 9     //方法的重載：方法名同樣，參數列表不一樣
10     Person(String n){
11         name=n;
12         System.out.println("B: name="+name+",,age="+age);
13     }
14     Person(String n,int a){
15         name=n;
16         age=a;
17 System.out.println("C: name="+name+",,age="+age);
18     }
19 }
20 class PersonDemo3
21 {
22     public static void main(String [] args){
23         Person p1=new Person();
24         Person p2=new Person("lisi");
25         Person p3=new Person("wangwu",10);
26     }
27 }

何時定義構造函數？

當分析事物時，該事物存在就具有一些特性或者行爲，那麼將這些內容定義在構造函數中

構造代碼塊：

做用：給對象進行初始化

對象一創建就運行，並且優先於構造函數執行和構造函數的區別

構造代碼塊是給全部對象進行提議初始化，而構造函數是給對應的對象初始化，構造代碼塊中定義的是不一樣對象：共性的初始化內容，當你想每次new對象的時候都須要有相同的操做時，使用構造代碼塊

注意：每次每一個對象實例化都會執行它

語法：

｛

語句；

｝

例：

 1 class Person 
 2 {
 3     private String name;
 4     private int age;
 5     //構造代碼塊
 6     {
 7         System.out.println("構造代碼塊");
 8     }
 9       Person(){
10         System.out.println("A：name="+name+",,age="+age);
11     }
12     Person(String n){
13         name=n;
14         System.out.println("B: name="+name+",,age="+age);
15     }
16 }
17 class PersonDemo3
18 {
19     public static void main(String [] args){
20         Person p1=new Person();
21         Person p2=new Person("lisi");
22     }
23 }

結果:

this 關鍵字

this:就表明本類的對象

this表明他所在函數所屬對象的引用

簡單說：哪一個對象在調用this所在的函數，this就表明哪一個對象

this的應用：

1.成員變量和局部變量重名，能夠用this來區分

當定義類中功能時：該函數內部要用到調用函數的對象時，這時用this來表示這個對象，但凡本類功能內部使用到了本類對象，都用this表示

例：

 1 class Person 
 2 {
 3     private String name;
 4     private int age;
 5     //當成員變量和局部變量，用this來區分
 6     Person(String name){
 7         this.name=name;//this表明本類對象，誰調用它this表明誰
 8     }
 9     Person(String n,int a){
10         name=n;
11         age=a;
12     }
13     public void speak(){
14         System.out.println("name="+name+"...age="+age);//省略了this：this.name;this.age
15         show();//也省略了this:this.show();
16     }
17     public void show(){
18         System.out.println(name);//其實都省略了this:this.name
19     }
20 }
21 class PersonDemo4
22 {
23     public static void main(String []args){
24         Person p=new Person("lisi");
25         Person p1=new Person("zhangsan");
26         p.speak();
27         p1.speak();
28 
29     }
30 }

結果：

需求：定義功能：給人定義一個用於比較年齡是否相同的功能，也就是是不是同齡人

 1 class Person
 2 {
 3     private int age;//年齡
 4     Person(int age){//Person類的構造方法
 5         this.age=age;
 6     }
 7     public boolean compare(Person p){
 8         return this.age==p.age;//這裏的this指p1，由於p1.compare(p2),是p1調用的它
 9     }
10 }
11 class  PersonDemo5
12 {
13     public static void main(String []agrs){
14         Person p1=new Person(20);
15         Person p2=new Person(25);
16         boolean b=p1.compare(p2);
17         System.out.println(b);
18     }
19 }