JavaSE筆記（二）面向對象

什么是對象

1.對象的概念：對特定一個存在事物
2.什么是面向對象：以自我為中心對待一個特定事物存在，需要自己描述出來的符合的條件
3.類：是對象的一個屬性一個特征，是你描述的條件，條件符合的多個對象可以歸納為一個類，也可以說這個對象含有這個類。
4.什么是對象的屬性：對象有的各種特征，他具有什么就是對象的屬性。
5.什么是對象的方法：對象能干什么
6.類與對象的關系/區別：類是抽象的概念是一個模板，是條件信息。對象是一個具體的東西，是一個客觀存在。好比是類是能打電話，能發短信的功能條件。而對象就是一部手機。

如何定義一個類：

1.類的重要性：所有java程序都是以類class為組織單元的，是基本元素。
2.類是模子，確定對象將會擁有什么樣的特征（屬性）和行為（方法）。先有類才能夠描述具體對象。
3.類的組成：屬性和方法
4.定義一個類的順序：
a.定義類名：publi class 類名{內容}，class是定義類的關鍵字。
b.編寫類的屬性：在{}內定義不同的屬性類型，可以是一種可以是N種。
c.編寫類的方法：可以多種行為，可以一種。

如何使用Java中的對象
⑴使用對象的步驟：

①創建對象：
類名 對象名= new 類名();//對一個類實例化
Telphone phone = new Telphone();
②使用對象：
引用對象的屬性：對象名.屬性
phone.screen = 5;//給screen屬性賦值5
引用對象的方法：對象名.方法
phone.sendMessage();//調用sendMessage()方法
例：

package com.imooc;

public class InitailTelphone {

public static void main(String[] args) {
// TODO Auto-generated method stub
Telphone phone=new Telphone();
phone.sendMessage();
//給實例變量賦值
phone.screen=5.0f;
phone.cpu=1.4f;
phone.mem=2.0f;
//調用對象的方法
phone.sendMessage();
}
}

成員變量：在類中定義，用來描述對象將要有什么（屬性）。可被本類方法和其他跟當前類有關系的方法使用。
局部變量：在類的方法中定義，在方法中臨時保存數據。（只能在當前的方法中使用）

區別：
1.作用域不同：局部變量的作用域僅限于定義它的方法，成員變量的作用域在整個類內部都是可見的。
2.初始值不同：java會給成員變量一個初始值，java不會給局部變臉賦予初始值。
3.在同一個方法中，不允許有同名局部變量；在不同的方法中，可以有同名局部變量。
4.兩類變量同名時，局部變量具有更高的優先級。
構造方法:
1.使用new+構造方法創建一個新的對象
2.構造方法是定義在Java類中的一個用來初始化對象的方法,構造方法與類同名且沒有返回值

構造方法的語法格式:
public 構造方法名(){
//初始化代碼
}
public后面沒有返回值類型,構造方法名與類名相同,括號內可以指定參數

3.無參構造方法的使用

main():
Telphone phone=new Telphone();
class TelPhone:
public Telphone(){
System.out.println("Telphone構造方法執行了");
}

如果我們沒有指定一個無參的構造方法,那系統會幫我們自動生成一個無參的構造方法,如果我們對系統生成的無參構造方法不滿意,可以自定義一個無參的構造方法

也就是說當我們創建對象的時候,其實我們執行的是構造方法

4.有參構造方法的使用

main():
Telphone phone2=new Telphone(4.0f, 2.0f, 2.0f);
class Telphone:
public Telphone(float newScreen,float newCpu,float newMem){
screen=newScreen;
cpu=newCpu;
mem=newMem;
}

有參構造方法的目的就是初始化對象中成員變量的值

通過無參或者有參的構造方法都可以創建對象,但是后者不但可以創建對象而且可以給對象中的實例變量賦初值

