摘要：面向?qū)ο笾庋b繼承多態(tài)封裝將類中的信息進行隱藏在類的內(nèi)部，不允許外部程序信息直接訪問，而是只能通過該類的提供的方法來實現(xiàn)對隱藏信息的提供和訪問。與之對應(yīng)，包含內(nèi)部類的類被稱為外部類。

將類中的信息進行隱藏在類的內(nèi)部，不允許外部程序信息直接訪問，而是只能通過該類的提供的方法來實現(xiàn)對隱藏信息的提供和訪問。

好處

只能隱藏規(guī)定的方法和數(shù)據(jù)
隱藏類的實現(xiàn)細(xì)節(jié)，方便修改和實現(xiàn)

封裝的實現(xiàn)步驟

1. 用private等修飾符修飾屬性
2. 創(chuàng)建屬性的getter/setter方法
3. 在getter/setter方法中加入屬性的控制語句

java中的訪問修飾符一個有四個，我們主要學(xué)習(xí)private、protected、public三個。

this關(guān)鍵字代表當(dāng)前對象

this.屬性 操作當(dāng)前對象的屬性
this.方法 操作當(dāng)前對象的方法

封裝對象的屬性的時候會經(jīng)常使用this關(guān)鍵字

package com.test.cat; // 定義包

public class Cat {
    int a;
    int b;

    public void send() {
        System.out.print("send");
    }

    public int getA() {
        this.send(); // 調(diào)用方法
        return a;
    }
    public void setA(int a) {
        this.a = a;  // 調(diào)用屬性
    }
    public int getB() {
        return b;
    }
    public void setB(int b) {
        this.b = b;
    }
    public Cat() {
        System.out.println("Cat 實例化了");
    }
}

內(nèi)部類（ Inner Class ）就是定義在另外一個類里面的類。與之對應(yīng)，包含內(nèi)部類的類被稱為外部類。

內(nèi)部類的主要作用

1. 內(nèi)部類提供了更好的封裝，可以把內(nèi)部類隱藏在外部類之內(nèi)，不允許同一個包中的其他類訪問該類
2. 內(nèi)部類的方法可以直接訪問外部類的所有數(shù)據(jù)，包括私有的數(shù)據(jù)
3. 內(nèi)部類所實現(xiàn)的功能使用外部類同樣可以實現(xiàn)，只是有時使用內(nèi)部類更方便

內(nèi)部類的分類

成員內(nèi)部類
靜態(tài)內(nèi)部類
方法內(nèi)部類
匿名內(nèi)部類

先舉個例子

//外部類HelloWorld
public class HelloWorld {
    
    // 內(nèi)部類Inner，類Inner在類HelloWorld的內(nèi)部
    public class Inner {
        
        // 內(nèi)部類的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }
    
    public static void main(String[] args) {
        
        // 創(chuàng)建外部類對象
        HelloWorld hello = new HelloWorld();
        // 創(chuàng)建內(nèi)部類對象
        Inner i = hello.new Inner();
        // 調(diào)用內(nèi)部類對象的方法
        i.show();
    }
}

package innerClass;
 
// 外部類
public class Outer {
    private int out; // 外部類成員
    private int b; // 外部的b
    
    public int getOut() {
        return out;
    }
    public void setOut(int out) {
        this.out = out;
    }
    // 外部類構(gòu)造函數(shù)
    public Outer(int _out) {
        this.out = _out;
        System.out.println("外部類實例化中.....");
        // 外部類則無法訪問內(nèi)部類的數(shù)據(jù)
    }
    
    // 內(nèi)部類
    public class Inner{
        private int in; // 內(nèi)部類成員
        private int b; // 內(nèi)部的b
        
        // 內(nèi)部類構(gòu)造函數(shù)
        public Inner(int _in) {
            this.in = _in;
            System.out.println("內(nèi)部類實例化中....");
            System.out.println(out); // 內(nèi)部類可以訪問外部類中的任何數(shù)據(jù)
            System.out.println(this.b); // 如果遇上重名，那么默認(rèn)是使用內(nèi)部的變量，如果想要使用外部的變量，可以使用this 
        }
    }
    
