-------android培訓(xùn)java培訓(xùn)期待與您交流!----------

1.面向?qū)ο蟾拍?/h5>

---

a.面向?qū)ο蟾拍?/p>

• 理解面向?qū)ο螅好嫦驅(qū)ο笫敲嫦蜻^程而言樊拓。是一種思想。將功能封裝進(jìn)對象，強(qiáng)調(diào)具備了功能的對象。
• 任何事物都能抽象成對象，比如人粹胯。人都有共性：年齡，性別辰企，身高风纠，學(xué)歷等等。把人抽象成對象牢贸，而這個人對象內(nèi)部的功能可以定義成年齡竹观，性別，身高等等這些潜索；而對于外界想要調(diào)用你這個人的某個功能屬性臭增，對他來說不必關(guān)心你人對象內(nèi)部的實(shí)現(xiàn)，他只管調(diào)用你的這個對象某個功能竹习，獲取他需要的結(jié)果即可誊抛。方便快捷，提高編程效率整陌。
• 面向?qū)ο笕齻€特征：封裝拗窃、繼承、多態(tài)

---

b.類與對象的關(guān)系

• 類：對現(xiàn)實(shí)生活中事物的描述泌辫。
• 對象：就是實(shí)實(shí)在在的個體的這類事物随夸。
• 定義：
  A. 定義類就是在描述事物，也就是在定義屬性和行為甥郑。屬性和行為共同成為類中的成員(成員變量逃魄，成員函數(shù))。
  B. 對象由new操作符來生成澜搅，在堆內(nèi)存產(chǎn)生一個實(shí)體伍俘。
• 示例：

//定義類
    class People{
    //屬性
    public int age;
    public string name;
    ...
    //定義方法 行為
    public int age()
    {
            return age;
    }

    //對象
    People p = new People();
    p.age();
    ...

• 成員變量和局部變量
  A.最大區(qū)別區(qū)別：作用的范圍不一樣邪锌。成員變量作用于整個類中，從屬于類癌瘾，不必初始化觅丰。局部變量作用于函數(shù)中或者語句中，必須手動初始化妨退。
  B.內(nèi)存的位置：成員變量在堆內(nèi)存中妇萄，因?yàn)閷ο蟮拇嬖诓糯嬖谟趦?nèi)存中。局部變量存在棧內(nèi)存中咬荷。
• 匿名對象
  A.匿名對象是對象的簡化形式,沒有名字的對象冠句。格式為new 實(shí)例名稱();
  B.匿名對象兩種使用情況：
  (1).當(dāng)對對象方法僅進(jìn)行一次調(diào)用時(shí)
  (2).匿名對象可以作為實(shí)際參數(shù)進(jìn)行傳遞

new People().age = 23;

age(new People());

---

c.封裝

• OOP三大特征之一。
• 概念：指隱藏獨(dú)享的屬性和實(shí)現(xiàn)細(xì)節(jié)幸乒，僅對外提供公共訪問方式懦底。
• 封裝的好處：將變化隔離、便于使用罕扎、提高重用性聚唐、提高安全性
• 封裝原則：將不需要對外提供的內(nèi)容都隱藏起來、把屬性都隱藏腔召，提供公共方法對其訪問杆查。
• private:私有權(quán)限反問修飾符。用于修飾類中的成員(成員變量臀蛛，成員函數(shù))亲桦，私有指只在本類中有效。僅僅是封裝的一種表現(xiàn)形式掺栅。

d.構(gòu)造函數(shù)

• 特點(diǎn)：函數(shù)名與類名相同烙肺、不用定義返回值類型、不可以寫return語句氧卧。
• 作用：給對象初始化,用于對象初始化桃笙。
• 注意：當(dāng)一個類中沒有定義構(gòu)造函數(shù)時(shí)，那么系統(tǒng)會默認(rèn)給該類加入一個空參數(shù)的構(gòu)造函數(shù)沙绝，用于對象初始化搏明。當(dāng)在類中定義了初始化構(gòu)造函數(shù)，默認(rèn)的構(gòu)造函數(shù)就沒有了闪檬。
• 特點(diǎn)：構(gòu)造函數(shù)和一般函數(shù)在寫法上不同星著、在運(yùn)行上也不同，構(gòu)造函數(shù)是在對象一建立就運(yùn)行粗悯，給對象初始化虚循。而一般方法是對象調(diào)用才執(zhí)行，給是對象添加對象具備的功能、一個對象建立横缔，構(gòu)造函數(shù)值運(yùn)行一次铺遂，而一般方法可以被該對象調(diào)用多次。