5.當沒有指定構造方法時,系統會自動添加無參的構造方法
6.當有指定構造方法時,無論是有參無參的構造方法,都不會自動添加無參的構造方法
7.構造方法的重載:方法名相同,但參數不同的多個方法,調用時會自動根據不同的參數選擇相應的方法
8.構造方法不但可以給對象的屬性賦值,還可以保證給對象的屬性賦一個合理的值

Java 中的 static 使用之靜態變量

大家都知道，我們可以基于一個類創建多個該類的對象，每個對象都擁有自己的成員，互相獨立。然而在某些時候，我們更希望該類所有的對象共享同一個成員。此時就是 static 大顯身手的時候了！！

Java 中被 static 修飾的成員稱為靜態成員或類成員。它屬于整個類所有，而不是某個對象所有，即被類的所有對象所共享。靜態成員可以使用類名直接訪問，也可以使用對象名進行訪問。當然，鑒于他作用的特殊性更推薦用類名訪問~~

使用 static 可以修飾變量、方法和代碼塊。

要注意哦：靜態成員屬于整個類，當系統第一次使用該類時，就會為其分配內存空間直到該類被卸載才會進行資源回收！~~

Java 中的 static 使用之靜態方法

1、 靜態方法中可以直接調用同類中的靜態成員，但不能直接調用非靜態成員。
如果希望在靜態方法中調用非靜態變量，可以通過創建類的對象，然后通過對象來訪問非靜態變量。如：

Paste_Image.png

2、 在普通成員方法中，則可以直接訪問同類的非靜態變量和靜態變量，

3、 靜態方法中不能直接調用非靜態方法，需要通過對象來訪問非靜態方法。

Java 中的 static 使用之靜態初始化塊

需要特別注意：靜態初始化塊只在類加載時執行，且只會執行一次，同時靜態初始化塊只能給靜態變量賦值，不能初始化普通的成員變量。

面向對象的三大特性：封裝、繼承、多態

封裝：
將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問。
好處：只能通過規定的方法訪問數據；隱藏類的實例細節，方便修改和實現。
封裝實現方法：1）、修改屬性可見性。2）、創建getter\setter方法。3）、在getter\setter中加入屬性控制語句(對屬性值的合法性進行判斷)。
封裝 ：

1.類變成private float screen;
2. 加get/set
public float getScreen(){
return screen;
}
public void setScreen(float newScreen){
screen=newScreen;
}
3. main調用： phone.setscreen(6.0f);
System.out.printly(phone.getScreen());
好處：只能通過規定的方法訪問數據；隱藏類的實例細節，方便修改和實現。
封裝的信息的類的名字是沖突的

java中包的作用：
1.管理java文件
2.管理同名文件沖突
加上不同的包來區分相同文件名的類

包的定義：packege,包名間可以用點來區別文件夾
且要放在java程序的第一行

類名相同的可以用包名來區分
java.lang.(類) 放置java語言基礎類
java.util.(類)放置java語言工具類
java.io.(類)包含輸入輸出相關功能的類

用import來顯示在某個文件中的其他文件中的類
在包中不能存放相同名字的類
默認情況下會把同一個包名導入進來
包 名全部是小寫

訪問修飾符：修飾屬性和方法的訪問范圍
Paste_Image.png
java this關鍵字
1.this關鍵字代表當前對象
this.屬性 操作當前對象的屬性
this.方法 調用當前對象的方法

2.封裝對象的屬性的時候，經常會使用this關鍵字
public void setJia(double jia){
this.jia=jia;//this.屬性=參數；就是將參數的值付給當前對象的屬性（為了區分屬性和參數）
this.sendMessage();//this.方法；就是調用當前對象的sendMessage（）方法。
}

什么是 Java 中的內部類

問：什么是內部類呢？

答：內部類（ Inner Class ）就是定義在另外一個類里面的類。與之對應，包含內部類的類被稱為外部類。

問：那為什么要將一個類定義在另一個類里面呢？清清爽爽的獨立的一個類多好啊！！

答：內部類的主要作用如下：

  1. 內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類

  2. 內部類的方法可以直接訪問外部類的所有數據，包括私有的數據

  3. 內部類所實現的功能使用外部類同樣可以實現，只是有時使用內部類更方便