    public static void main(String [] args) {
        Outer o = new Outer(100);  // 創(chuàng)建一個外部對象
        System.out.println(o.getOut());
        
        Inner i = o.new Inner(200); // 創(chuàng)建一個內(nèi)部對象
    }
}

注意事項

1. Inner 類定義在 Outer 類的內(nèi)部，相當(dāng)于 Outer 類的一個成員變量的位置，Inner 類可以使用任意訪問控制符，如 public 、 protected 、 private 等
2. Inner 類中定義的 test() 方法可以直接訪問 Outer 類中的數(shù)據(jù)，而不受訪問控制符的影響
3. 定義了成員內(nèi)部類后，必須使用外部類對象來創(chuàng)建內(nèi)部類對象，而不能直接去 new 一個內(nèi)部類對象，即：內(nèi)部類 對象名 = 外部類對象.new 內(nèi)部類( );
4. 編譯上面的程序后，會發(fā)現(xiàn)產(chǎn)生了兩個 .class 文件
其中，第二個是外部類的 .class 文件，第一個是內(nèi)部類的 .class 文件，即成員內(nèi)部類的 .class 文件總是這樣：外部類名$內(nèi)部類名.class

外部類是不能直接使用內(nèi)部類的成員和方法滴

如果外部類和內(nèi)部類具有相同的成員變量或方法，內(nèi)部類默認(rèn)訪問自己的成員變量或方法，如果要訪問外部類的成員變量，可以使用 this 關(guān)鍵字。

靜態(tài)內(nèi)部類是 static 修飾的內(nèi)部類

特點

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

package static_inner_class;

public class Outer {
    private int a; // 外部普通成員變量
    static int b = 10; //外部靜態(tài)變量
    
    public Outer(int _a) {
        this.a = _a;
        System.out.println("外部類實例化中....");
    }
    
    
    // 內(nèi)部類
    public static class Inner{
        private int b;
        public Inner(int _b) {
            this.b = _b;
            System.out.println("內(nèi)部類實例化中....");
        }
        
        public void test() {
            System.out.println("訪問外部類中的b：" + Outer.b); 
            // 訪問外部靜態(tài)變量，建議使用class.staticName ，即使這是處理外部類和內(nèi)部類存在同名變量的情況下
            System.out.println("訪問內(nèi)部類中的b：" + b); // 訪問內(nèi)部變量可以直接訪問
        }
    }
    
    public static void main(String [] args) {
        Outer o = new Outer(10);
        Inner i = new Inner(20); // 創(chuàng)建內(nèi)部類可以直接使用該方法，不用先實例化外部類
        i.test();
    }
}

方法內(nèi)部類就是內(nèi)部類定義在外部類的方法中，方法內(nèi)部類只在該方法的內(nèi)部可見，即只在該方法內(nèi)可以使用。

//外部類
public class HelloWorld {
    
    private String name = "愛慕課";
    
    // 外部類中的show方法
    public void show() { 
        // 定義方法內(nèi)部類
        class MInner {
            int score = 83;
            public int getScore() {
                return score + 10;
            }
        }
        
        // 創(chuàng)建方法內(nèi)部類的對象
        MInner mi=new MInner();
        
        // 調(diào)用內(nèi)部類的方法
        int newScore=mi.getScore();
        
        System.out.println("姓名：" + name + "
加分后的成績：" + newScore);
    }
    
    // 測試方法內(nèi)部類
    public static void main(String[] args) {
        
        // 創(chuàng)建外部類的對象
        HelloWorld mo=new HelloWorld();
        
        // 調(diào)用外部類的方法
        mo.show();
    }
}

繼承就是類與類之間的一種 is a的關(guān)系

java中繼承是單繼承的，也就是只能由一個父類

好處

1. 實現(xiàn)代碼的復(fù)用
2. 子類擁有父類的所有屬性和方法
3. 但是private修飾的屬性和方法卻無法訪問到

語法規(guī)則

例子

// Animal.java

package inhert_demo1;

public class Animal {
    public int age;
    public String name;
    public void eat() {
        System.out.println("動物可以吃東西");
    }
}

// Cat.java
package inhert_demo1;

public class Cat extends Animal{
    // 【方法的重寫】
    public void eat() {
        System.out.println("貓咪可以吃東西");
    }
}

// test.java

package inhert_demo1;

public class test {
    public static void main(String [] args) {
        Cat c = new Cat();
        c.eat();
    }
}

如果子類對繼承父類的方法不滿意，是可以重寫父類的方法的，當(dāng)調(diào)用的時候，優(yōu)先調(diào)用子類的方法

// 規(guī)定
1. 返回值相同
2. 參數(shù)類型及個數(shù)相同
3. 方法名相同

1. 先初始化父類，然后再初始化子類
2. 先執(zhí)行初始化對象中的屬性，然后再執(zhí)行構(gòu)造函數(shù)中的初始化

// 執(zhí)行順序為
package inhert_demo1;

public class Animal {
    public int age = 10; //【1】 屬性初始化
    public String name;
    
