14_Java面向對象_第14天（Eclipse高級、類與接口做爲參數返回值）_講義

今日內容介紹
一、Eclipse經常使用快捷鍵操做
二、Eclipse文檔註釋導出幫助文檔
三、Eclipse項目的jar包導出與使用jar包
四、不一樣修飾符混合使用細節
五、辨析什麼時候定義變量爲成員變量
六、類、抽象類、接口做爲方法參數
七、類、抽象類、接口做爲方法返回值

01eclipse快捷鍵

• A: Ctrl+T：查看所選中類的繼承樹

  例如，在下面代碼中，選中Teacher類名，而後按Ctrl+T，就會顯示出Teacher類的繼承關係

• B:查看所選中方法的源代碼

  Ctrl+滑動鼠標點擊方法名，或者選中方法名後，按F3鍵查看所選中方法的源代碼。

02java中的文檔註釋和製做

• A: 在eclipse使用時，能夠配合文檔註釋，導出對類的說明文檔，從而供其 他人閱讀學習與使用。

• 經過使用文檔註釋，將類或者方法進行註釋用@簡單標註基本信息。
    如@author 做者、@version代碼版本、@param方法參數、@return方法返回值等。

03eclipse生成jar包

04JAVA_HOME配置

05導入jar包

• A:  導入jar包：即把指定的jar包，加入到指項目中，提供給項目使用。

  導入jar包的過程是將jar包加入到項目的.classpath文件中去，讓項目識別，即可以使用jar包中全部的.class文件類。
  
    如下是加入步驟：
  
    1：項目根文件夾下建立lib文件夾，用於同一管理全部的jar文件
    2：把jar文件複製到lib文件夾中
    3：右鍵點擊jar文件，點擊Build Path，選擇Add to Build Path，此時查
    看項目根文件夾下的.classpath文件，發現新加入的jar包路徑被配置到了該文件中。
    說明可使用jar包中全部類了。

  注意：

  Jar包加入後，必須Add to Build Path才能使用
    Jar包加入後，加入的類也必須導包，若是加入的類其包名與現有類包名相同，則視做在同一個包下。(不常見)

07不一樣修飾符使用細節

A: 經常使用來修飾類、方法、變量的修飾符以下：
           public 權限修飾符，公共訪問, 類,方法,成員變量
           protected 權限修飾符，受保護訪問, 方法,成員變量
           默認什麼也不寫 也是一種權限修飾符，默認訪問, 類,方法,成員變量
           private 權限修飾符，私有訪問, 方法,成員變量
           static 靜態修飾符  方法,成員變量
           final 最終修飾符   類,方法,成員變量,局部變量
           abstract 抽象修飾符  類 ,方法

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

C: 修飾類可以使用的修飾符：
        修飾類只能使用public、默認的、final、abstract關鍵字
        使用最多的是 public關鍵字

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

D:修飾成員變量可以使用的修飾符：
        public : 公共的
        protected : 受保護的
            : 默認的
        private ：私有的
        final : 最終的
        static : 靜態的
        使用最多的是 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:修飾構造方法可以使用的修飾符：
        public : 公共的
        protected : 受保護的
            : 默認的
        private ：私有的
        使用最多的是 public

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

            修飾成員方法可以使用的修飾符：
                public : 公共的
                protected : 受保護的
                    : 默認的
                private ：私有的
                final : 最終的
                static : 靜態的
                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();//最經常使用的方式

07局部變量和成員變量解析

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

長方形類
public class CFX {
    //由於長與寬，在現實事物中屬於事物的一部分，因此定義成員變量
    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;
    }
}

08類做爲方法的參數

* A：    類做爲方法參數
    在編寫程序中，會常常碰到調用的方法要接收的是一個類類型的狀況，那麼這時，要向方法中傳入該類的對象。

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

09抽象類做爲方法參數與返回值

* A:    抽象類做爲方法參數
    從此開發中，抽象類做爲方法參數的狀況也不少見。當遇到方法參數爲抽象類類型時，要傳入一個實現抽象類全部抽象方法的子類對象。以下代碼演示：
    //抽象類
    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) {
            //經過多態的方式，建立一個Person類型的變量，而這個對象實際是Student
            Person p = new Student();
            //調用method方法
            method(p);
        }
        
        //定義一個方法method，用來接收一個Person類型對象，在方法中調用Person對象的show方法
        public static void method(Person p){//抽象類做爲參數
            //經過p變量調用show方法,這時實際調用的是Student對象中的show方法
            p.show();   
    }
    }