問：內部類有幾種呢？

答：內部類可分為以下幾種：

成員內部類
靜態內部類
方法內部類
匿名內部類

Java 中的成員內部類

員內部類的使用方法：
1、 Inner 類定義在 Outer 類的內部，相當于 Outer 類的一個成員變量的位置，Inner 類可以使用任意訪問控制符，如 public 、 protected 、 private 等

2、 Inner 類中定義的 test() 方法可以直接訪問 Outer 類中的數據，而不受訪問控制符的影響，如直接訪問 Outer 類中的私有屬性a

3、 定義了成員內部類后，必須使用外部類對象來創建內部類對象，而不能直接去 new 一個內部類對象，即：內部類 對象名 = 外部類對象.new 內部類( );

4、 編譯上面的程序后，會發現產生了兩個 .class 文件

友情提示哦：
1、 外部類是不能直接使用內部類的成員和方法滴
可先創建內部類的對象，然后通過內部類的對象來訪問其成員變量和方法。

2、 如果外部類和內部類具有相同的成員變量或方法，內部類默認訪問自己的成員變量或方法，如果要訪問外部類的成員變量，可以使用 this 關鍵字。如：

運行結果：

//外部類HelloWorld
public class HelloWorld{
    
    //外部類的私有屬性name
    private String name = "imooc";
    
    //外部類的成員屬性
    int age = 20;
    
    //成員內部類Inner
    public class Inner {
        String name = "愛慕課";
        //內部類中的方法
        public void show() { 
            System.out.println("外部類中的name：" +  HelloWorld.this.name               );
            System.out.println("內部類中的name：" +  name                );
            System.out.println("外部類中的age：" + age);
        }
    }
    
    //測試成員內部類
    public static void main(String[] args) {
        
        //創建外部類的對象
        HelloWorld o = new HelloWorld (); 
        
        //創建內部類的對象
        Inner inn = o.new Inner() ;
        
        //調用內部類對象的show方法
        inn.show();
    }
}
Java 中的靜態內部類

靜態內部類：
1、 靜態內部類不能直接訪問外部類的非靜態成員，但可以通過 new 外部類().成員 的方式訪問
2、 如果外部類的靜態成員與內部類的成員名稱相同，可通過“類名.靜態成員”訪問外部類的靜態成員；如果外部類的靜態成員與內部類的成員名稱不相同，則可通過“成員名”直接調用外部類的靜態成員
3、 創建靜態內部類的對象時，不需要外部類的對象，可以直接創建 內部類 對象名= new 內部類();

Java 中的方法內部類

為什么要使用內部類？在《Think in java》中有這樣一句話：使用內部類最吸引人的原因是：每個內部類都能獨立地繼承一個（接口的）實現，所以無論外圍類是否已經繼承了某個（接口的）實現，對于內部類都沒有影響。
在我們程序設計中有時候會存在一些使用接口很難解決的問題，這個時候我們可以利用內部類提供的、可以繼承多個具體的或者抽象的類的能力來解決這些程序設計問題。可以這樣說，接口只是解決了部分問題，而內部類使得多重繼承的解決方案變得更加完整。
其實使用內部類最大的優點就在于它能夠非常好的解決多重繼承的問題，但是如果我們不需要解決多重繼承問題，那么我們自然可以使用其他的編碼方式，但是使用內部類還能夠為我們帶來如下特性（摘自《Think in java》）：
1、內部類可以用多個實例，每個實例都有自己的狀態信息，并且與其他外圍對象的信息相互獨立。
2、在單個外圍類中，可以讓多個內部類以不同的方式實現同一個接口，或者繼承同一個類。
3、創建內部類對象的時刻并不依賴于外圍類對象的創建。
4、內部類并沒有令人迷惑的“is-a”關系，他就是一個獨立的實體。
5、內部類提供了更好的封裝，除了該外圍類，其他類都不能訪問。

繼承

