老羅課堂筆記：

面向物件概念：
1、在java語言中，把所有的一切事物都看作物件 ，一種是可見的，莫得著。一種是虛擬的物體
2、面向過程程式設計和麵向物件程式設計的區別是什麼？
   面向過程程式設計主要是描述一件事或者一個過程的執行
   面向物件程式設計主要是用語言描述將現實世界中存在的事物，或者規律。無限接近機器識別的語言。

3、物件：在java中所有的物件都是Object
   物件包含哪些屬性和特徵？物件的屬性，屬性是區別於其他事物的特徵。
   物件的行為特徵，所有的物件都有自己的屬性和行為，兩者加起來是區別於其他事物的標準。
4、在java用什麼來描述一個類？
   類和物件的關係 Class和Object的關係
   類的概念：類是所有物件的抽象概念或者集合(物以類聚)，物件稱為類的具體例項。
   類是抽象的，物件是具體
5、物件例項化 new 關鍵字 例項化物件或者創造一個物件
   物件和物件引用的關係  電視機和遙控器的關係，拿到了遙控器就可以控制電視機
   Person person = new Person();
   person 表示物件引用
   在new一個物件的過程中，計算機做了什麼？
   在記憶體中申請一片獨立的空間，表示可以使用獨立的空間來執行程式.
6、面向物件的三大特性：
   封裝：

隱藏內部實現的細節，對外提供公共的訪問方法(介面)
   好處：從程式碼設計者的角度，一個是安全性，防止程式碼被修改破壞。從呼叫者角度，忽略實現細節，只關注功能怎麼呼叫。
   如何設計封裝：成員變數儘量私有化(private)，對外提供公有的方法
   繼承:
   多型
7、package 包的概念引入：
   對所有的class進行分類，以方便管理。包命名的規則：小寫字母，一般都是四級目錄
   com.公司名.專案名.模組名稱
   如何編譯包：
   javac -d . 類名.java
   javac -d . *.java
   如何執行：
   java 全路徑(包名/../../類名)
   cd 到指定的目錄去執行java 命令

8、構造方法：什麼是構造方法？構造方法是一個類在初始化的形態，類本身自帶特徵。
   jvm在構建一個類的時候，會構建一個預設的構造方法。
   javap 全類路徑  XX
   構造方法的特點：
   公有的、和類名相同、沒有返回值
   構造方法的用處在哪裡？
   初始化成員變數。
   構造方法越多，代表在這個類初始化的時候，形態越多,功能約強大。
   構造方法的過載概念(overload)
   構造方法的過載，引數型別不同，引數個數不同，引數次序不同 都能構成過載。僅僅限於本類。

9、類的成員方法：
   方法的概念：方法是一個類接收外部資訊的其中的渠道。
   方法在一個類中專門解決業務邏輯的。

   public  返回值 方法名(引數列表){

      // return 返回值;
   }
10、方法引數的傳遞：傳值或者傳遞引用
    方法的引數傳遞只能傳遞兩種型別：
    如果要是傳值，就是一個具體的值
    如果要傳遞引用，那麼傳遞的該物件的地址
11、static 用來修飾靜態的方法、靜態的程式碼模組、靜態變數
    如果使用static所修飾的方法或者變數，可以使用類名直接呼叫，
    不需要new物件來呼叫.
    static 修飾的變數在記憶體中只有唯一的一個地址，
    使用場景：只有在工具類中才可以使用，該方法被頻繁的呼叫，確實節省記憶體空間
12、類的繼承 extends
    類與類的關係有哪些？
    第一種是關聯(has-a)關係(聚合)、第二種是繼承(is-a)關係
    如果是關聯關係，那麼就是類呼叫類的關係。
    所有的物件都是繼承Object類，java是單根繼承的特點
    單根繼承的好處是什麼？不好的地方？
    子類可以呼叫父類的方法，減少程式碼的冗餘度。
    在父類的角度考慮問題，繼承可以延伸父類的功能(擴大功能)
    如果子類繼承父類，子類可以呼叫父類的公有方法，不能呼叫父類的私有方法
    子類呼叫父類的時候，父類的構造方法會被呼叫
    super關鍵字只能存在子類中，主要在子類的方法中呼叫父類的方法，包括構造方法，一般寫在程式的第一行
    super可以在子類的構造方法中呼叫父類的構造方法super();
    重寫(override)子類覆蓋父類的同名方法，好處在於擴充子類的方法功能。
    里氏替換原則，如果B類和C類有相同的屬性和方法，就應該把相同的屬性和方法提取到A類中，讓B類和C類繼承A類
