Java開發之旅之面向對象

                            Java開發之旅之面向對象


類是組成java程序的基本要素,類的3大特性:封裝、繼承和多態。類的封裝相當於一個黑匣子,放在黑匣子裏面的東西你什麼也看不到。繼承是類的一個重要屬性,可以從一個簡單的類繼承出相對複雜的高級類,這樣可使程序編寫的工作量大大減輕。多態則可以動態地對對象進行調用,使對象之間變得相對獨立。

面向對象特點:

1:將複雜的事情簡單化。

2:面向對象將以前的過程中的執行者,變成了指揮者。

3:面向對象這種思想是符合現在人們思考習慣的一種思想。

 

我的總結:過程其實就是函數;對象是將函數等一些內容進行了封裝。

 

在類中定義其實都稱之爲成員,成員有兩種

1:成員變量:其實對應的就是事物的屬性。

2:成員函數:其實對應的就是事物的行爲。

 

其實定義類,就是在定義成員變量和成員函數。但是在定義前,必須先要對事物進行屬性和行爲的分析,纔可以用代碼來體現。

 

private int age;//私有的訪問權限最低,只有在本類中的訪問有效。

注意:私有僅僅是封裝的一種體現形式而已。 

私有的成員:其他類不能直接創建對象訪問,所以只有通過本類對外提供具體的訪問方式來完成對私有的訪問,可以通過對外提供函數的形式對其進行訪問。

好處:可以在函數中加入邏輯判斷等操作,對數據進行判斷等操作。

 

類中怎麼沒有定義主函數呢?

注意:主函數的存在,僅爲該類是否需要獨立運行,如果不需要,主函數是不用定義的。

主函數的解釋:保證所在類的獨立運行,是程序的入口,被jvm調用。

 

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

1:成員變量直接定義在類中。

   局部變量定義在方法中,參數上,語句中。

2:成員變量在這個類中有效。

局部變量只在自己所屬的大括號內有效,大括號結束,局部變量失去作用域。

3:成員變量存在於堆內存中,隨着對象的產生而存在,消失而消失。

局部變量存在於棧內存中,隨着所屬區域的運行而存在,結束而釋放。

 

構造函數:用於給對象進行初始化,是給與之對應的對象進行初始化,它具有針對性,函數中的一種。

特點:

1:該函數的名稱和所在類的名稱相同。

2:不需要定義返回值類型。

3:該函數沒有具體的返回值。

記住:所有對象創建時,都需要初始化纔可以使用。

 

注意事項:一個類在定義時,如果沒有定義過構造函數,那麼該類中會自動生成一個空參數的構造函數,爲了方便該類創建對象,完成初始化。如果在類中自定義了構造函數,那麼默認的構造函數就沒有了。

 

一個類中,可以有多個構造函數,因爲它們的函數名稱都相同,所以只能通過參數列表來區分。所以,一個類中如果出現多個構造函數。它們的存在是以重載體現的。

 

構造函數和一般函數區別

1:兩個函數定義格式不同。

2:構造函數是在對象創建時,就被調用,用於初始化,而且初始化動作只執行一次。

    一般函數,是對象創建後,需要調用才執行,可以被調用多次。

   

構造代碼塊和構造函數區別

構造代碼塊:是給所有的對象進行初始化,也就是說,所有的對象都會調用一個代碼塊。只要對象一建立。就會調用這個代碼塊。

構造函數:是給與之對應的對象進行初始化。它具有針對性。

 

Person p = new Person();

創建一個對象都在內存中做了一下這些事情:

1:先將硬盤上指定位置的Person.class文件加載進內存。

2:執行main方法時,在棧內存中開闢了main方法的空間(壓棧-進棧),然後在main方法的棧區分配了一個變量p。

3:在堆內存中開闢一個實體空間,分配了一個內存首地址值。new

4:在該實體空間中進行屬性的空間分配,並進行了默認初始化。

5:對空間中的屬性進行顯示初始化。

6:進行實體的構造代碼塊初始化。

7:調用該實體對應的構造函數,進行構造函數初始化。()

8:將首地址賦值給p ,p變量就引用了該實體。(指向了該對象)

--------------------------------------------------------------------------------------------

