面向切面編程易混淆

package day01;
//引用類型畫等號與null的演示
public class RefNullDemo {
    public static void main(String[] args) {
        Cell c = new Cell();
        Cell cc = c; //指向同一個對象
        c.row = 2;
        cc.row = 5;
        System.out.println(c.row); //5
        
        int a = 5;
        int b = a; //賦值
        b = 8;
        System.out.println(a); //5
        
        Cell c1 = new Cell();
        c1.row = 2;
        c1 = null; //空，沒有指向任何對象
        c1.row = 2; //NullPointerException空指針異常
    }
}

答案：

5
5
Exception in thread "main" java.lang.NullPointerException
    at day01.RefNullDemo.main(RefNullDemo.java:19)

1.方法的簽名:方法名+參數列表
2.方法的重載(Overload):
  1)發生在一個類中，方法名稱相同，參數列表不一樣
  2)編譯器在編譯時會自動根據簽名來綁定調用不一樣的方法
3.構造方法:構造函數、構造器、構建器
  1)經常用於給成員變量賦初值
  2)與類同名，沒有返回值類型
  3)在建立對象時被自動調用
  4)若本身不寫構造，則編譯器默認提供一個無參構造
    若本身寫了構造，則再也不默認提供
  5)構造方法能夠重載
4.this:指代當前對象，哪一個對象調指的就是哪一個對象
       只能用在方法中，方法中訪問成員變量以前默認有個this.
  this的用法:
    1)this.成員變量名------------訪問成員變量
    2)this.方法名()--------------調用方法
    3)this()---------------------調用構造方法
5.引用類型數組:
  1)Cell[] cells = new Cell[4];
    cells[0] = new Cell(2,5);
    cells[1] = new Cell(2,6);
    cells[2] = new Cell(2,7);
    cells[3] = new Cell(3,6);
  2)Cell[] cells = new Cell[]{
      new Cell(2,5),
      new Cell(2,6),
      new Cell(2,7),
      new Cell(3,6)
    };
  3)int[][] arr = new int[3][];
    arr[0] = new int[2];
    arr[1] = new int[3];
    arr[2] = new int[2];
    //給arr中第2個元素中的第1個元素賦值爲100
    arr[1][0] = 100;
  4)int[][] arr = new int[3][4]; //3行4列
    for(int i=0;i<arr.length;i++){
      for(int j=0;j<arr[i].length;j++){
        arr[i][j] = 100;
      }
    }

 

int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[2];
給arr中第2個元素中的第1個元素賦值爲100
arr[1][0] = 100;

arr----------------int[][]
arr[0]-------------int[]
arr[0][0]----------int

 

 

 

 

arr包含3個元素
arr中的第1個元素又包含2個元素
arr中的第2個元素又包含3個元素
arr中的第3個元素又包含2個元素

//聲明int型數組arr，包含3個元素
//每一個元素都是int型，默認值爲0
int   [] arr   = new int[3];

//聲明Cell型數組cells，包含4個元素
//每一個元素都是Cell型，默認值爲null
Cell  [] cells = new Cell[4];

//聲明int[]型數組arr，包含3個元素
//每一個元素都是int[]型，默認值爲null
int[] [] arr   = new int[3][];

1.內存管理:由JVM來管理
  1)堆:
    1.1)存儲全部new出來的對象(包括成員變量)
    1.2)沒有任何引用指向的對象就是垃圾，
        垃圾回收器(GC)不定時到內存中清掃垃圾，
        回收過程是透明的(看不到的)，並不必定發現垃圾就立刻回收，
        調用System.gc()建議虛擬機儘快調度gc來回收垃圾
    1.3)內存泄漏:再也不使用的內存沒有被及時的回收
                 建議:對象再也不使用時及時將引用設置爲null
    1.4)成員變量的生命週期:
          建立對象時存在堆中，對象被垃圾回收器回收時一併消失
  2)棧:
    2.1)存儲正在調用的方法中的全部局部變量(包括參數)
    2.2)調用方法時會爲該方法在棧中分配一塊對應的棧幀，
        棧幀中包含方法中的全部局部變量(包括參數)，
        方法調用結束時，棧幀被消除，局部變量隨之消失
    2.3)局部變量的生命週期:
          調用方法時存在棧中，方法結束棧幀被清除時一併消失
  3)方法區:
    3.1)存儲.class字節碼文件(包括方法)
    3.2)方法只有一份，經過this來區分具體的對象