13、final關鍵字
    表示最終的。如果用final 所修飾的變數，稱為常量(不能被改變或者賦值)。
    如果final修飾一個方法，那麼該方法在子類中不能被重寫。
    如果final 修飾一個類，那麼這個類不能被繼承。
14、抽象類 abstract 關鍵字
    public abstract class 類名{

    }
    抽象類和普通類的區別是什麼？
    抽象類是不能被例項化的，也就是不能使用new 關鍵字，普通類是可以例項化的
    如果一個類有抽象方法，那麼這個類必然是抽象類，反之抽象類不一定有抽象方法。
    定義一個抽象類的用途在哪裡？
    抽象的概念是不需要實際去做的，但是在實際應用中有兩種場景用途：
    1、父類某一個功能或者方法，需要子類強行去重寫的，那麼該方法必須是抽象的，這個類必須是抽象類。
    2、父類對於某一個方法，無法預知子類會怎麼實現，那麼該方法必須是抽象的。
    抽象類在繼承的關係圖中起到什麼作用？
    承上啟下的作用
15、介面 interface
    介面的概念：
    介面是一種標準，所有實現該介面的子類都要實現這個標準。
    介面也是一種契約，所有實現該介面的子類都要實現該契約的條款
    介面也是一種身份特徵，所有的子類都具有該身份特徵。
    接口裡面的所有方法都是抽象的、公有的
    接口裡所有的成員變數都是常量
    介面可以繼承嗎？介面是可以繼承介面的。
16、多型
    什麼是多型？一個事物在不同的條件下，所表現的多種形態。
    在開發中使用多型的場景，主要是使用在方法的引數傳遞上，可以傳遞介面、也可以傳遞抽象類
17、異常 Exception
    異常是一個物件
    異常就是錯誤，是在程式編譯階段或者執行過程中的錯誤。
    學習異常主要是除錯程式的錯誤資訊，根據錯誤資訊來發現程式的bug
    異常的分類：執行時態異常和編譯時異常
    異常的級別：Error和Exception
    Error：表示不可抗阻因素造成的。
    Exception：表示程式執行錯誤，是可以除錯的。
    捕獲異常的語法
    try{
       //假設程式碼執行正常......
    }catch(異常型別){
      //程式出錯了，要做什麼，比如列印輸出錯誤資訊
    }finally{
      //不管程式是否出錯，都執行
    }
    異常的型別必須是明確的，這樣才能準確的找出錯誤。
    throws 和 throw 的區別 宣告異常和 丟擲異常
    自定義異常資訊：標準的異常中無法描述錯誤資訊，我們需要自己定義一個異常資訊。
    什麼時候捕獲異常？什麼時候丟擲異常？
    如果我們呼叫的是標準的API文件的方法，如果該類或者方法丟擲異常，我們必須要捕獲
    在實際開發中，我們所編寫的程式的功能執行成功與否，與外界有緊密關係(比如，引數傳遞、呼叫關係)
    必須要丟擲異常。
 

吳波老師筆記：

繼承： 

1 減少重複程式碼

2 在已有的類上進行功能的擴充

繼承的限制：

1：只能存在單繼承  （不能多重繼承） 例如 class A extends b,c {} ×  可以多層繼承  b extends a   

C extends b  

2 構造方法 ： 子類是例項化的時候 首先先執行父類的構造方法 為什麼？ 繼承父類的屬性 

3 方法上： 方法的覆寫  方法名稱 引數型別 返回值型別 和父類的方法完全一致  子類的訪問修飾符 不能比父類更嚴格

例如： void fun();   子類  public void fun(); 

方法的過載 和方法的覆寫 由什麼區別？