//定義類
class People{
    //默認(rèn)構(gòu)造函數(shù)
    People(){}
}

• 定義構(gòu)造函數(shù)的時(shí)間：當(dāng)對象需要一定的特征或者行為茎刚，就需要對其進(jìn)行構(gòu)造函數(shù)襟锐。

構(gòu)造代碼塊：

//定義類
class People{
    /**
     * 作用：給對象進(jìn)行初始化
     * 特點(diǎn)：對象一建立就運(yùn)行，而且優(yōu)先于構(gòu)造函數(shù)執(zhí)行膛锭，針對所有的對象進(jìn)行初始化都會先被執(zhí)行一次粮坞。
     * 和構(gòu)造函數(shù)的區(qū)別：
     *             構(gòu)造代碼塊是給所有對象進(jìn)行統(tǒng)一初始化。
     *             構(gòu)造函數(shù)時(shí)給對應(yīng)的對象進(jìn)行初始化初狰。
     * 用處：定義給不同對象的共性進(jìn)行初始化莫杈。
     */
    {
        System.out.println("構(gòu)造代碼塊");
    }
}

e.this關(guān)鍵字

• 用于區(qū)分局部變量和成員變量同名情況。
• this代表它所在的函數(shù)所屬對象的引用奢入。
• this代表本類對象姓迅。

    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

• 應(yīng)用：當(dāng)定義類中功能時(shí)，該函數(shù)內(nèi)部要用到調(diào)用該函數(shù)的對象是俊马，這時(shí)使用this來代表使用此對象。凡是本類功能內(nèi)部使用了本類對象肩杈，都用this表示柴我。

class People{
    private int age;

    /**
     * 構(gòu)造函數(shù)
     * @param age
     */
    People(int age)
    {
        this.age = age;
    }
    public int getAge()
    {
        return age;
    }
    public void setAge(int age)
    {
        this.age = age;
    }

    /**
     * 比較兩個人的年齡是否相等。此處的this代表當(dāng)前調(diào)用的對象的引用也就是p1扩然。
     * @param p 人的對象變量
     * @return boolean
     */
    public boolean compare(People p)
    {
        return this.age == age;
    }

    
    public static void main(String[] args) {
        People p1 = new People(20);
        People p2 = new People(23);
        boolean b = p1.compare(p2);
        System.out.println("b = " + b);

    }
}

• this與構(gòu)造函數(shù)：this用與構(gòu)造函數(shù)的之間互相調(diào)用艘儒。而且只能定義在構(gòu)造函數(shù)的第一行。因?yàn)槌跏蓟葓?zhí)行

class People{
    private int age;
    private String name;

    /**
     * 空構(gòu)造函數(shù)
     */
    People()
    {
    }

    /**
     * 構(gòu)造函數(shù)
     * @param age
     */
    People(int age)
    {
        this();//調(diào)用People()構(gòu)造函數(shù)
    }

    /**
     * 構(gòu)造函數(shù)
     * @param age
     * @param name
     */
    People(int age, String name)
    {
        this(23);//調(diào)用People(int age)構(gòu)造函數(shù)
        this.name = name;
    }

f.static關(guān)鍵字

• static修飾符夫偶，修飾變量界睁、方法和代碼塊。
• 當(dāng)成員被static修飾后兵拢，可以用類名直接調(diào)用翻斟。格式：類名.靜態(tài)成員。

    static String name;

    public static void main(String[] args) {
        System.out.println("People.name = " + People.name);
    }

• 特點(diǎn)：隨著類的加載而加載,靜態(tài)隨著類的消失而消失说铃，生命周期最長访惜、優(yōu)先于對象的存在、被所有對象所共享腻扇、可以直接被類名所調(diào)用债热。
• 實(shí)例變量和靜態(tài)成員變量區(qū)別：
  A.存放位置：(1)靜態(tài)成員變量隨著類的加載而存在方法區(qū)中。(2)實(shí)例變量隨著對象的建立而存在于堆內(nèi)存中幼苛。
  B.生命周期：(1)靜態(tài)成員變量最長窒篱，隨著類的消失而消失。(2)實(shí)例變量隨著對象的消失而消失。
• 靜態(tài)使用注意點(diǎn)：
  A.靜態(tài)方法只能訪問靜態(tài)成員(方法與變量)墙杯。非靜態(tài)方法即可以訪問靜態(tài)也可以訪問非靜態(tài)配并。
  B.靜態(tài)方法中不可以定義this、super關(guān)鍵字霍转。因?yàn)殪o態(tài)優(yōu)先于對象存在荐绝。
  C.主函數(shù)是靜態(tài)的。