2.繼承:
  1)做用:代碼的複用
  2)經過extends來實現繼承
  3)父類/基類:全部子類所共有的屬性和行爲
    子類/派生類:子類所特有的屬性的行爲
  4)子類繼承父類後，子類具備: 子類的+父類的
  5)一個父類能夠有多個子類，
    一個子類只能繼承一個父類-----單一繼承
  6)繼承具備傳遞性
  7)java規定:構造子類以前必須先構造父類
    子類構造方法中若沒有調用父類的構造方法，
    則默認super()調父類的無參構造，
    若子類構造方法中調用了父類的構造方法，則再也不默認提供
    super()調父類構造必須位於子類構造方法的第一句
3.super:指代當前對象的父類對象
  super的用法:
   1)super.成員變量名----------訪問父類的成員變量
   2)super.方法名()------------調用父類的方法
   3)super()-------------------調用父類的構造方法
4.向上造型:
  1)父類型的引用指向子類的對象
  2)能點出來什麼，看引用的類型

1)繼承要符合is a的關係
2)問:子類能夠繼承父類的構造方法嗎?
  答:不能，由於父類的構造方法是被子類調用的

1.方法的重寫(Overrid):
  1)發生在父子類中，方法名相同，參數列表相同，方法體不一樣
  2)重寫方法被調用時，看對象的類型
2.重寫與重載的區別:常見面試題
  1)重寫(Override):
    1.1)發生在父子類中，方法名相同，參數列表相同，方法體不一樣
    1.2)遵循"運行期"綁定，根據對象的類型來調用方法
  2)重載(Overload):
    2.1)發生在一個類中，方法名相同，參數列表不一樣，方法體不一樣
    2.2)遵循"編譯期"綁定，根據引用的類型來綁定方法

5.static:靜態的
  1)靜態變量:
    1.1)由static修飾
    1.2)屬於類的，存在方法區中，只有一份
    1.3)經常經過類名點來訪問
    1.4)什麼時候用:全部對象共享的數據(圖片、音頻、視頻...)
  2)靜態方法:
    2.1)由static修飾
    2.2)屬於類的，存在方法區中，只有一份
    2.3)經常經過類名點來訪問
    2.4)靜態方法沒有隱式的this傳遞，
        因此在靜態方法中不能直接訪問實例成員
    2.5)什麼時候用:方法的操做僅與參數相關而與對象無關 ？？？？
  3)靜態塊:
    3.1)由static修飾
    3.2)屬於類的，在類被加載期間自動執行，
        因類只被加載一次，因此靜態塊也只執行一次
    3.3)什麼時候用:經常用於初始化靜態資源(圖片、音頻、視頻等)

封裝
1.保護數據---------私有數據
2.保護程序的邏輯---公開方法
數據私有化，行爲公開化

package oo.day04;
//重寫與重載的演示
public class OverrideOverloadDemo {
    public static void main(String[] args) {
        Goo goo = new Goo();
        Eoo o = new Foo(); //向上造型
        goo.test(o); //重載看引用
    }
}

class Goo{
    void test(Eoo o){
        System.out.println("父型參數");
        o.show(); //重寫看對象
    }
    void test(Foo o){
        System.out.println("子型參數");
        o.show();
    }
}

class Eoo{
    void show(){
        System.out.println("父類show");
    }
}
class Foo extends Eoo{
    void show(){
        System.out.println("子類show");
    }
}
答案：

父型參數
子類show
 

package oo.day04;
//static的演示
public class StaticDemo {
    public static void main(String[] args) {
        Loo o1 = new Loo();
        o1.show();
        Loo o2 = new Loo();
        o2.show();
        System.out.println(Loo.b); //2，建議經過類名來訪問
        System.out.println(o1.b);  //2，不建議對象來訪問
        
        Moo.test();
        
        Noo o3 = new Noo();
        Noo o4 = new Noo();
        
    }
}

class Noo{ //演示靜態塊
    Noo(){
        System.out.println("構造方法");
    }
    static{
        System.out.println("靜態塊");
    }
}

