摘要：當(dāng)遇到方法參數(shù)為抽象類類型時(shí)，要傳入一個(gè)實(shí)現(xiàn)抽象類所有抽象方法的子類對象。根據(jù)向酒店中，增加多名員工其中包含名經(jīng)理，名廚師名服務(wù)員。

* A: ?    Ctrl+T：查看所選中類的繼承樹
    例如，在下面代碼中，選中Teacher類名，然后按Ctrl+T，就會(huì)顯示出Teacher類的繼承關(guān)系

* B:?    查看所選中方法的源代碼
    Ctrl+滑動(dòng)鼠標(biāo)點(diǎn)擊方法名，或者選中方法名后，按F3鍵查看所選中方法的源代碼。

* A: 在eclipse使用時(shí)，可以配合文檔注釋，導(dǎo)出對類的說明文檔，從而供其         他人閱讀學(xué)習(xí)與使用。
    通過使用文檔注釋，將類或者方法進(jìn)行注釋用@簡單標(biāo)注基本信息。如@author 作者、@version代碼版本、@param方法參數(shù)、@return方法返回值等。

        

* A: ?    導(dǎo)入jar包：即把指定的jar包，加入到指項(xiàng)目中，提供給項(xiàng)目使用。
    導(dǎo)入jar包的過程是將jar包加入到項(xiàng)目的.classpath文件中去，讓項(xiàng)目識(shí)別，便可以使用jar包中所有的.class文件類。
    以下是加入步驟：
    1：項(xiàng)目根文件夾下創(chuàng)建lib文件夾，用于同一管理所有的jar文件
    2：把jar文件復(fù)制到lib文件夾中
    3：右鍵點(diǎn)擊jar文件，點(diǎn)擊Build Path，選擇Add to Build Path，此時(shí)查看項(xiàng)目根文件夾下的.classpath文件，發(fā)現(xiàn)新加入的jar包路徑被配置到了該文件中。說明可以使用jar包中所有類了。

注意：
    Jar包加入后，必須Add to Build Path才能使用
    Jar包加入后，加入的類也必須導(dǎo)包，如果加入的類其包名與現(xiàn)有類包名相同，則視作在同一個(gè)包下。(不常見)

==============================第二節(jié)課開始====================================

A: 常用來修飾類、方法、變量的修飾符如下：
?    public 權(quán)限修飾符，公共訪問, 類,方法,成員變量
?    protected 權(quán)限修飾符，受保護(hù)訪問, 方法,成員變量
?    默認(rèn)什么也不寫 也是一種權(quán)限修飾符，默認(rèn)訪問, 類,方法,成員變量
?    private 權(quán)限修飾符，私有訪問, 方法,成員變量
?    static 靜態(tài)修飾符  方法,成員變量
?    final 最終修飾符   類,方法,成員變量,局部變量
?    abstract 抽象修飾符  類 ,方法

B: 不能同時(shí)使用的修飾符
    同時(shí)，abstract與private不能同時(shí)使用；
    同時(shí)，abstract與static不能同時(shí)使用；
    同時(shí)，abstract與final不能同時(shí)使用。

? C: 修飾類能夠使用的修飾符：

    修飾類只能使用public、默認(rèn)的、final、abstract關(guān)鍵字
    使用最多的是 public關(guān)鍵字

    a:代碼案例
        public class Demo {} //最常用的方式
        class Demo2{}
        public final class Demo3{}
        public abstract class Demo4{}

D:修飾成員變量能夠使用的修飾符：
    public : 公共的
    protected : 受保護(hù)的
        : 默認(rèn)的
    private ：私有的
    final : 最終的
    static : 靜態(tài)的
    使用最多的是 private

    a: 代碼案例
        public int count = 100;
        protected int count2 = 100;
        int count3 = 100;
        private int count4 = 100; //最常用的方式
        public final int count5 = 100;
        public static int count6 = 100;