方法的過載： 方法名稱相同 引數的型別與個數不同 與返回值無關 

多型： 

物件的多型：向上轉型  和向下轉型

方法的多型： 方法的過載 方法的覆寫

物件的多型：

物件的多型 一定是在繼承關係中，實現了方法的覆寫：

在開發中 向上轉型使用 90%

不轉型 5 %

向下轉型5 %

對於向下轉型是存在危險係數的，在多型上存在限制：

1 在向下轉型之前，必須向上轉型 兩個類必須存在關係 才能向下轉型

可以通過  關鍵字 instanceof 來判斷兩個類是否存在關係, 該關鍵字的語法格式如下：

物件  instacneof  類    boolean   true    false 

範例：物件的向上和向下轉型

public static void main(String[] args) { //向上轉型 A a=new B();   //A類  例項化 子類物件   呼叫的方法 依然是子類的物件 new 子類  父類的方法被子類覆寫 呼叫的一定是子類的方法 if(a instanceof B) { B b=(B)a;  //向下轉型 b.fly(); }

需求： 

定義一個方法 可以接收 A類 的任意子類物件  30000個子類

Public  void fun(B b);

Public void fun (C c)

多型：

物件的向上和向下轉型：

向上轉型:統一標準  A 父類   c  d e  f子類 都可以按照父類的標準 執行

向下轉型的意義： 使用子類獨有的方法

                            輸出位元組  父類   輸出

輸出                                       輸出                   輸出

  A  File輸出的內容變為檔案               B  輸出內容到記憶體           C  物件   

向下轉型： 實現自己獨有的方法

靜態只能訪問靜態，靜態成員和方法都是屬於類的。

1.需求：貴婦從寵物店購買了寵物狗、寵物貓，某天，家裡舉行聚會，向朋友介紹起自家豢養的寵物的情形。

分析：

  類：

    貴婦類：

        特徵：名字

        行為：購買寵物狗  

                購買寵物貓 

               舉行聚會

               介紹寵物狗 

               介紹寵物貓

         main:1, xxxx

    寵物狗類：

         特徵：名字

                   性別

                   年齡

                    品種

           行為：看家 

                 吃骨頭

   寵物貓類：

         特徵：名字

                   性別

                   年齡

                    品種

           行為：抓老鼠 

                  吃魚

題目就不看了，特別簡單的初級，主要是這個程式中有物件做引數的用法，記錄一下。

可用繼承減少程式碼累贅，以下是沒有優化的。

package com.judy.demo;

public class HelloWorld {
    public static void main(String[] args) {
        Ladys ladys = new Ladys("judy");
        ladys.buyCat();
        ladys.buyDog();
        ladys.party();
        Cat cat = new Cat("jerry", 'g', 2, "bule cat");
        Dog dog = new Dog("tom", 'b', 1, "jingmao");
        ladys.introduceCat(cat);
        ladys.introduceDog(dog);
    }
}

class Ladys {
    private String name;

    Ladys(String name) {
        this.name = name;
    }

    public void buyDog() {
        System.out.println(name + ",buy buddy dog");
    }

    public void buyCat() {
        System.out.println(name + ",buy buddy cat");
    }

    public void party() {
        System.out.println("holding party");

    }

    public void introduceDog(Dog dog) {
        System.out.print("introducing dog:" + dog.name + ",he like" + " ");
        dog.eatBone();
    }

    public void introduceCat(Cat cat) {
        System.out.print("introducing cat:this is," + cat.name + "," + cat.kind + ",she like" + " ");
        cat.eatFish();
    }
}


class Dog {
    protected String name;
    protected char sex;
    protected int age;
    protected String kind;

    Dog(String name, char sex, int age, String kind) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.kind = kind;
    }

    public void look() {
        System.out.println("look at home");
    }

    public void eatBone() {
        System.out.println("eating bone");
    }
}


class Cat {
    protected String name;
    protected char sex;
    protected int age;
    protected String kind;

    Cat(String name, char sex, int age, String kind) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.kind = kind;
    }

    public void zhua() {
        System.out.println("zhua mouse");
    }

    public void eatFish() {
        System.out.println("eating fish");

    }

}