• 靜態(tài)優(yōu)缺點(diǎn)：
  A.優(yōu)：對對象的共享數(shù)據(jù)進(jìn)行單獨(dú)空間的存儲避消，節(jié)省空間低滩。可以直接被類名調(diào)用岩喷。
  B.缺：生命周期過長恕沫、訪問出現(xiàn)局限性(只能訪問靜態(tài))。

靜態(tài)的使用時(shí)間：

• 靜態(tài)變量(類變量)定義：當(dāng)對象中的出現(xiàn)對象調(diào)用的共享數(shù)據(jù)時(shí)纱意，該數(shù)據(jù)被靜態(tài)所修飾存在于方法區(qū)中婶溯；對象中的特有數(shù)據(jù)定義成非靜態(tài)存在于堆內(nèi)存中。
• 靜態(tài)函數(shù)定義：當(dāng)類中的某個功能沒有訪問到非靜態(tài)數(shù)據(jù)(對象特有的數(shù)據(jù))偷霉，那么該功能可以定義成靜態(tài)的(static)迄委。

class People{
    String name;

    //沒有關(guān)聯(lián)到非成員變量name，那么這個函數(shù)可以設(shè)置成static的类少，方便后面直接通過類名調(diào)用
    public static void show()
    {
        System.out.println("沒有訪問到成員變量");
    }

    public static void main(String[] args) {
        //調(diào)用此方法時(shí)叙身，與name沒有關(guān)系。沒有封裝進(jìn)數(shù)據(jù)硫狞⌒沤危可以不建立對象來調(diào)用，設(shè)置成static的通過類名調(diào)用方便明了残吩。
        People.show();
    }
}

靜態(tài)代碼塊

• 格式：

    static
    {
        System.out.println("靜態(tài)代碼塊");
    }

• 特點(diǎn)：隨著類的加載而執(zhí)行财忽，只執(zhí)行一次，用于給類進(jìn)行初始化泣侮。并優(yōu)先于主函數(shù)即彪。

g.mian函數(shù)

public static void main(String[] args)

• public:表示全局所有訪問權(quán)限最大。也就是封裝性旁瘫。
• static:表示只能通過類調(diào)用祖凫。主函數(shù)隨著類的加載就已經(jīng)存在了。
• void：主函數(shù)沒有具體返回值酬凳。
• main：不是關(guān)鍵字惠况，特殊的一個詞，可以被JVM識別宁仔。
• String[] args:函數(shù)的參數(shù)稠屠，是一個字符串?dāng)?shù)組。

主函數(shù)是固定格式：JVM識別

h.對象初始化過程：
People p = new People("zhangsan", 23);

1.因?yàn)閚ew用到了People.class，所以會先找到People.class文件并加載到內(nèi)存中权埠。
2.執(zhí)行該類中的static代碼塊榨了，如果有的話。再給People.class類進(jìn)行初始化攘蔽。
3.在堆內(nèi)存中開辟空間龙屉，分配內(nèi)存地址。
4.在堆內(nèi)存中建立對象的特有屬性满俗，并進(jìn)行默認(rèn)初始化转捕。
5.對屬性進(jìn)行顯示初始化。
6.對對象進(jìn)行構(gòu)造代碼塊初始化唆垃。
7.對對象進(jìn)行對應(yīng)的構(gòu)造函數(shù)初始化五芝。
8.將內(nèi)存地址賦給內(nèi)存中的引用變量p。

i.繼承

• 面向?qū)ο筇卣髦?/li>
• 把對象間的共性特征進(jìn)行抽取辕万，類與類之間有關(guān)系枢步，最后抽象成一個共性類，被抽取的類的繼承自這個共性類就可渐尿。減少代碼量醉途，提高復(fù)用性。
• 形式：