    public Animal() {
        age = 20; // 【2】構(gòu)造函數(shù)中的初始化
    }
    public void eat() {
        System.out.println("動物可以吃東西");
    }
}

final可以修飾類、屬性、方法、變量

final修飾的類，則該類不能被繼承
final修飾的方法，則方法不允許被覆蓋（也就是方法的重寫）
final修飾的屬性： 屬性初始化必須是在屬性初始化或者構(gòu)造方法中初始化，只能人選其一
final修飾的變量，這個變量就成為了常量，只能賦值一次

super關(guān)鍵字代指父類 （在對象內(nèi)部使用、可以代表父類對象）

// 子類 cat
package inhert_demo1;

public class Cat extends Animal{
    public int age = 20;
    public void eat() {
        System.out.println("貓咪可以吃東西");
    }
    
    public void meyhod () {
        // super代表父類
        System.out.println(super.age); // 使用父類的屬性
        super.eat(); // 子類中調(diào)用父類的方法
    }
}

注意

1. 如果子類中的構(gòu)造方法沒有顯示的調(diào)用父類的構(gòu)造方法，那么系統(tǒng)將默認(rèn)調(diào)用父類的無參構(gòu)造方法

也就是會隱世的調(diào)用`super()`

2. 如果父類沒有無參構(gòu)造方法，而是有有參的構(gòu)造方法，那么子類中就必須顯示的調(diào)用父類的構(gòu)造方法。

Object類是所有類的父類，如果一個類沒有明確的使用extends來指定繼承一個類，那么這個類默認(rèn)繼承Object（Object類中的方法適合子類）

方法一、toString()

Object中的類方法toString()返回的是一個對象的哈希Code碼（對象的地址引用）

// 我們則是想使用該方法來返回屬性的值，因此我們可以重寫該方法

// cat類中
public String toString() {
    return "Cat [age=" + age + "]";
}


//使用

package inhert_demo1;

public class test {
    public static void main(String [] args) {
        Cat c = new Cat();
        System.out.println(c.toString());
    }
}

方法二、equals()

比較對象的引用是否指向同一塊內(nèi)存地址。

Dog d1 = new Dog();
Dog d2 = new Dog();

d1.d2是兩個地址，是不相同的

// 如果我們想要用equals來比較兩個對象的值是否相同，這就需要我們重寫該方法

// cat中重寫

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())// getClass 獲取到的是類對象
            return false;
        Cat other = (Cat) obj;
        if (age != other.age)
            return false;
        return true;
    }

Cat c = new Cat();
System.out.println(c.toString());
Cat c1 = new Cat();
if(c1.equals(c)) {
    System.out.println("兩個對象的屬性相同");
}

補充 getClass 獲取到的是類對象

多態(tài)指的是對象的多種形態(tài)

1. 引用多態(tài)
   父類的引用可以指向子類的對象
   父類的引用可以指向本類的對象
public static void main(String [] args) {
    Animal d1 = new Animal();
    Animal d2 = new Dog();
    Dog d3 = new Animal(); // 報錯了，因為是子類的引用指向了父類的對象
}
2. 方法多態(tài)
    創(chuàng)建本類對象時，調(diào)用的時本類的方法
    創(chuàng)建子類對象時，調(diào)用的方法時子類重寫的方法或者時父類繼承過來的方法
    Animal d1 = new Animal();
    Animal d2 = new Dog();
    d1.eat(); // 調(diào)用父類的eat方法
    d2.eat(); // 調(diào)用子類重寫的eat方法