1、封 裝(面向對象特徵之一)是指隱藏對象的屬性和實現細節,僅對外提供公共訪問方式。

好處:將變化隔離;便於使用;提高重用性;安全性。

封裝原則:將不需要對外提供的內容都隱藏起來,把屬性都隱藏,提供公共方法對其訪問。

 

例如

class Person {

// 對屬性的封裝

private String name;

private int age;

 

void talk() {

System.out.println("我是" + getName() + ",今年" + getAge() + "歲");

}

 

public void setName(String name) {

this.name = name;

}

 

public String getName() {

return name;

}

 

public void setAge(int age) {

this.age = age;

}

 

public int getAge() {

return age;

}

}

 

public class Test {

public static void main(String[] args) {

// 聲明並實例化對象

Person p = new Person();

// 給p中的name屬性賦值

p.setName("張三");

// 給p中的age賦值

p.setAge(20);

// 調用Preson類中的talk()方法。

p.talk();

}

}

this:代表對象。就是所在函數所屬對象的引用。

this到底代表什麼呢?哪個對象調用了this所在的函數,this就代表哪個對象,就是哪個對象的引用。

開發時,什麼時候使用this呢?

在定義功能時,如果該功能內部使用到了調用該功能的對象,這時就用this來表示這個對象。

 

this 還可以用於構造函數間的調用。

調用格式:this(實際參數);

this對象後面跟上 .  調用的是成員屬性和成員方法(一般方法);

this對象後面跟上 () 調用的是本類中的對應參數的構造函數。

 

注意:用this調用構造函數,必須定義在構造函數的第一行。因爲構造函數是用於初始化的,所以初始化動作一定要執行。否則編譯失敗。

 

static:★★★ 關鍵字,是一個修飾符,用於修飾成員(成員變量和成員函數)。

特點:

1,想要實現對象中的共性數據的對象共享。可以將這個數據進行靜態修飾。

2,被靜態修飾的成員,可以直接被類名所調用。也就是說,靜態的成員多了一種調用方式。類名.靜態方式。

3,靜態隨着類的加載而加載。而且優先於對象存在。

 

弊端:

1,有些數據是對象特有的數據,是不可以被靜態修飾的。因爲那樣的話,特有數據會變成對象的共享數據。這樣對事物的描述就出了問題。所以,在定義靜態時,必須要明確,這個數據是否是被對象所共享的。

2,靜態方法只能訪問靜態成員,不可以訪問非靜態成員。

因爲靜態方法加載時,優先於對象存在,所以沒有辦法訪問對象中的成員。

3,靜態方法中不能使用this,super關鍵字。

因爲this代表對象,而靜態在時,有可能沒有對象,所以this無法使用。

4,主函數是靜態的。

 

什麼時候定義靜態成員呢?或者說:定義成員時,到底需不需要被靜態修飾呢?

成員分兩種:

1,成員變量。(數據共享時靜態化)

該成員變量的數據是否是所有對象都一樣:

如果是,那麼該變量需要被靜態修飾,因爲是共享的數據。 

如果不是,那麼就說這是對象的特有數據,要存儲到對象中。 

2,成員函數。(方法中沒有調用特有數據時就定義成靜態)

如果判斷成員函數是否需要被靜態修飾呢?

只要參考,該函數內是否訪問了對象中的特有數據:

如果有訪問特有數據,那方法不能被靜態修飾。

如果沒有訪問過特有數據,那麼這個方法需要被靜態修飾。

 

成員變量和靜態變量的區別:

1,成員變量所屬於對象。所以也稱爲實例變量。

靜態變量所屬於類。所以也稱爲類變量。

2,成員變量存在於堆內存中。

靜態變量存在於方法區中。

3,成員變量隨着對象創建而存在。隨着對象被回收而消失。

靜態變量隨着類的加載而存在。隨着類的消失而消失。

4,成員變量只能被對象所調用 。

靜態變量可以被對象調用,也可以被類名調用。

所以,成員變量可以稱爲對象的特有數據,靜態變量稱爲對象的共享數據。

 

靜態的注意:靜態的生命週期很長。

靜態代碼塊:就是一個有靜態關鍵字標示的一個代碼塊區域。定義在類中。