繼承類 extends 被繼承類

• Java只支持單繼承砖茸。支持多層繼承：B繼承A结蟋，D繼承B。D類可以使用A類的功能渔彰。
• 繼承關(guān)系中類成員的特點(diǎn)：
  A. 變量：如果子類中出現(xiàn)非私有的同名變量時(shí)，子類要訪問本類中的變量推正，用this恍涂。子類要訪問父類中的同名變量，用super植榕，super跟this的使用幾乎一致再沧。super代表父類對象的引用，this代表本類對象引用尊残。

/**
 * Created by Sergio on 2014/11/2.
 */
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Sun s = new Sun();
        s.show();
    }
}

class Parents{
    int num = 5;
}

//子繼承父類
class Sun extends Parents{
    int num = 4;
    void show()
    {
        System.out.println(num);//訪問的是子類的變量炒瘸，相當(dāng)于this.num
        System.out.println(super.num);//碰到同名變量可以使用super關(guān)鍵字訪問父類的變量。
    }
}

B. 函數(shù)：當(dāng)父類出現(xiàn)和子類一模一樣的函數(shù)時(shí)寝衫，當(dāng)子類對象調(diào)用該函數(shù)顷扩，會運(yùn)行子類函數(shù)的內(nèi)容，如同父類的函數(shù)被覆蓋掉慰毅。這也叫做覆蓋(重寫)隘截。

/**
 * Created by Sergio on 2014/11/2.
 */
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Sun s = new Sun();
        s.show();
    }
}

class Parents{
    int num = 5;
    void show()
    {
        System.out.println("被覆蓋");
    }
}

//子繼承父類
class Sun extends Parents{
    int num = 4;
    void show()
    {
        System.out.println(num);//訪問的是子類的變量，相當(dāng)于this.num
        System.out.println(super.num);//碰到同名變量可以使用super關(guān)鍵字訪問父類的變量。
    }
}

覆蓋注意點(diǎn):子類覆蓋父類婶芭，必須保證子類權(quán)限大于等于父類權(quán)限东臀，才可以叫覆蓋，否則編譯失敗犀农。靜態(tài)只能覆蓋靜態(tài)惰赋。
C. 構(gòu)造函數(shù)：在對子類對象進(jìn)行初始化時(shí)，父類的構(gòu)造函數(shù)也會運(yùn)行呵哨，那是因?yàn)樽宇惖臉?gòu)造函數(shù)默認(rèn)第一行有一條隱式的語句super()[會訪問父類中空參數(shù)的構(gòu)造函數(shù)赁濒。而且子類中所有的構(gòu)造函數(shù)默認(rèn)第一行都是super();];

/**
 * Created by Sergio on 2014/11/2.
 */
public class ExtendsDemo2 {
    public static void main(String[] args) {
        Sun2 s2 = new Sun2(2);
        System.out.println(s2.x);//訪問的是父類抽取的x = 4；
    }
}

class Parents2{
    int x = 4;
    Parents2()
    {
        System.out.println("fu run");
    }

    Parents2(int x)
    {
        System.out.println("x = " + x);
    }
}

//子繼承父類
class Sun2 extends Parents2{
    Sun2()
    {
        //super();隱式的構(gòu)造函數(shù)
        super(1);//根據(jù)父類構(gòu)造函數(shù)來指定
        System.out.println("zi run");
    }

    Sun2(int x)
    {
        super(3);//根據(jù)父類構(gòu)造函數(shù)來指定
        System.out.println("zi run");
    }
}

super語句一定定義在子類構(gòu)造函數(shù)的第一行仇穗，初始化動作要先做流部。子類的所有的構(gòu)造函數(shù)，默認(rèn)都會訪問父類中空參數(shù)的構(gòu)造函數(shù)纹坐，因?yàn)樽宇惷恳粋€構(gòu)造函數(shù)的第一行都有一句隱式super();當(dāng)父類中沒有空參數(shù)的構(gòu)造函數(shù)時(shí)枝冀，子類必須手動通過super語句形式來指定要訪問的構(gòu)造函數(shù)。子類的構(gòu)造函數(shù)第一行也可以手動指定this語句來訪問本類中的構(gòu)造函數(shù)耘子。子類中至少會有一個構(gòu)造函數(shù)會訪問父類中的構(gòu)造函數(shù)果漾。