1. 向上類型轉(zhuǎn)換（隱式/自動類型轉(zhuǎn)換） 小類型 => 大類型
2. 向下類型轉(zhuǎn)換（強制類型轉(zhuǎn)換） 大類型 => 小類型
3. instanceof可以解決引用對象的類型，來避免轉(zhuǎn)換類型的安全性問題

package polymorphic;

public class test {
    public static void main(String [] args) {
        Dog dog = new Dog();
        Animal animal = dog;  // 小類型 => 大類型
//        Dog dog2 = animal;    // 報錯了，因為大類型 => 小類型 存在風(fēng)險
        Dog dog2 = (Dog)animal; // 強制類型轉(zhuǎn)換，就不報錯了
//        Cat cat =(Cat) animal; // 編譯時Cat類型，運行時時Dog類型
        
        if(animal instanceof Dog) {
            
        } else {
            
        }
        
    }
}

使用abstract修飾的類成為抽象類

1. 某一個父類只知道子類應(yīng)該含有怎樣的方法，但是無法確定這個子類的方法如何實現(xiàn)
2. 從多個具有相同特征的類中抽象出一個抽象類，以這個抽線類作為子類的模板，從而避免了子類設(shè)計的隨意性

使用規(guī)則

abstract定義抽象方法，只有聲明、不需要實現(xiàn)
抽象類中可以有普通方法，也可以有抽象方法
抽象類不能直接創(chuàng)建，我們可以定義引用變量

public abstract class telphone {
    // 定義抽象方法
    public abstract void call();
    public abstract void message();
    // 抽象方法沒有方法體，因此以分號結(jié)束
}

實例

// Telphone.java
package abstrated;

public abstract class Telphone {
    // 定義抽象方法
    public abstract void call();
    public abstract void message();
    // 抽象方法沒有方法體，因此以分號結(jié)束
}

// Cellphone.java

package abstrated;

public class Celltelphone extends Telphone {
    public void call() {
        System.out.println("通過鍵盤打電話");
    }
    public void message() {
        System.out.println("通過鍵盤發(fā)短信");
    }
    
}

// smartphone.java
package abstrated;

public class Smarttelphone extends Telphone{
    public void call() {
        System.out.println("通過語音打電話");
    }
    public void message() {
        System.out.println("通過語音發(fā)短信");
    }
}

// initial.java
package abstrated;

public class initial {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Telphone t1 = new Celltelphone(); // 使用父類的引用創(chuàng)建子類對象
        t1.call();
        t1.message();
        
        Telphone t2 = new Smarttelphone(); // 使用父類的引用創(chuàng)建子類對象
        t2.call();
        t2.message();
    }

}

接口可以理解為時一種特殊的類，由全局常量和公共的抽象方法來組成

它是類的一種具體實現(xiàn)，而接口定義了某一批類所需要遵守的【規(guī)范】，接口并不關(guān)心這些類的內(nèi)部實現(xiàn)，也不關(guān)心這些類的實現(xiàn)細(xì)節(jié)，只是規(guī)定了這些類的必須實現(xiàn)的某些方法。

接口定義

interface A{//定義一個接口

    public static final String MSG = "hello";//全局常量
    public abstract void print();//抽象方法
}

// X.java

package interfaceDemo1;

interface A{
    public static final String MSG = "hello"; // 全局常量
    public abstract void print(); // 抽象方法
}

interface B{
    public static final int a = 10;
    public abstract void get();
}

public class X implements A,B{
    // X實現(xiàn)了兩個接口
    public void print() {
        System.out.println("接口A的抽象方法print()");
    }
    
    public void get() {
        System.out.println("接口B的抽象方法get()");
    }
    
}

// test.java
package interfaceDemo1;

public class test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        X x = new X(); // 實例化子類
        A a = new X();
        B b = new X();
        
        x.print();
        x.get();
        a.print();
        b.get();
    }

}

未完待續(xù)