作用:可以完成類的初始化。靜態代碼塊隨着類的加載而執行,而且只執行一次(new 多個對象就只執行一次)。如果和主函數在同一類中,優先於主函數執行。

 

Public:訪問權限最大。

static:不需要對象,直接類名即可。

void:主函數沒有返回值。

Main:主函數特定的名稱。

(String[] args):主函數的參數,是一個字符串數組類型的參數,jvm調用main方法時,傳遞的實際參數是 new String[0]。

 

jvm默認傳遞的是長度爲0的字符串數組,我們在運行該類時,也可以指定具體的參數進行傳遞。可以在控制檯,運行該類時,在後面加入參數。參數之間通過空格隔開。jvm會自動將這些字符串參數作爲args數組中的元素,進行存儲。

 

靜態代碼塊、構造代碼塊、構造函數同時存在時的執行順序:靜態代碼塊 à 構造代碼塊 à 構造函數;

 

生成Java幫助文檔:命令格式:javadoc –d 文件夾名 –auther –version *.java

 

2、繼 承(面向對象特徵之一)

好處:

1:提高了代碼的複用性。

2:讓類與類之間產生了關係,提供了另一個特徵多態的前提。

 

父類的由來:其實是由多個類不斷向上抽取共性內容而來的。

java中對於繼承,java只支持單繼承。java雖然不直接支持多繼承,但是保留了這種多繼承機制,進行改良。

 

單繼承:一個類只能有一個父類。

多繼承:一個類可以有多個父類。

繼承的關鍵字extends

繼承的格式:

單繼承:

class A{  }

Class B extends A{

}

多重繼承:

class A{  }

Class B extends A{

}

Class C extends B{ }

但是絕不能這樣:class C extends A,B{}

 

繼承的例子:

class Person {

// 對屬性的封裝

String name;

 int age;

 

void talk() {

System.out.println("我是" + name",今年" + age + "歲");

}

 

}

class Student extends Person{

String school;

}

public class Test {

public static void main(String[] args) {

// 聲明並實例化對象

Person p = new Person();

// 給p中的name屬性賦值

p.name="李四";

// 給p中的age賦值

p.age=20;

// 調用Preson類中的talk()方法。

p.talk();

Student stu=new Student();

stu.name="王五 ";

stu.age=20;

stu.talk();

System.out.println(stu.school="xxxxx學校");

}

}

 

爲什麼不支持多繼承呢?

因爲當一個類同時繼承兩個父類時,兩個父類中有相同的功能,那麼子類對象調用該功能時,運行哪一個呢?因爲父類中的方法中存在方法體。

但是java支持多重繼承。A繼承B  B繼承C  C繼承D。

多重繼承的出現,就有了繼承體系。體系中的頂層父類是通過不斷向上抽取而來的。它裏面定義的該體系最基本最共性內容的功能。

所以,一個體系要想被使用,直接查閱該系統中的父類的功能即可知道該體系的基本用法。那麼想要使用一個體系時,需要建立對象。建議建立最子類對象,因爲最子類不僅可以使用父類中的功能。還可以使用子類特有的一些功能。

 

簡單說:對於一個繼承體系的使用,查閱頂層父類中的內容,創建最底層子類的對象。 

 

子父類出現後,類中的成員都有了哪些特點:

1:成員變量。

 當子父類中出現一樣的屬性時,子類類型的對象,調用該屬性,值是子類的屬性值。

 如果想要調用父類中的屬性值,需要使用一個關鍵字:super 

 This:代表是本類類型的對象引用。

 Super:代表是子類所屬的父類中的內存空間引用。

 注意:子父類中通常是不會出現同名成員變量的,因爲父類中只要定義了,子類就不用在定義了,直接繼承過來用就可以了。

2:成員函數。

當子父類中出現了一模一樣的方法時,建立子類對象會運行子類中的方法。好像父類中的方法被覆蓋掉一樣。所以這種情況,是函數的另一個特性:覆蓋(複寫,重寫)

什麼時候使用覆蓋呢?當一個類的功能內容需要修改時,可以通過覆蓋來實現。

3:構造函數。

發現子類構造函數運行時,先運行了父類的構造函數。爲什麼呢?

原因:子類的所有構造函數中的第一行,其實都有一條隱身的語句super();

