java它是OOP語言（ObjectOrientedProgramming）面向?qū)ο缶幊陶Z言，那么什么是對象？對象是什么？毫無疑問這個問題有很多個答案，每個人對對象的理解是不一樣。
java面向?qū)ο蟮娜蠡咎卣髦庋b：我們?yōu)槭裁匆獙ξ覀兊拇a進(jìn)行封裝？當(dāng)我們定義一個人類的體重，要求用戶輸入，如果用戶輸入1000kg,這個對我們?nèi)藖碚f是不現(xiàn)實的，那我們要怎樣使用戶輸入不合理時我們能及時的輸出異常？這就要用到j(luò)ava里面的封裝了。封裝的優(yōu)點(diǎn)：隱藏類實現(xiàn)細(xì)節(jié)；我們通過屬性的get和set方法執(zhí)行，這樣我們后期修代碼也比較方便。那么我們是怎樣對屬性進(jìn)行封裝？例

public class Dog {
    private String name;
    private int love;
    private int health;
    private String strain;
    /***
     * 獲取name的值
     * @return name的值
     */
    public String getName() {
        return name;
    }
    /***
     * 對那么進(jìn)行賦值
     * @param name 傳回來的狗的名字
     */
    public void setName(String name) {
        this.name = name;
    }
    /***
     * 獲取狗狗的親密度
     * @return 狗狗的親密度
     */
    public int getLove() {
        return love;
    }
    /***
     * 對狗狗的親密度進(jìn)行賦值
     * @param love 返回狗狗的親密度
     */
    public void setLove(int love) {
        if (love>=0 && love<= 100){
        this.love = love;
        }else {
            this.love = 40;
            System.err.println("親密度輸入有誤?。?！默認(rèn)為40");
        }
    }
    /***
     * 獲取狗狗的健康值
     * @return 狗狗的健康值
     */
    public int getHealth() {
        return health;
    }
    /***
     * 對狗狗的健康值進(jìn)行賦值
     * @param health 返回來的狗狗的健康的值
     */
    public void setHealth(int health) {
        if (health>=0 && health<= 100){
            this.health = health;
        }else {
            this.health = 40;
            System.err.println("健康值輸入有誤！??！默認(rèn)為40");        }
    }
    /***
     * 獲取狗品種
     * @return 狗品種
     */
    public String getStrain() {
        return strain;
    }
    /*** 
    * 給狗的品種進(jìn)行賦值
     * @param strain 用戶輸入的狗的品種
     */
    public void setStrain(String strain) {
        if ("聰明的拉布拉多犬".equals(strain)||"酷酷的雪納瑞".equals(strain)) {
            this.strain = strain;
        }else {
            this.strain = "聰明的拉布拉多犬";
            System.err.println("輸入有誤?。。。∧J(rèn)為聰明的拉布拉多犬");
        }
    }
    public String toString(){
        return "寵物自白：\n我的名字加"+name+"我的健康值為"+health+"我和主人的親密度為"+love+"我的類型為"+strain;
    }
}

上述代碼我們就是對我們定義的狗狗的名稱，健康值，親密度，以及狗的品種屬性并進(jìn)行了封裝。我們通過set方法對屬性進(jìn)行賦值，通過get方法來對屬性進(jìn)行取值最后我們定義一個toString()方法輸出我們要輸出的內(nèi)容。這要我們在測試類里面我們只需要提示用戶輸入名稱，健康值，親密度，以及狗的品種，同時我們向Dog類里面?zhèn)髦稻涂梢粤恕＿@樣我們要修改代碼我們就只需要去修改Dog類就可以了。
在jsp中像上面的代碼叫做JavaBean，其實就是封裝。
java面向?qū)ο蟮娜筇匦灾^承：繼承就像太子繼承皇位一樣，他可以繼承他父親的皇位，得到他父親的江山，當(dāng)時他需要自己的國家更加的強(qiáng)大，那么他就需要有自己的改革。在java里面的繼承也是這樣，我們子類可以繼承父類的東西，也可以有自己的東西。子類是通過關(guān)鍵字extends來繼承父類。子類繼承父類有幾點(diǎn)注意事項：
1、當(dāng)父類是一個抽象類時，子類如果繼承他，那么子類必須實現(xiàn)父類的抽象方法。如果子類沒有重寫父類的抽象方法，那么這個子類也要定義為抽象類。
2、子類是不可以重寫父類的構(gòu)造方法的。
例：

/**
 * Created by Zippo on 2016/7/4.
 * 創(chuàng)建一個抽象的寵物類
 */
public abstract class Pet {
    private String name;
    private int love;
    private int health;
    public String getName() {
        return name;
    }
    /***
     * 對寵物名字進(jìn)行賦值
     * @param name 傳回來的寵物的名字
     */
    public void setName(String name) {
        this.name = name;
    }
    /***
     * 獲取寵物的親密度
     * @return 寵物的親密度
     */
    public int getLove() {
        return love;
    }
    /***
     * 對寵物的親密度進(jìn)行賦值
     * @param love 返回寵物的親密度
     */
    public void setLove(int love) {
        if (love>=0 && love<= 100){
            this.love = love;
        }else {
            this.love = 40;
            System.err.println("親密度輸入有誤?。?！默認(rèn)為40");
        }
    }
    /***
     * 獲取寵物的健康值
     * @return 寵物的健康值
     */
    public int getHealth() {
        return health;
    }
    /***
     * 對寵物的健康值進(jìn)行賦值
     * @param health 返回來的寵物的健康的值
     */
    public void setHealth(int health) {
        if (health>=0 && health<= 100){
            this.health = health;
        }else {
            this.health = 40;
            System.err.println("健康值輸入有誤?。。∧J(rèn)為40");
        }
    }
    public abstract void print();
}

