java中面向對象

1、java面向對象

java是一門面向對象的語言，在面向對象的世界中，把事務看成對象，面向對象的做法確實是把屬性和功能封裝起來，但是其核心是歸類和抽象。

把相關的屬性和功能集中起來，把可以分離的部分隔絕開來，從而把複雜的業務邏輯切割成互相之間可以相對獨立的部分，降低開發的難度。

主要從下面幾個方面理解：
1、理解類，接口，方法，構造器
2、理解修符:public,protected,private
3、理解封裝，繼承，多態。面向對象的三個特徵不是分割的，是一個整體。

2、封裝

封裝是將對象的一些信息隱藏起來，不對外暴漏細節。只提供對外使用或者調用的方法。爲什麼不對外暴漏？封裝有什麼好處？

1. 隱藏類的實現細節，使用的時候方便，不需要知道內部具體什麼方法，如何實現，哪些限定，只需要調用一下即可。
2. 安全。通過設置一定的方法，對外提供。外面沒有辦法直接訪問或者修改對象的一些屬性（比如說，你兜裏有錢，別人是不是直接可以從你兜裏拿？當然不可以，但你又提供一個機制取出你兜裏的錢，比如說是你，或者你家人纔可以拿）
3. 數據校驗。比如定義一個Person類的時候，它有姓名和年齡，在設置年齡的時候是不是要校驗，假如寫200，300，就是不合法。
4. 便於修改，提高可維護性。

---

也就是類的信息，該隱藏的隱藏，又要提供對外暴漏的方法。

理解下面四個訪問權限：
private:當前類權限
default:包訪問權限
protected子類訪問權限
public公共訪問權限

舉個例子：

package com.example.demo;

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    //對用戶年齡進行校驗
    public void setAge(int age) {

        if(age>150  || age<0){
            System.out.println("設置年齡不合法");
            return;
        }
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }


}

測試代碼

public class PersonTest {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
          Person p=new Person();
          p.setName("abc");
          p.setAge(200);
          System.out.println(p);
          System.out.println(p.getAge());
    }
}

輸出結果：

3、繼承

1、繼承能夠實現代碼複用，簡化代碼，容易拓展維護。
2、子類繼承父類，能夠使用父類的方法屬性，也可以覆蓋，使用自己特有的方法和屬性。
3、抽象類是爲繼承做準備的，抽象類是指抽取出子類共同點，子類只一定要有這樣的方法。因此子類一定要實現抽象類中的抽象方法。
（下面探討抽象與接口的區別）
4、abstract 不能與private、static、final並列修飾同一個方法。
原因：
abstract不能與private使用，因爲子類一定要重寫這個方法，如果用private就訪問不到父類的這個方法

abstract與final：final修改的類，不能被繼承。但是abstract中可以用final修飾的方法。final修改的方法，不能被重寫，因爲父類已經感覺完美實現了，只能讓子類調用。

abstract不能與static一塊使用，abstrac修飾的就是要等到子類時具體的實現，一定是動態的，和static靜態矛盾
從代碼中仔細的理解

package com.example.demo;

public class AppleClass extends FruiteClass {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        AppleClass apple = new AppleClass();
        // 子類重寫父類方法；
        apple.getName();
        // 使用子類自己的名子；
        apple.getAppleName();
        // 獲取父類的名子；
        apple.getFruiteName();
        apple.getAbsName();
        apple.getFinalName();

    }

    public void getAppleName() {
        String name = "apple name";
        System.out.println(name);
    }

    public void getFruiteName() {
        System.out.println(super.name);
    }

    // 子類重寫父類方法：
    @Override
    public void getName() {
        // TODO Auto-generated method stub
        super.getName();
        // 在這super.getName()的作用
        // 如果需要用父類的方法，直接調用super.getName
        // 如果父類的方法不能滿足，或者沒用，去掉就可以，
    }

    @Override
    public void getAbsName() {
        // TODO Auto-generated method stub
        System.out.println("abstract name");
    }

}

abstract class FruiteClass {
    // protected子類可以訪問
    protected String name = "fruite name";
    // private修改的，子類不能訪問
    private String color = "fruite";

    public void getName() {
        System.out.println("fruite getName()");
    }
    //abstract方法，具體到子類中才實現。
    public abstract void getAbsName();
    //fianl修飾的方法，只能給子類調用，不用重寫（父類的一些方法已經完美，不讓子類重寫，只能調用）
    public final void getFinalName(){
        System.out.println("fruite getFinalName()");
    }
}

4、多態

多態的作用是消除類型間的耦合關係，比如說，將接口和實現分離開，不但能夠改善代碼的組織結構，還容易拓展。

1、java中的引用變量分兩種類型，一種是編譯時期類型，一種是運行時期類型。如果編譯時類型和運行時類型不一樣，這就產生多態。
靜態多態就是在編譯時期確定調用的方法,最典型的的就是重載了。動態多態是在運行時確定的,最典型的的父類和子類之間的重寫。所以重寫和重載都是多態的表現。

2、多態的場景

1. 存在繼承關係
2. 子類重寫父類的方法
3. 父類引用指向子類對象。

3、多態在java中具體實現

1. 類繼承（重寫父類方法）
2. 接口實現
3. 方法重載

package com.example.demo;

public class SubClass  extends BaseClass{

    public static void main(String[] args) {
        //在編譯時期是BaseClass,在運行時是SubClass
        //最終調用的是子類的getBaseName()；
        BaseClass sub=new SubClass();
        sub.getBaseName();
    }
    @Override
    public void getBaseName() {
        System.out.println("getSubName()");
    }

}
class BaseClass{

    String baseName="baseName";
    public void getBaseName(){
        System.out.println("getBaseName()");

    }
}

5、Final關鍵字

在編程中，我們常遇到一些變量或者對象，我們要求它不可改變。
1、一個不可改變的編譯時常量。
2、一個在運行時期被初始化的值，而不希望它的值改變。

對於基本數據類型，final使數值不可改變。
對於對象引用，使引用恆定不變，一旦引用被引用初始化指向一個對象，就無法讓他再指向另一個對象。

6、抽象與接口的區別

抽象類是從多個具體類中抽象出來的父類，它具有很高的抽象層次。多個類以這個抽象類爲模板，避免子類設計的隨意性，要求子類必須實現一些特點的功能。

抽象類體現的就是一種模板的設計思想，抽象類作爲多個子類的通用模板，子類在抽象類的基礎上進行擴展，改造。

---

接口：如果多個類中，每一個類中所有的功能都相似，只是具體實現不同。那麼這個類，在抽象類的基本上再提煉。這就是接口。
可以說接口是比抽象更加進一步的提取。

接口裏面的成員變量只能是靜態常量，接口裏默認的方法只能是抽象方法。
也就是接口裏面的變量默認爲public static fainl修飾
接口裏的方法默認爲abstract修飾，因此如果要實現接口，就必須實現接口裏面的所有方法。

相同點：

1. 都不能被實例化，因爲他們是模板，是抽取，具體實現讓子類開實現的。
2. 都包含抽象方法（接口是全部抽象方法）要繼承或者實現，子類就必須實現所有的抽象方法。

不同點：

1. 接口比抽象更加“抽象”，它只包含抽象方法，成爲規範，標準。
2. 抽象類能夠有構造方法，並不是用來實例化的，而是讓子類調用，完成屬於抽象類的初始化操作。
3. 抽象用於繼承，子父類之間，接口用於實現。

7、java是不是一門純粹面向對象的語言

參考博客
http://www.codeceo.com/article/why-java-purely-object-oriented-language.html