super(): 表示父類的構造函數,並會調用於參數相對應的父類中的構造函數。而super():是在調用父類中空參數的構造函數。

爲什麼子類對象初始化時,都需要調用父類中的函數?(爲什麼要在子類構造函數的第一行加入這個super()?)

因爲子類繼承父類,會繼承到父類中的數據,所以必須要看父類是如何對自己的數據進行初始化的。所以子類在進行對象初始化時,先調用父類的構造函數,這就是子類的實例化過程。

 

注意:子類中所有的構造函數都會默認訪問父類中的空參數的構造函數,因爲每一個子類構造內第一行都有默認的語句super(); 

如果父類中沒有空參數的構造函數,那麼子類的構造函數內,必須通過super語句指定要訪問的父類中的構造函數。

如果子類構造函數中用this來指定調用子類自己的構造函數,那麼被調用的構造函數也一樣會訪問父類中的構造函數。

 

問題:super()和this()是否可以同時出現的構造函數中。

兩個語句只能有一個定義在第一行,所以只能出現其中一個。

 

super()或者this():爲什麼一定要定義在第一行?

因爲super()或者this()都是調用構造函數,構造函數用於初始化,所以初始化的動作要先完成。

 

繼承的細節:

什麼時候使用繼承呢?

當類與類之間存在着所屬關係時,才具備了繼承的前提。a是b中的一種。a繼承b。狼是犬科中的一種。

英文書中,所屬關係:" is a "

注意:不要僅僅爲了獲取其他類中的已有成員進行繼承。

 

所以判斷所屬關係,可以簡單看,如果繼承後,被繼承的類中的功能,都可以被該子類所具備,那麼繼承成立。如果不是,不可以繼承。

 

細節二:

在方法覆蓋時,注意兩點:

1:子類覆蓋父類時,必須要保證,子類方法的權限必須大於等於父類方法權限可以實現繼承。否則,編譯失敗。

2:覆蓋時,要麼都靜態,要麼都不靜態。 (靜態只能覆蓋靜態,或者被靜態覆蓋)

 

繼承的一個弊端:打破了封裝性。對於一些類,或者類中功能,是需要被繼承,或者複寫的。

這時如何解決問題呢?介紹一個關鍵字,final:最終。

 

 

3、多 態(面向對象特徵之一):函數本身就具備多態性,某一種事物有不同的具體的體現。

 

體現:父類引用或者接口的引用指向了自己的子類對象。//Animal a = new Cat();

多態的好處:提高了程序的擴展性。

多態的弊端:當父類引用指向子類對象時,雖然提高了擴展性,但是隻能訪問父類中具備的方法,不可以訪問子類中特有的方法。(前期不能使用後期產生的功能,即訪問的侷限性)

多態的前提:

1:必須要有關係,比如繼承、或者實現。

2:通常會有覆蓋操作。

 

多態的出現思想上也做着變化:以前是創建對象並指揮對象做事情。有了多態以後,我們可以找到對象的共性類型,直接操作共性類型做事情即可,這樣可以指揮一批對象做事情,即通過操作父類或接口實現。

例如:

class Dog{

void eat(){

System.out.println("一般的狗吃一般的狗糧!");

}

}

 

class HashDog extends Dog{

void eat(){

System.out.println("哈士奇吃哈士奇的狗糧!");

}

}

 

class ZangAoDog extends Dog{

void eat(){

System.out.println("藏獒吃藏獒的狗糧!");

}

}

 

//定義一個動物園喂的方法

class Zoo{

void feed(Dog d){

d.eat();

}

}

 

public class Demo11 {

public static void main(String[] args) {

Dog hd = new HashDog();

Dog zd = new ZangAoDog();

Zoo z = new Zoo();

z.feed(hd);

z.feed(zd);

}

}

---------------------------------------------------------------

如果想用子類對象的特有方法,如何判斷對象是哪個具體的子類類型呢?

可以可以通過一個關鍵字 instanceof ;//判斷對象是否實現了指定的接口或繼承了指定的類

 

格式:<對象 instanceof 類型> ,判斷一個對象是否所屬於指定的類型。

 

我的總結:封裝、繼承和多態是java的重要特徵,必須要掌握好


 

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章