上述代碼我們定義一個抽象的寵物類，因為寵物有很多，所以我們定義了一個抽象的方法輸出我們要輸出的東西。那么如果我們定義一個子類的話，我們必須實現(xiàn)這個寵物類的抽象方法，如果沒有實現(xiàn)，那么他的子類也必須是抽象的，那么我們要怎樣實現(xiàn)呢？
例：

public class Dog extends Pet {
    private String strain;
    /***
     * 獲取狗品種
     * @return 狗品種
     */
    public String getStrain() {
        return strain;
    }
    /***
     * 給狗的品種進(jìn)行賦值
     * @param strain 用戶輸入的狗的品種
     */
    public void setStrain(String strain) {
        if ("聰明的拉布拉多犬".equals(strain)||"酷酷的雪納瑞".equals(strain)) {
            this.strain = strain;
        }else {
            this.strain = "聰明的拉布拉多犬";
            System.err.println("輸入有誤?。。?！默認(rèn)為聰明的拉布拉多犬");
        }
    }
    @Override
    public void print() {
        System.out.println("name::::"+getName()+"health::::"+getHealth()+"love::::"+getLove()+"strian::::"+strain);
    }
}

現(xiàn)在我們定義了一個Dog類他繼承了Pet類，那么他要實現(xiàn)Pet類的抽象的輸出方法，Dog類重寫了Pet類的輸出方法，通過這樣的方式來實現(xiàn)Pet類的抽象方法。這就是繼承。子類繼承父類，不可以訪問父類的私有的屬性，子類只有通過父類的共有的方法去獲取父類屬性的值。這樣我們在測試類中只需要向子類傳值就可以了，同時我們也可以大量的節(jié)省重復(fù)的代碼。
在類中，我們都知道類的加載順序：
靜態(tài)屬性->靜態(tài)代碼塊->實例屬性->實例代碼塊->構(gòu)造方法。
那么繼承狀態(tài)下的類加載順序：
父類靜態(tài)屬性 ->父類靜態(tài)塊 ->子類靜態(tài)屬性 ->子類靜態(tài)塊->父類實例屬性->父類實例塊 ->父類構(gòu)造方法 ->子類實例屬性 ->子類實例塊 ->子類構(gòu)造方法。
java面對象的第三大特性：多態(tài)。多態(tài)就是我們運(yùn)用一個消息，可以有多個不同的了對它做出響應(yīng)。
我們運(yùn)用多態(tài)來編寫代碼，在我們要更新我們代碼的時候，我們再新建一個類，這樣我們就可以直接運(yùn)用，就不要去修改其他的代碼，這樣代碼的可擴(kuò)展性就比較的強(qiáng)了，同時我們也可以避免在我們修改代碼的時候?qū)е鲁霈F(xiàn)大量的bug.那我們怎樣運(yùn)用都太呢？例：
我們先創(chuàng)建一個抽象的寵物類，同時他也是一個父類，并對它的屬性進(jìn)行封裝，定義一個抽象的方法。

public abstract class Pet {
    private String name;
    private int health;
    private int love;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
   public int getHealth() {
        return health;
    }
    public void setHealth(int health) {
        this.health = health;
    }
    public int getLove() {
        return love;
    }
    public void setLove(int love) {
        this.love = love;
    }
    public abstract  void  print();}

然后我們創(chuàng)建一個寵物類的子類狗類，對品種這個屬性進(jìn)行封裝，實現(xiàn)Pet類的抽象方法。

public class Dog extends Pet{
    public String getStrain() {
        return strain;
    }
    public void setStrain(String strain) {
        this.strain = strain;
    }
    private String strain;
    @Override
    public void print() {
        this.setHealth(getHealth());
        System.out.println(this.getName()+"正在打針，吃藥體力恢復(fù)中.......");
    }
}

我們在創(chuàng)建主人類來給寵物看病。

public class Master {
    public void cure(Pet pet){
        if (pet.getHealth()<50){
            pet.print();
        }
    }
}

我們在主人這個類里面我們只是定義一個，這個方法的參數(shù)我們就是父類，這樣我們在測試類中只需要調(diào)用這個方法就可以了。

public class petText {
    public static void main(String[] args) {
        Master master = new Master();
        Scanner scanner = new Scanner(System.in);
        System.out.print("請輸入寵物的品種：");
        String str = scanner.next();
        System.out.print("請輸入寵物的姓名：");
        String name = scanner.next();
        System.out.print("請輸入"+name+"的健康值：（0--100）");
        int he = scanner.nextInt();
        System.out.print("請輸入"+name+"的品種：");
        String strina = scanner.next();
        Dog dog = new Dog();
        master.cure(dog);
    }
}

這樣我們就不用再使用dog.方法名了，我們只需要調(diào)用主人了里面的哪一個方法就可以了，把我們創(chuàng)建的dog這個對象傳進(jìn)去，這樣我們就可以輸出了。因為我們在主人類里面的有一個pet.print();方法，而我們的類型是父類。這樣寫的好處是當(dāng)我們要更新新的一個動物的時候我們只需要創(chuàng)建一個該動物的類，我們不用去修改其它地方的代碼，這樣我們就可以避免在我們更新代碼的時候出現(xiàn)bug了。
這就是面向?qū)ο蟮娜筇匦浴Ｒ驗橛羞@些