j. final關(guān)鍵字

• 解釋：最終。修飾符谷誓。
• 修飾的范圍：類绒障、函數(shù)、變量捍歪。
• 特點(diǎn)：被final修飾的類不可以被繼承户辱，為了避免被繼承，被子類復(fù)寫功能糙臼。
• final類：被final修飾的類不可以復(fù)寫庐镐。
• final變量：被final修飾的變量是一個常量只能賦值一次，既可以修飾成員變量变逃，又可以修飾局部變量必逆。
• 使用的時(shí)候。描述事物時(shí)揽乱，一些數(shù)據(jù)的出現(xiàn)值是固定的名眉。可以用一個常量來表示凰棉。
• 命名：常量的書寫規(guī)范所有字母都大寫损拢。如果有多個單詞定義，每個單詞通過"_"鏈接撒犀。P_AI探橱。比如PI申屹。

k. 抽象類

• 多個類出現(xiàn)相同功能，但是功能主體不同隧膏，進(jìn)行向上抽取哗讥，只抽取功能定義，而不抽取功能主題胞枕。
• 定義方式：abstract 類名包含抽象方法和非抽象方法杆煞、abstract 方法名();抽象方法只有方法名沒有方法內(nèi)容。
• 注意：抽象方法只存在于抽象類中腐泻。抽象類不可以用new創(chuàng)建對象决乎，因?yàn)檎{(diào)用抽象方法沒有意義。抽象方法要被使用派桩，必須由子類復(fù)寫所有的抽象方法后构诚，建立子類對象調(diào)用；如果子類只覆蓋了部分抽象方法铆惑，那么該子類還是一個抽象類范嘱，因?yàn)槌橄蠓椒ㄖ淮嬖谟诔橄箢愔小?/li>
• 抽象類不可以實(shí)例化,沒意義。

l. 接口

• 格式：interface 接口名{}员魏。接口中定義常量丑蛤、方法固定修飾符如下(修飾符可以省略，interface會自動加上撕阎。)：
  A. 常量：public static final
  B. 方法：public abstract
  接口中的成員都是public受裹。接口中的方法都是抽象的。

/**
 * Created by Sergio on 2014/11/3.
 */
interface InterfaceDemo {
    public static final int NUM = 3;//變量定義
    public abstract void intefaceDemo();//方法定義
}


//接口必須被子類實(shí)現(xiàn)用關(guān)鍵字implements虏束，接口可以被多個子類實(shí)現(xiàn)棉饶。子類也可以繼承于一個父類。必須將接口中的所有方法實(shí)現(xiàn)因?yàn)榻涌谥械姆椒ǘ际浅橄蟮?class InterfaceTest extends ExtendsDemo2 implements InterfaceDemo,InterfaceDemo2....{
    @Override
    public void intefaceDemo() {

    }
}

接口是不可以創(chuàng)建對象的镇匀，因?yàn)橛谐橄蠓椒ù嬖谂檠巍Ｐ枰蛔宇悓?shí)現(xiàn)，覆蓋接口中的抽象方法后坑律，子類才可以實(shí)例化，否則子類是一個抽象類囊骤。
接口與接口之間的關(guān)系是繼承關(guān)系晃择，支持多繼承關(guān)系。

• 接口特點(diǎn)：
  -. 接口是對外暴露的規(guī)則
  -. 接口是程序的功能擴(kuò)展
  -. 接口可以用來多實(shí)現(xiàn)
  -. 類與接口之間是實(shí)現(xiàn)關(guān)系也物，而且類可以繼承一個類的同時(shí)實(shí)現(xiàn)多個接口
  -. 接口與接口之間可以有繼承關(guān)系

m. 多態(tài)與關(guān)鍵字instanceof

一. 概念

• 面向?qū)ο筇卣髦?/li>
• 概念:事物存在的多種體現(xiàn)形態(tài)宫屠。比如人分為：男人、女人滑蚯。人 r = new 男人(); 人 r2 = new 女人();

二. 多態(tài)擴(kuò)展性