1、繼承的概念：繼承是類與類的一種關系；Java中的繼承是單繼承，只有一個父類。
2、繼承的好處：子類直接擁有父親的所有屬性和方法。---private實現的無效！
代碼可復用。
class 子類 extends 父類{……}

重寫方法的規則：

1、參數列表必須完全與被重寫的方法相同，否則不能稱其為重寫而是重載。
2、返回的類型必須一直與被重寫的方法的返回類型相同，否則不能稱其為重寫而是重載。如果在子類中寫了一個只有返回類型不同的函數，將不是重寫，且會報錯
3、訪問修飾符的限制一定要大于被重寫方法的訪問修飾符（public>protected>default>private）
4、重寫方法一定不能拋出新的檢查異常或者比被重寫方法申明更加寬泛的檢查型異常。例如：

父類的一個方法申明了一個檢查異常IOException，在重寫這個方法是就不能拋出Exception,只能拋出IOException的子類異常，可以拋出非檢查異常。

而重載的規則：
1、必須具有不同的參數列表；
2、可以有不責罵的返回類型，只要參數列表不同就可以了；
3、可以有不同的訪問修飾符；
4、可以拋出不同的異常；

重寫與重載的區別在于：
重寫多態性起作用，對調用被重載過的方法可以大大減少代碼的輸入量，同一個方法名只要往里面傳遞不同的參數就可以擁有不同的功能或返回值。

用好重寫和重載可以設計一個結構清晰而簡潔的類，可以說重寫和重載在編寫代碼過程中的作用非同一般.
重寫是除了函數體其他必須完全相同，如果參數不同則是重載，如果參數相同而返回類型不同則會報錯

繼承的初始化順序：

1.初始化父類再初始化子類。
2.先執行初始化對象中的屬性，再執行構造方法中的初始化。
父類對象-->屬性初始化--->構造方法
子類對象-->屬性初始化--->構造方法

final關鍵字： 表示“最終的”，即不可修改。

final可以修飾類、方法、屬性和變量
1、修飾類：不允許被繼承
2、修飾方法：不允許被重寫
3、修飾屬性：則該屬性不會進行隱式初始化（不會自動初始化），需要手動初始化或者在構造方法中初始化 （但二者只能選一，即只能初始化一次后便不能更改）
4、修飾變量，只能在聲明的時候賦一次值，成為常量。 （static final 會使其成為全局常量）

super關鍵字指的是父類

子類的構造的過程當中必須調用其父類的構造方法 相當于super();默認是調用無參的
如果子類的構造方法中沒有顯示調用父類的構造方法,系統會默認調用父類無參的構造方法.
如果要顯示的調用父類的構造方法,必須在子類的構造方法第一行中添加super();
如果子類構造方法中既沒有顯示調用父類的構造方法,而父類又沒有無參的構造方法,則編譯出錯,如果父類是定義了有參的構造方法,那么子類必須super.(父類的參數),或者父類中添加一個無參的構造方法,否則出錯 因為默認調用的是super();是無參的。

一個類中沒有定義構造方法,則系統會默認為此類定義一個無參的構造方法.如果自定義了一個帶參的構造方法,則系統不會為其添加無參的構造方法.

Object類是所有類的父類,如果一個類沒有使用extends關鍵字明確標識繼承另外一個類,那么這個類默認繼承Object類,且Object類中的方法適合所有子類

1.toString()方法
在Object類里面定義toString()方法的時候返回的對象的哈希code碼(對象地址字符串)
如果我們在代碼里面直接輸出一個對象,會輸出這個對象在內存中的地址,我們把它稱為哈希碼,哈希碼是通過哈希算法生成的一個字符串用來唯一區分對象的

可以通過重寫toString()方法表示出對象的屬性

(我們經常在輸出對象的時候希望得到子類的屬性值,那么我們就要重寫從父類繼承來的toString()方法,eclipse中右鍵菜單欄-源碼source-生成generate toString(),他就會根據我們對象的屬性幫我們生成一個toString()方法來輸出屬性值)