? E:修飾構(gòu)造方法能夠使用的修飾符：

    public : 公共的
    protected : 受保護(hù)的
        : 默認(rèn)的
    private ：私有的
    使用最多的是 public

    a:代碼案例
        public Demo(){} //最常用的方式
        protected Demo(){}
        Demo(){}
        private Demo(){}

    ?    修飾成員方法能夠使用的修飾符：
            public : 公共的
            protected : 受保護(hù)的
                : 默認(rèn)的
            private ：私有的
            final : 最終的
            static : 靜態(tài)的
            abstract : 抽象的
            使用最多的是 public
        public void method1(){}//最常用的方式
        protected void method2(){}
        void method3(){}
        private void method4(){}
        public final void method5(){}
        public static void method6(){}//最常用的方式
        public abstract void method7();//最常用的方式

* A：程序編譯
    ?    數(shù)學(xué)工具類
public class MathTool {
    //求兩個(gè)數(shù)的和的二倍
    public double sum2times(int number,int number2) {
        return (number+number2)*2;
    }
    //求兩個(gè)數(shù)的積
    public double area(int number,int number2) {
        return number*number2;
    }
}

? 長方形類

public class CFX {
    //因?yàn)殚L與寬，在現(xiàn)實(shí)事物中屬于事物的一部分，所以定義成員變量
    private int chang;
    private int kuan;
    
    public CFX(int chang, int kuan) {
        this.chang = chang;
        this.kuan = kuan;
    }
    
    //求長與寬的周長
    public double zhouChang() {
        return (chang+kuan)*2;
    }
    //求長與寬的面積
    public double mianJi() {
        return chang*kuan;
    }
    public int getChang() {
        return chang;
    }
    public void setChang(int chang) {
        this.chang = chang;
    }
    public int getKuan() {
        return kuan;
    }
    public void setKuan(int kuan) {
        this.kuan = kuan;
    }
}