* B:   抽象類做爲方法返回值
    抽象類做爲方法返回值的狀況，也是有的，這時須要返回一個實現抽象類全部抽象方法的子類對象。以下代碼演示：
    //抽象類
    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) {
            //調用method方法，獲取返回的Person對象
            Person p = method();
            //經過p變量調用show方法,這時實際調用的是Student對象中的show方法
            p.show();
        }
        
        //定義一個方法method，用來獲取一個Person對象，在方法中完成Person對象的建立
        public static Person method(){
            Person p = new Student();
            return p;
        }
    }

10接口做爲方法參數與返回值

* A:   接口做爲方法參數
    接口做爲方法參數的狀況是很常見的，常常會碰到。當遇到方法參數爲接口類型時，
    那麼該方法要傳入一個接口實現類對象。以下代碼演示。
    //接口
    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) {
            //經過多態的方式，建立一個Smoke類型的變量，而這個對象實際是Student
            Smoke s = new Student();
            //調用method方法
            method(s);
        }
        
        //定義一個方法method，用來接收一個Smoke類型對象，在方法中調用Smoke對象的show方法
        public static void method(Smoke sm){//接口做爲參數
            //經過sm變量調用smoking方法，這時實際調用的是Student對象中的smoking方法
            sm.smoking();
        }
    }

* B:   接口做爲方法返回值
    接口做爲方法返回值的狀況，在後面的學習中會碰到。當遇到方法返回值是接口類型時，
    那麼該方法須要返回一個接口實現類對象。以下代碼演示。

    //接口
    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) {
            //調用method方法，獲取返回的會吸菸的對象
            Smoke s = method();
            //經過s變量調用smoking方法,這時實際調用的是Student對象中的smoking方法
            s.smoking();
        }
        
        //定義一個方法method，用來獲取一個具有吸菸功能的對象，並在方法中完成吸菸者的建立
        public static Smoke method(){
            Smoke sm = new Student();
            return sm;
        }
    }

11星級酒店案例

* A: 根據「某五星級酒店，資金雄厚……都有本身的工做要作。」分析出，該題      目中包含酒店，能夠把它封裝成類，多名員工）。

        class 員工 {
             屬性：姓名
        屬性：工號
        方法：工做
        }
        class 廚師 extends 員工{}
        class 服務員 extends 員工{}
        class 經理 extends 員工 {
             屬性：獎金
        }

        員工的類型有經理、廚師、服務員，它們有共同的屬性（姓名、工號、），經理額外屬性（獎金）。

       根據「向酒店中，增長多名員工（其中包含1名經理，1名廚師、2名服務員）」。
    分析出，要建立一個酒店對象，並添加4名員工到酒店對象的員工集合中。
        酒店員工集合添加新員工： 經理對象
        酒店員工集合添加新員工： 廚師對象
        酒店員工集合添加新員工： 服務員對象
        酒店員工集合添加新員工： 服務員對象

       根據「獲取酒店幸運員工」。分析出，從酒店員工集合隨機獲得一名員工對象。
        1. 從酒店員工集合長度範圍內，隨機產生一個隨機數
        2. 使用該隨機數做爲集合的索引，返回該索引處對應的員工對象

       根據「酒店開設VIP服務，酒店的廚師與服務員能夠提供VIP服務。
        （廚師作菜加量、服務員給顧客倒酒）」。分析出，這是要增長一個VIP的接口，
            接口中提供個VIP服務的方法。讓廚師與服務員實現該接口。
        interface VIP服務{
             抽象方法：服務
        }
        class 廚師 extends 員工 implements VIP服務{ 重寫服務方法 }
        class 服務員 extends 員工 implements VIP服務{ 重寫服務方法 }

實現代碼步驟

VIP服務

public interface VIP {
     public abstract void server(); //服務
}

員工

/*
 *  員工：
         姓名 String
         工號 String
    
 */
public abstract class YuanGong {
    // 成員變量
    private String xingMing;
    private String gongHao;
    // 構造方法
    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;
    }
    
}

服務員

/*
 * 定義員工的子類 服務員類
 */
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("親，全身心爲您服務，記得給好評哦");
    }
    @Override
    public void server() {
        System.out.println("給顧客倒酒");
    }
}

經理

/*
 * 經理在員工的基礎上，添加了獎金成員
 */
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("哪一個員工讓顧客不滿意，我扣誰錢");
    };
}

廚師

/*
 * 定義員工的子類 廚師類
 */
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("作菜加量加料");
    }
}