目錄

包

1.靜態匯入

2.將類放到包中

3.包的訪問權限控制

繼承

基本語法:

注意事項:

protected 關鍵字

final 關鍵字

組合

多型

向上轉型:

動態系結

方法重寫

重寫的規則 :

注意事項 :

多載和重寫的區別:

向下轉型

super 關鍵字

1.使用了 super 來呼叫父類的構造器

2.使用 super 來呼叫父類的普通方法

super和this的區別

理解多型:

抽象類

語法規則

注意事項:

1.包含抽象方法的類,叫做抽象類.

2.什么是抽象方法,一個沒有具體實作的方法,被abstract修飾.

3.抽象類是不可以被實體化的.

4.因為不能被實體化,所以,這個抽象類,其實只能被繼承.

5.抽象類當中,也可以包含和普通類一樣的成員方法.

6.一個普通類,繼承了一個抽象類,那么這個普通類當中,需要重寫這個抽象類的所有的抽象方法.

7.抽象類最大的作用,就是為了被繼承.

8.一個抽象類A,如果繼承了一個抽象類B,那么這個抽象類A,可以不實作抽象父類B的抽象方法.

9.結合第八點,當A類再次被一個普通類繼承后,那么A和B這兩個抽象類當中的抽象方法,必須被重寫.

10.抽象類 不能被final修飾,抽象方法也不可以被final修飾.

介面

語法規則:

注意事項:

1.使用interface來修飾的.interface IA{}

2.介面當中的方法,不能有具體的實作.非要實作,只能通過關鍵字defaut來修飾這個方法.

3.在介面中,可以有static的方法.

4.里面的所有的方法都是public的.

5.抽象方法,默認是public abstract的.

6.介面是不可以通過new來實體化的

7.類和介面之間的關系是通過implements來實作的

8.當一個類實作了一個介面,就必須要重寫介面當中的抽象方法.

9.介面當中的成員變數,默認是public staitc final修飾的

10.當一個類實作一個介面之后,重寫這個方法的時候,這個方法前面必須加public

11.一個類可以通過關鍵字extens繼承一個抽象類或者一個普通類,但是只能繼承一個類,同時,也可以通過implements實作多個介面,介面之間使用 ,(逗號)隔開.

12.介面和介面之間可以使用extends來操作他們的關系,此時這里意為:拓展.

包

import java.util.*其中* 是通配符,需要誰就拿誰

1.靜態匯入

使用import static可以匯入包中的靜態的方法和欄位.(可讀性差 不建議使用)

import static java.lang.System.*;
import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        out.println("hehhee");
        out.println(max(10,20));
    }
}

2.將類放到包中

基本規則:

1. 在檔案的最上方加上一個 package 陳述句指定該代碼在哪個包中.
2. 包名需要盡量指定成唯一的名字, 通常會用公司的域名的顛倒形式(例如 com.bit.demo1 ).
3. 包名要和代碼路徑相匹配.例如創建com.bit.demo1的包, 那么會存在一個對應的路徑com/bit/demo1來存盤代碼.
4. 如果一個類沒有 package 陳述句, 則該類被放到一個默認包中.

3.包的訪問權限控制

我們已經了解了類中的 public 和 private. private 中的成員只能被類的內部使用.

如果某個成員不包含 public 和 private 關鍵字, 此時這個成員可以在包內部的其他類使用, 但是不能在包外部的類使用.

如果你的成員變數前面不加任何訪問修飾符,它就默認為一個包的訪問權限

例如:

package com.bit.demo1;
class Dog{
    String name;
    int age;
}

繼承

封裝:不必要公開的資料成員和方法 使用private關鍵字進行修飾. 意義: 安全性.

繼承:對公共性的抽取.使用extends關鍵字來進行處理的. 意義:可以對代碼重復進行使用.

基本語法:

class  子類  extends  父類{

}
 

class Animal{
    public int age;
    public String name;

    public void eat(){
        System.out.println("吃吃吃");
    }
}

class Dog extends Animal{

}

注意事項:

1. 使用 extends 指定父類.
2. Java 中一個子類 只能 繼承一個父類 (而C++/Python等語言支持多繼承).
3. 子類會繼承父類的所有 public 的欄位和方法.
4. 對于父類的 private 的欄位和方法, 子類中是無法訪問的.
5. 子類的實體中, 也包含著父類的實體. 可以使用 super 關鍵字得到父類實體的參考.
6. 當子類和父類中有重名的情況(成員變數),子類會優先考慮自己的.
7. 子類繼承了父類,那么子類在構造的時候,需要先幫助父類來進行構造.需要在子類的構造方法當中,使用super關鍵字來顯示的呼叫父類的構造方法.

protected 關鍵字

• 對于類的呼叫者來說, protected 修飾的欄位和方法是不能訪問的

• 對于類的子類和同一個包的其他類來說, protected修飾的欄位和方法是可以訪問的

包訪問權限:什么都不寫,只能在同一個包里面訪問

final 關鍵字

如果一個類不想被繼承可以用final修飾

例如:

//被final修飾,類不可以被繼承
final class A{
    final int age = 10;//常量被final修飾 不可以被修改
}
//err
class B extends A{

}
public class Test1 {
    public static void main(String[] args) {
        A a = new A();
        a.age=20;//err
    }
}

final 關鍵字的功能是限制 類被繼承 "限制" 這件事情意味著 "不靈活". 在編程中, 靈活往往不見得是一件好事. 靈活可能意味著更容易出錯. 是用 final 修飾的類被繼承的時候, 就會編譯報錯, 此時就可以提示我們這樣的繼承是有悖這個類設計的初衷的.

我們平時是用的 String 字串類, 就是用 final 修飾的, 不能被繼承.

組合

組合并沒有涉及到特殊的語法(諸如 extends 這樣的關鍵字), 僅僅是將一個類的實體作為另外一個類的欄位. 這是我們設計類的一種常用方式之一.

組合表示 has - a 語意:

在剛才的例子中, 我們可以理解成一個學校中 "包含" 若干學生和教師.

繼承表示 is - a 語意:

在上面的 "動物和貓" 的例子中, 我們可以理解成一只貓也 "是" 一種動物

多型

向上轉型:

一個 父類的參考 參考 子類的物件 這就是 向上轉型

向上轉型發生的時機 :

1. 直接賦值
2. 方法傳參
3. 方法回傳

public class Test {
    //作為方法傳參
    public static void func(Animal animal){

    }
    //作為方法回傳
    public static Animal func2(Animal animal){
        return animal;
    }

    public static void main(String[] args) {
        //直接賦值
        Animal animal = new Dog("dddddoog",200);//父類參考 參考 子類物件

        Dog dog = new Dog("www",20);
        func(dog);
    }
}

動態系結

父類參考 參考子類物件 且 父類和子類 有同名的覆寫方法.通過父類參考呼叫這個同名的覆寫方法.就會發生運行 動態系結.

package com.bit.demo2;
class Animal{
    public String name;
    public void eat(){
        System.out.println(name+"吃吃吃");
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println(name+"L狼吞虎咽");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog("www",20);
        animal.eat(); //運行時是運行Dog子類物件中的eat()
    }
}

如上面代碼,父類參考animal 參考了子類物件 Dog,且有同名的覆寫方法,eat(),當通過父類呼叫這個方法的時候,就會運行 動態系結

方法重寫

針對剛才的 eat 方法來說: 子類實作父類的同名方法, 并且引數的型別和個數完全相同, 這種情況稱為 覆寫/重寫/覆寫(Override).

重寫的規則 :

1. 方法名相同
2. 回傳值型別相同
3. 引數的型別及個數
4. 繼承關系(父子類的情況下)
5. 被重寫的方法不能擁有比父類更嚴格的訪問限制權限

注意事項 :

1. 普通方法可以重寫, static 修飾的靜態方法不能重寫.
2. 子類的訪問修飾符限定,要大于等于父類的訪問修飾限定
3. private方法不能重寫
4. 被final修飾的方法不能重寫
5. 重寫的方法回傳值型別不一定和父類的方法相同(但是建議最好寫成相同, 特殊情況除外).

多載和重寫的區別:

通過父類參考 只能訪問父類自己的成員;

向下轉型

就是 父類物件 轉換成 子類物件

public static void main(String[] args) {
    Animal animal = new Bird("hhe",200,"起飛起飛");
    Bird bird = (Bird) animal;
    bird.fly();
}

super 關鍵字

super 表示獲取到父類實體的參考. 有2種常見方法:

1.使用了 super 來呼叫父類的構造器

class Bird extends Animal {
    public String wing;
    public String name;

    public Bird(String name,int age,String wing){
        super(name,age);
        this.wing = wing;
    }
}

2.使用 super 來呼叫父類的普通方法

class Animal {
    public String name;
    public int age;

    public void eat(){
        System.out.println("吃吃吃吃吃吃");
    }
}
class Bird extends Animal {
    public String name;

    @Override
    public void eat() {
        super.eat();
        System.out.println("小鳥吃吃吃");
    }
}

super和this的區別

理解多型:

通過一個參考呼叫同一個draw方法,因為參考的物件不一樣表現出的形式各不相同

class Shape {
    public void draw(){
        System.out.println("shape::shape");
    }
}

class Rect extends Shape{
    @Override
    public void draw() {
        System.out.println("?");
    }
}

class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("?");
    }
}

public class Test {
    public static void  drawMap(Shape shape){
        shape.draw();
    }

    public static void main(String[] args) {
        Rect ret = new Rect();
        drawMap(ret);
        Flower flower = new Flower();
        drawMap(flower);
    }
}

多型顧名思義, 就是 "一個參考, 能表現出多種不同形態"

一個參考到底是指向父類物件, 還是某個子類物件(可能有多個), 也是要根據背景關系的代 碼來確定.

抽象類

語法規則

在剛才的列印圖形例子中, 我們發現, 父類 Shape 中的 draw 方法好像并沒有什么實際作業, 主要的繪制圖形都是由 Shape 的各種子類的 draw 方法來完成的. 像這種沒有實際作業的方法, 我們可以把它設計成一個 抽象方法(abstract method), 包含抽象方法的類我們稱為 抽象類(abstract class).

abstract class Shape {
    abstract public void draw();
}

注意事項:

1.包含抽象方法的類,叫做抽象類.

//抽象類
abstract class Shape{
    public abstract void draw();//抽象方法
}

2.什么是抽象方法,一個沒有具體實作的方法,被abstract修飾.

3.抽象類是不可以被實體化的.

4.因為不能被實體化,所以,這個抽象類,其實只能被繼承.

5.抽象類當中,也可以包含和普通類一樣的成員方法.

6.一個普通類,繼承了一個抽象類,那么這個普通類當中,需要重寫這個抽象類的所有的抽象方法.

7.抽象類最大的作用,就是為了被繼承.

8.一個抽象類A,如果繼承了一個抽象類B,那么這個抽象類A,可以不實作抽象父類B的抽象方法.

9.結合第八點,當A類再次被一個普通類繼承后,那么A和B這兩個抽象類當中的抽象方法,必須被重寫.

10.抽象類 不能被final修飾,抽象方法也不可以被final修飾.

介面

介面是抽象類的更進一步. 抽象類中還可以包含非抽象方法, 和欄位. 而介面中包含的方法都是抽象方法, 欄位只能包含 靜態常量.

語法規則:

interface IShape{
    void draw();
}
class Cycle implements IShape{
    @Override
    public void draw() { 
        System.out.println("○");
    }
}

注意事項:

1.使用interface來修飾的.interface IA{}

2.介面當中的方法,不能有具體的實作.非要實作,只能通過關鍵字defaut來修飾這個方法.

3.在介面中,可以有static的方法.

4.里面的所有的方法都是public的.

5.抽象方法,默認是public abstract的.

6.介面是不可以通過new來實體化的

7.類和介面之間的關系是通過implements來實作的

8.當一個類實作了一個介面,就必須要重寫介面當中的抽象方法.

9.介面當中的成員變數,默認是public staitc final修飾的

10.當一個類實作一個介面之后,重寫這個方法的時候,這個方法前面必須加public

11.一個類可以通過關鍵字extens繼承一個抽象類或者一個普通類,但是只能繼承一個類,同時,也可以通過implements實作多個介面,介面之間使用 ,(逗號)隔開.

12.介面和介面之間可以使用extends來操作他們的關系,此時這里意為:拓展.

一個介面B 通過 extens來 拓展另一個介面A的功能.此時當一個類C通過implements實作這個介面B的時候,此時重寫的方法不僅僅是B的抽象方法,還有其他從C介面,拓展來的方法(功能).