* A：?    類作為方法參數(shù)
    在編寫程序中，會(huì)經(jīng)常碰到調(diào)用的方法要接收的是一個(gè)類類型的情況，那么這時(shí)，要向方法中傳入該類的對象。

    如下代碼演示：
        class Person{
            public void show(){
                System.out.println("show方法執(zhí)行了");
            }
        }
        //測試類
        public class Test {
            public static void main(String[] args) {
                //創(chuàng)建Person對象
                Person p = new Person();
                //調(diào)用method方法
                method(p);
            }
            
        //定義一個(gè)方法method，用來接收一個(gè)Person對象，在方法中調(diào)用Person對象的show方法
        public static void method(Person p){
            p.show();
        }

* A: ?    抽象類作為方法參數(shù)
    今后開發(fā)中，抽象類作為方法參數(shù)的情況也很多見。當(dāng)遇到方法參數(shù)為抽象類類型時(shí)，要傳入一個(gè)實(shí)現(xiàn)抽象類所有抽象方法的子類對象。如下代碼演示：
    //抽象類
    abstract class Person{
        public abstract void show();
    }
    class Student extends Person{
        @Override
        public void show() {
            System.out.println("重寫了show方法");
        }
    }
    //測試類
    public class Test {
        public static void main(String[] args) {
            //通過多態(tài)的方式，創(chuàng)建一個(gè)Person類型的變量，而這個(gè)對象實(shí)際是Student
            Person p = new Student();
            //調(diào)用method方法
            method(p);
        }
        
        //定義一個(gè)方法method，用來接收一個(gè)Person類型對象，在方法中調(diào)用Person對象的show方法
        public static void method(Person p){//抽象類作為參數(shù)
            //通過p變量調(diào)用show方法,這時(shí)實(shí)際調(diào)用的是Student對象中的show方法
            p.show();    
    }
    }

* B:?    抽象類作為方法返回值
    抽象類作為方法返回值的情況，也是有的，這時(shí)需要返回一個(gè)實(shí)現(xiàn)抽象類所有抽象方法的子類對象。如下代碼演示：
    //抽象類
    abstract class Person{
        public abstract void show();
    }
    class Student extends Person{
        @Override
        public void show() {
            System.out.println("重寫了show方法");
        }
    }
    //測試類
    public class Test {
        public static void main(String[] args) {
            //調(diào)用method方法，獲取返回的Person對象
            Person p = method();
            //通過p變量調(diào)用show方法,這時(shí)實(shí)際調(diào)用的是Student對象中的show方法
            p.show();
        }
        
        //定義一個(gè)方法method，用來獲取一個(gè)Person對象，在方法中完成Person對象的創(chuàng)建
        public static Person method(){
            Person p = new Student();
            return p;
        }
    }

    

* A: ?    接口作為方法參數(shù)
    接口作為方法參數(shù)的情況是很常見的，經(jīng)常會(huì)碰到。當(dāng)遇到方法參數(shù)為接口類型時(shí)，那么該方法要傳入一個(gè)接口實(shí)現(xiàn)類對象。如下代碼演示。
    //接口
    interface Smoke{
        public abstract void smoking();
    }
    class Student implements Smoke{
        @Override
        public void smoking() {
            System.out.println("課下吸口煙，賽過活神仙");
        }
    }
    //測試類
    public class Test {
        public static void main(String[] args) {
            //通過多態(tài)的方式，創(chuàng)建一個(gè)Smoke類型的變量，而這個(gè)對象實(shí)際是Student
            Smoke s = new Student();
            //調(diào)用method方法
            method(s);
        }
        
        //定義一個(gè)方法method，用來接收一個(gè)Smoke類型對象，在方法中調(diào)用Smoke對象的show方法
        public static void method(Smoke sm){//接口作為參數(shù)
            //通過sm變量調(diào)用smoking方法，這時(shí)實(shí)際調(diào)用的是Student對象中的smoking方法
            sm.smoking();
        }
    }

* B:?    接口作為方法返回值
    接口作為方法返回值的情況，在后面的學(xué)習(xí)中會(huì)碰到。當(dāng)遇到方法返回值是接口類型時(shí)，那么該方法需要返回一個(gè)接口實(shí)現(xiàn)類對象。如下代碼演示。

    //接口
    interface Smoke{
        public abstract void smoking();
    }
    class Student implements Smoke{
        @Override
        public void smoking() {
            System.out.println("課下吸口煙，賽過活神仙");
        }
    }
    //測試類
    public class Test {
        public static void main(String[] args) {
            //調(diào)用method方法，獲取返回的會(huì)吸煙的對象
            Smoke s = method();
            //通過s變量調(diào)用smoking方法,這時(shí)實(shí)際調(diào)用的是Student對象中的smoking方法
            s.smoking();
        }
        
        //定義一個(gè)方法method，用來獲取一個(gè)具備吸煙功能的對象，并在方法中完成吸煙者的創(chuàng)建
        public static Smoke method(){
            Smoke sm = new Student();
            return sm;
        }
    }

    

==============================第三節(jié)課開始====================================

* A: ?    根據(jù)“某五星級(jí)酒店，資金雄厚……都有自己的工作要做。”分析出，該題        目中包含酒店，可以把它封裝成類，多名員工）。

    class 員工 {
         屬性：姓名
    屬性：工號(hào)
    方法：工作
    }
    class 廚師 extends 員工{}
    class 服務(wù)員 extends 員工{}
    class 經(jīng)理 extends 員工 {
         屬性：獎(jiǎng)金
    }

    員工的類型有經(jīng)理、廚師、服務(wù)員，它們有共同的屬性（姓名、工號(hào)、），經(jīng)理額外屬性（獎(jiǎng)金）。

    ?    根據(jù)“向酒店中，增加多名員工（其中包含1名經(jīng)理，1名廚師、2名服務(wù)員）”。分析出，要?jiǎng)?chuàng)建一個(gè)酒店對象，并添加4名員工到酒店對象的員工集合中。
    酒店員工集合添加新員工： 經(jīng)理對象
    酒店員工集合添加新員工： 廚師對象
    酒店員工集合添加新員工： 服務(wù)員對象
    酒店員工集合添加新員工： 服務(wù)員對象

    ?    根據(jù)“獲取酒店幸運(yùn)員工”。分析出，從酒店員工集合隨機(jī)得到一名員工對象。
    1. 從酒店員工集合長度范圍內(nèi)，隨機(jī)產(chǎn)生一個(gè)隨機(jī)數(shù)
    2. 使用該隨機(jī)數(shù)作為集合的索引，返回該索引處對應(yīng)的員工對象

    ?    根據(jù)“酒店開設(shè)VIP服務(wù)，酒店的廚師與服務(wù)員可以提供VIP服務(wù)。（廚師做菜加量、服務(wù)員給顧客倒酒）”。分析出，這是要增加一個(gè)VIP的接口，接口中提供個(gè)VIP服務(wù)的方法。讓廚師與服務(wù)員實(shí)現(xiàn)該接口。
    interface VIP服務(wù){(diào)
         抽象方法：服務(wù)
    }
    class 廚師 extends 員工 implements VIP服務(wù){(diào) 重寫服務(wù)方法 }
    class 服務(wù)員 extends 員工 implements VIP服務(wù){(diào) 重寫服務(wù)方法 }