1. 多態(tài)的體現(xiàn)：父類的引用指向了自己的子類對象(父類)浪蹂。
2. 多態(tài)的前提：類與類之間有關(guān)系抵栈，有繼承或者實(shí)現(xiàn)。
3. 多態(tài)的益處：多態(tài)的出現(xiàn)提高了程序的擴(kuò)展性坤次，通常有前提條件是：存在覆蓋古劲。
4. 多態(tài)的弊端：只能使用父類的引用訪問父類中的成員。
5. 多態(tài)中成員的特點(diǎn)：
   • 非靜態(tài)成員函數(shù)：
     a. 在編譯時(shí)期:參與引用型變量所屬的類中是否有調(diào)用的方法缰猴，如果有編譯通過产艾，如果沒有編譯失敗。
     b. 在運(yùn)行時(shí)期：參與對象所屬的類中是否有調(diào)用的方法滑绒。
     總結(jié)就是:成員函數(shù)在多態(tài)調(diào)用時(shí)闷堡，編譯看左邊，運(yùn)行看右邊疑故。
   • 成員變量：
     無論編譯和運(yùn)行：都參考左邊(引用型變量所屬的類)
   • 靜態(tài)成員函數(shù)(子類不覆蓋父類方法杠览，父類走父類，子類走子類纵势。變量也一樣踱阿。)：
     無論編譯和運(yùn)行：都參考左邊

/**
 * Created by Sergio on 2014/11/19.
 */
public class PolymorphicDemo {
    public static void main(String[] args) {
        //調(diào)用子類覆蓋父類的eat()方法，有局限性在這點(diǎn)上
        function(new Dog());
        function(new Pig());
    }

    //定義共性的功能方法eat()
    public static void function(Animal a)
    {
        a.eat();
    }
}

/**
 * 集中抽象功能的父類Animal
 */
abstract class Animal{
    abstract void eat();
}


/**
 * 定義Dog類繼承之Animal父類吨悍，并且擁有自己的特定功能類houseKeeping().
 */
class Dog extends Animal{
    //覆蓋父類eat()方法
    public void eat()
    {
        System.out.println("Dog.eat");
    }

    //子類特有的方法
    public void houseKeeping()
    {
        System.out.println("看家");
    }
}


/**
 * 定義Pig類繼承之Animal父類扫茅，并且擁有自己的特定功能類fat().
 */
class Pig extends Animal{
    //覆蓋父類eat()方法
    public void eat()
    {
        System.out.println("Pig.eat");
    }

    //子類特有的方法
    public void fat()
    {
        System.out.println("養(yǎng)膘");
    }
}

三. 父類、子類類型轉(zhuǎn)型

/**
 * Created by Sergio on 2014/11/19.
 */
public class PolymorphicDemo {
    public static void main(String[] args) {
        //類型提升育瓜，向上轉(zhuǎn)型葫隙。將Dog類型提升為Animal類型
        Animal a = new Dog();
        a.eat();

        /**
         * 如果要調(diào)用子類特有的方法操作：強(qiáng)制將父類的引用轉(zhuǎn)成子類類型，向下轉(zhuǎn)型.將父類a引用強(qiáng)制轉(zhuǎn)換成子類類型Dog躏仇。
         *
         * 注意：不能將父類對象轉(zhuǎn)成子類類型恋脚。能轉(zhuǎn)換的是父類指向了自己的子類對象時(shí)，該引用可以被提升也可以強(qiáng)制轉(zhuǎn)換焰手。
         * 多態(tài)始終都是子類在作者變化糟描。
         */
        Dog d = (Dog)a;
        d.houseKeeping();

        //fun函數(shù)調(diào)用子類對象的功能
        fun(new Dog());
        fun(new Pig());
    }

    //提煉共性函數(shù)特征fun(Animal a)
    public static void fun(Animal a)
    {
        a.eat();

        /**
         * 判斷傳遞進(jìn)來的子類是那個對象的。使用關(guān)鍵字instanceof,判斷左邊對象是否屬于右邊類的實(shí)例书妻，返回boolean
         * 類型數(shù)據(jù)船响。
         *
         * instanceof是一個二元操作符。使用的前提：1.子類型有限躲履、2.對象需要做比較首先判斷是否屬于某個類的實(shí)例
         */
        if (a instanceof Dog){
            Dog d = (Dog)a;
            d.houseKeeping();
        }
        else if(a instanceof Pig)
        {
            Pig p = (Pig)a;
            p.fat();
        }
    }
}