class Moo{ //演示靜態方法
    int a;
    static int b;
    void show(){
        System.out.println(a);
        System.out.println(b);
    }
    static void test(){
        //編譯錯誤，靜態方法沒有隱式this，
        //沒有this意味着沒有對象，
        //而a必須得經過對象來訪問，
        //System.out.println(a);
        System.out.println(b);
    }
}

class Loo{ //演示靜態變量
    int a;
    static int b;
    Loo(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a="+a);
        System.out.println("b="+b);
    }
}

答案：

a=1
b=1
a=1
b=2
2
2
0
靜態塊
構造方法
構造方法

 

1.static final常量:
  1)必須聲明同時初始化
  2)經過類名點訪問，不能被改變
  3)建議:常量名全部字母都大寫，多個單詞之間用_鏈接
  4)編譯器在編譯時會將常量自動替換爲具體的值，效率高
2.抽象方法:
  1)由abstract修飾
  2)只有方法的定義，沒有方法的具體實現(連大括號都沒有)
3.抽象類:
  1)由abstract修飾
  2)包含抽象方法的類必須是抽象類
    不包含抽象方法的類也能夠聲明爲抽象類----我樂意
  3)抽象類不能被實例化
  4)抽象類都是須要被繼承的，子類:
    4.1)重寫抽象類中的全部抽象方法----建議
    4.2)也聲明爲抽象類----------------不建議
  5)抽象類的意義:
    5.1)封裝子類共有的屬性和行爲，實現代碼複用
    5.2)爲全部子類提供了一種統一的類型--向上造型
    5.3)能夠包含抽象方法，爲全部子類提供了一個統一的入口，
        子類能夠有不一樣的實現，但方法的定義是一致的
4.接口:
  1)是一個標準、規範------制定方
    遵照了這個標準就能幹某件事------------API以後
  2)是一個數據類型(引用類型)
  3)是由interface定義的
  4)只能包含常量和抽象方法
  5)接口不能被實例化
  6)接口是須要被實現的，實現類(遵照方):
      必須重寫接口中的全部抽象方法
  7)一個類能夠實現多個接口，用逗號隔開
    若又繼承又實現時，應先繼承後實現
  8)接口能夠繼承接口
1.多態:
  1)多態的意義:
    1.1)同一類型的引用指向不一樣的對象時，有不一樣的實現
        --------行爲的多態: cut()、run()、study()
    1.2)同一個對象被造型爲不一樣的類型時，有不一樣的功能
        --------對象的多態: 我、水、你
  2)向上造型:
    2.1)父類型的引用指向子類的對象
    2.2)能造型爲的類型有: 父類+所實現的接口
    2.3)能點出來什麼，看引用的類型
  3)強制類型轉換，能成功的條件只有兩種:
    3.1)引用所指向的對象，就是該類型
    3.2)引用所指向的對象，實現了該接口
  4)強轉時若不符合如上兩個條件，則發生ClassCastExcetion類型轉換異常，
    因此建議在強轉以前先經過instanceof來判斷引用指向的對象是不是該類型
2.成員內部類: 單獨應用的概率很少
  1)類中套類，外面的稱爲外部類，裏面的稱爲內部類
  2)內部類一般只服務於外部類，對外不具有可見性
  3)內部類對象一般是在外部類中建立
  4)內部類中能夠直接訪問外部類的成員(包括私有的)
    內部類中有個隱式的引用指向了建立它的外部類對象
      eg:外部類名.this
3.匿名內部類:
  1)若想建立一個類(子類)的對象，而且對象只被建立一個，
    此時該類沒必要命名，稱之爲匿名內部類
  2)匿名內部類中訪問外部的變量，該變量必須是final的

4.面向對象的三大特徵:   1)封裝:     1.1)類:封裝的是對象的屬性和行爲     1.2)方法:封裝的是具體的業務邏輯功能實現     1.3)訪問控制修飾符:封裝的是具體的訪問權限   2)繼承:     2.1)做用:代碼的複用     2.2)父類/基類:全部子類所共有的屬性和行爲         子類/派生類:子類所特有的屬性和行爲     2.3)子類繼承父類後，子類具備:父+子     2.4)單一繼承、傳遞性   3)多態:     3.1)意義、向上造型、強制類型轉換、instanceof     3.2)多態的表現形式:         3.2.1)重寫         3.2.2)重載