B:
?    VIP服務(wù)

public interface VIP {

 public abstract void server(); //服務(wù)

}

? 員工
/*

員工：

    姓名 String
    工號(hào) String

*/

public abstract class YuanGong {

// 成員變量
private String xingMing;
private String gongHao;
// 構(gòu)造方法
public YuanGong() {
    super();
}
public YuanGong(String xingMing, String gongHao) {
    super();
    this.xingMing = xingMing;
    this.gongHao = gongHao;

}
// 抽象方法
public abstract void work();

// getters與setters
public String getXingMing() {
    return xingMing;
}
public void setXingMing(String xingMing) {
    this.xingMing = xingMing;
}
public String getGongHao() {
    return gongHao;
}
public void setGongHao(String gongHao) {
    this.gongHao = gongHao;
}

}

? 服務(wù)員
/*

定義員工的子類 服務(wù)員類
*/

public class FuWuYuan extends YuanGong implements VIP {

public FuWuYuan() {
    super();
}

public FuWuYuan(String xingMing, String gongHao) {
    super(xingMing, gongHao);
}
@Override
public void work() {
    System.out.println("親，全身心為您服務(wù)，記得給好評(píng)哦");
}
@Override
public void server() {
    System.out.println("給顧客倒酒");
}

}

? 經(jīng)理
/*

經(jīng)理在員工的基礎(chǔ)上，添加了獎(jiǎng)金成員
*/

public class JingLi extends YuanGong {

private double jiangJin;

public JingLi() {
    super();
}
public JingLi(String xingMing, String gongHao, double jiangJin) {
    super(xingMing, gongHao);
    this.jiangJin = jiangJin;
}

public double getJiangJin() {
    return jiangJin;
}
public void setJiangJin(double jiangJin) {
    this.jiangJin = jiangJin;
}

@Override
public void work() {
    System.out.println("哪個(gè)員工讓顧客不滿意，我扣誰錢");
};

}

? 廚師
/*

定義員工的子類 廚師類
*/

public class ChuShi extends YuanGong implements VIP{

public ChuShi() {
    super();
}
public ChuShi(String xingMing, String gongHao) {
    super(xingMing, gongHao);
}

@Override
public void work() {
    System.out.println("我做飯，放心吃吧，包您滿意");
}
@Override
public void server() {
    System.out.println("做菜加量加料");
}

}