getClass()可以得到一個類對象,當我們new的時候得到的是一個類的對象如果對象調用getClass()方法我們得到的是類對象,類對象描述的是類的代碼信息(類的代碼信息:這個類有哪些屬性\它是什么類型\變量名是什么\它有哪些方法\方法名是什么\方法里面的代碼是什么;而類的對象關注的是對象的屬性值的信息或者說這個對象的數據信息)

equals（）----返回值是布爾類型

比較的是對象的引用是否指向同一塊內存地址-------對象實例化時，即給對象分配內存空間
使用方法如：dog.equals(dog2);
如果是兩個對象，但想判斷兩個對象的屬性是否相同，則重寫equals（）方法
1.地址是否相同----if (this == obj)
2.對象是否為空----if (obj == null)
3.getClass（）可以得到類對象，判斷類型是否一樣-----if (getClass() != obj.getClass())
new出來的是類的對象，關注的是類的屬性的具體的數據；
類對象是類的代碼信息，關注的是類有什么屬性和方法
4.屬性值是否一樣----if (age != other.age)

多態： 指的是對象的多種形態

主要分為 引用多態 、方法多態
繼承是多態的實現基礎，別忘了子父類要有繼承關系.
多態特性：
一、引用多態
1.父類引用可以指向本類對象 Animal obj1 = new Animal();
2.父類引用可以指向子類對象 Animal obj2 = new Dog();
但是我們不能用子類的引用指向父類對象 Dog obj3 = new Animal();//錯

二、方法多態
1.在父類Animal中定義一個eat()方法，輸出一個語句(動物有吃的能力); 在子類Dog中重寫eat()方法，輸出一個語句（狗是吃肉的）; 那么我們在測試類main函數里面，如果obj1.eat() ，那么調用的是父類的方法. 若用obj2調用eat()方法，那么調用的是子類的方法.
2.還有一種情況，比如創建一個繼承父類Animal的子類Cat ，但是Cat里并不重寫繼承的eat()方法. 然后，我們在測試類main函數里創建一個子類對象, Animal obj3 = new Cat(); 然后調用 obj3.eat(); 那么，結果調用的則是子類繼承父類的方法. (輸出結果：動物有吃的能力)
3.最后一種特殊情況，多態的特性是不能使用的. 若在子類添加一個獨有的方法 public void watchDoor() ，含有一句輸出語句(狗具有看門的能力); 那么我們在測試類的main函數當中(得先定義好對象Animal obj2 = new Dog() )，就不能用obj2.watchDoor()，即不能通過父類的引用調用子類的方法.

類型轉換

Dog dog = new Dog()

//等號左邊代表:子類 的 引用，即子類Dog的引用dog
//等號右邊代表:創建一個子類Dog的對象
//綜合表示：用一個子類(Dog)的引用(dog)來指向所創建的子類對象，可以把dog看成對象

Paste_Image.png
抽象類定義

1、語法定義：
抽象類錢使用abstract關鍵字修飾，則該類為抽象類。
2、應用場景：
a、在某些情況下，某個父類只是知道其子類應該包含怎樣的方法，但無法準確知道這些子類如何實現這些方法
b、從多個具有相同特征的類中抽象出一個抽象類，以這個抽象類作為子類的模板，從而避免了子類設計的隨意性。
3、作用：
限制規定子類必須實現某些方法，但不關注實現細節。
4、使用規則：
a、abstract定義抽象類
b、abstract定義抽象方法，只有聲明，不需要實現
c、包含抽象方法的類是抽象類
d、抽象類中可以包含普通的方法，也可以沒

Paste_Image.png
接口=全局常量+公共的抽象方法；

接口定義了某一批類所需要遵守的規范，接口不關心這些類的內部數據，也不關心這些類里方法的實現細節，它只規定這些類里必須提供某些方法。

2.接口用interface定義，語法：
[修飾符] interface abstract 接口名 [extends 父接口1，父接口2……]
{//中括號中為可選項
零個到多個常量定義……
零個到多個抽象方法的定義
}