/**
 * 集中抽象功能的父類Animal
 */
abstract class Animal{
    abstract void eat();
}


/**
 * 定義Dog類繼承之Animal父類见间，并且擁有自己的特定功能類houseKeeping().
 */
class Dog extends Animal{
    //覆蓋父類eat()方法
    public void eat()
    {
        System.out.println("Dog.eat");
    }

    //子類特有的方法
    public void houseKeeping()
    {
        System.out.println("看家");
    }
}


/**
 * 定義Pig類繼承之Animal父類，并且擁有自己的特定功能類fat().
 */
class Pig extends Animal{
    //覆蓋父類eat()方法
    public void eat()
    {
        System.out.println("Pig.eat");
    }

    //子類特有的方法
    public void fat()
    {
        System.out.println("養(yǎng)膘");
    }
}

四：小示例

package com.sergio.lianxi;

/**
 * Created by Sergio on 2014/11/20.
 *
 * 需求：電腦運(yùn)行實(shí)例工猜。電腦運(yùn)行基于主板米诉。
 */
public class PolymorphicDemo2 {
    public static void main(String[] args) {
        MotherBoard mb = new MotherBoard();
        mb.run();
        mb.usePCI(new SoundCard());
    }

}

/**
 * 電腦的各種部件基于電腦主板上的pci接口運(yùn)行。模擬PCI接口篷帅。
 */
interface PCI{
    public void open();
    public void close();
}

//定義主板史侣，運(yùn)行的基礎(chǔ)
class MotherBoard{
    public void run(){
        System.out.println("主板運(yùn)行");
    }

    public void usePCI(PCI p)//接口型引用指向自己的子類對象
    {
        if(p != null)
        {
            p.open();
            p.close();
        }
    }
}


/**
 * 需要運(yùn)行部件實(shí)現(xiàn)方式
 */
class SoundCard implements PCI
{
    @Override
    public void open() {
        System.out.println("聲卡運(yùn)行");
    }

    @Override
    public void close() {
        System.out.println("聲卡關(guān)閉");
    }
}

2.設(shè)計(jì)模式

單例設(shè)計(jì)模式

• 設(shè)計(jì)模式概念：解決某一類問題最行之有效的方法拴泌，可以重復(fù)利用。java有23種設(shè)計(jì)模式惊橱。
• 單例模式：只對外提供一個實(shí)例蚪腐。在內(nèi)存中只存在一個對象。
• 三要素：(1)在類體中需要具有靜態(tài)的私有的本類型的變量李皇、(2)構(gòu)造方法必須是私有的削茁，不允許實(shí)例化、(3)提供一個公共的靜態(tài)的入口方法掉房。

package com.sergio.lianxi;

/**
 * 單例模式餓漢式茧跋。
 * 第一種方式。類一進(jìn)內(nèi)存就建立對象卓囚。
 * Created by Sergio on 2014/10/10.
 */
public class SinglePattern {
    private int age;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "SinglePattern{" +
            "age=" + age +
            '}';
    }

    //以下三個方法是單例使用的必須寫法
    /**
     * 靜態(tài)私有化本類的成員變量
     */
    private static SinglePattern instance = new SinglePattern();

    /**
     * 私有化構(gòu)造方法瘾杭，禁止對象實(shí)例化
     */
    private SinglePattern(){}

    /**
     * 對外提供一個公共的靜態(tài)入口方法
     */
    public static SinglePattern getInstance()
    {
        return instance;
    }
}

class SinglePatternTest
{
    public static void main(String[] args) {

        SinglePattern s1 = SinglePattern.getInstance();
        SinglePattern s2 = SinglePattern.getInstance();
        s1.setAge(23);
        System.out.println("s2 = " + s2);
    }
}

package com.sergio.lianxi;

/**
 * Created by Sergio on 2014/10/10.
 * 單例模式懶漢式。也叫延遲加載式哪亿。只有調(diào)用了getInstance方法時(shí)粥烁，才建立對象
 */
public class SinglePattern2 {
    private static SinglePattern2 instance = null;
    private SinglePattern2(){}
    public static synchronized SinglePattern2 getInstance()
    {
if
        if(instance == null)
        {
            instance = new SinglePattern2();
        }
        return instance;
    }
}

注意：開發(fā)時(shí)候使用餓漢式，也就是第一種蝇棉。