3.接口就是用來被繼承、被實現的，修飾符一般建議用public，不能使用private和protected修飾接口。

4.接口中的屬性是常量（public static final修飾），系統會自動加上

5.接口中的方法只能是抽象方法（public abstract修飾），系統會自動加上

6.使用接口：一個類可以實現一個或多和接口，實現接口使用implements關鍵字。java中一個類只能繼承一個父類，可以通過實現多個接口作補充

7.繼承父類實現接口的語法：
[修飾符] class 類名 extends 父類 implements 接口1，接口2……{
類體部分}//如果繼承的是抽象類，需要實現繼承的抽象方法；要實現接口中的抽象方法
如果要繼承父類，繼承父類必須在實現接口之前
接口命名時首字母為I，以區分類名。可通過add繼承父接口

8.實現時可以利用接口的引用指向實現了接口的對象，調用其方法，如 ：
IPlay ip1=new Psp();ip1.playGame();

9.接口的使用還經常與匿名內部類配合（匿名內部類就是沒有名字的內部類，多用于關注實現而不關注實現類的名稱）
語法格式：
Interface i=new Interface(){
public void method(){
System.out.print("匿名內部類實現接口的方式……");}}
//即通過創建接口的對象，直接寫出實現的方法，再調用此方法
還可以直接創建并調用方法，如：
new IPlay(){
public void playGame(){
System.out.println("……");}}.playGame();

UML的基本概念，POWER DESIGNER的使用方法。

UML：
1、概念：Unified Modeling Language(UML)統一建模語言或標準建模語言
2、三種常用的UML圖：
·用例圖（The Use Case Diagram）：關注功能，描述系統中出現的角色，以及它所需要的功能。
·序列圖（The Sequence Diagram）：關注順序，描述用戶和系統中對象的交互環節：步驟和順序
·類圖（The Class Diagram）：關注關系：描述類和類之間的關系（繼承等），表現類的屬性和方法
3.UML建模工具：如Visio、Rational Rose、PowerDesiner

遍歷數組四種方法：
1：  
Iterator iterator = list.iterator();
 while (iterator.hasNext()) {
}
2：
for (Iterator iter = list.iterator(); iter.hasNext();){
}
3：
for (Object obj : list) {
}
4：
for (int i = 0; i < list.size(); i++) {
}

1、創建兩個接口（載客接口A-載客量）、（載貨接口B-載貨量），載客和貨接口C extend 載客接口A，載貨接口B（載客量、載貨量），一個抽象父類Car（車型、單價-->元/天）；

2、實現-卡車類 extend 父類Car implement 載貨接口B；

 實現-客車類 extend 父類Car implement 載客接口A；

 實現-皮卡類 extend 父類Car implement 載客和貨接口C；

3、租車系統類：一維數組 實例化 卡車對象、客車對象 和 皮卡對象；

4、客戶選車、分類匯總車輛后，輸出租車明細與總價。

最后編輯于 ：
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

推薦閱讀更多精彩內容

  • 1 面向對象No6 面向對象 OO Object Oriented 編程時以對象為單元，封裝數據和邏輯，以此提...
    征程_Journey閱讀 1,194評論 0贊 2
  • 面向對象主要針對面向過程。 面向過程的基本單元是函數。 什么是對象：EVERYTHING IS OBJECT（萬物...
    sinpi閱讀 1,096評論 0贊 4
  • 1. Java基礎部分 基礎部分的順序：基本語法，類相關的語法，內部類的語法，繼承相關的語法，異常的語法，線程的語...
    子非魚_t_閱讀 31,769評論 18贊 399
  • 1.import static是Java 5增加的功能,就是將Import類中的靜態方法，可以作為本類的靜態方法來...
    XLsn0w閱讀 1,267評論 0贊 2
  • 今天換一種方式讀書，打開PPT電子版繪本，兄弟倆在翻看著自己喜歡的書，用自動播放滾動著讀了一本又一本，15分...
    秋惠閱讀 1,044評論 0贊 0