Eclipse快捷鍵文檔 jar包 4、修飾符混合5、何時定義變量為成員變量 6、類、抽象類、接

tinysun1234 發(fā)布于2019-08-14 18:41 / 3488人閱讀

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

01eclipse快捷鍵

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

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

02java中的文檔注釋和制作

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

03eclipse生成jar包 04JAVA_HOME配置 05導入jar包

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

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

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

07不同修飾符使用細節(jié)

A: 常用來修飾類、方法、變量的修飾符如下：
?    public 權限修飾符，公共訪問, 類,方法,成員變量
?    protected 權限修飾符，受保護訪問, 方法,成員變量
?    默認什么也不寫 也是一種權限修飾符，默認訪問, 類,方法,成員變量
?    private 權限修飾符，私有訪問, 方法,成員變量
?    static 靜態(tài)修飾符  方法,成員變量
?    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 : 靜態(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:修飾構造方法能夠使用的修飾符：

    public : 公共的
    protected : 受保護的
        : 默認的
    private ：私有的
    使用最多的是 public

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

    ?    修飾成員方法能夠使用的修飾符：
            public : 公共的
            protected : 受保護的
                : 默認的
            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();//最常用的方式

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

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

? 長方形類

public class CFX {
    //因為長與寬，在現(xiàn)實事物中屬于事物的一部分，所以定義成員變量
    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類作為方法的參數(shù)

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

    如下代碼演示：
        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);
            }
            
        //定義一個方法method，用來接收一個Person對象，在方法中調(diào)用Person對象的show方法
        public static void method(Person p){
            p.show();
        }

09抽象類作為方法參數(shù)與返回值

* A: ?    抽象類作為方法參數(shù)
    今后開發(fā)中，抽象類作為方法參數(shù)的情況也很多見。當遇到方法參數(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)建一個Person類型的變量，而這個對象實際是Student
            Person p = new Student();
            //調(diào)用method方法
            method(p);
        }
        
        //定義一個方法method，用來接收一個Person類型對象，在方法中調(diào)用Person對象的show方法
        public static void method(Person p){//抽象類作為參數(shù)
            //通過p變量調(diào)用show方法,這時實際調(diào)用的是Student對象中的show方法
            p.show();    
    }
    }

* B:?    抽象類作為方法返回值
    抽象類作為方法返回值的情況，也是有的，這時需要返回一個實現(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方法,這時實際調(diào)用的是Student對象中的show方法
            p.show();
        }
        
        //定義一個方法method，用來獲取一個Person對象，在方法中完成Person對象的創(chuàng)建
        public static Person method(){
            Person p = new Student();
            return p;
        }
    }

10接口作為方法參數(shù)與返回值

* A: ?    接口作為方法參數(shù)
    接口作為方法參數(shù)的情況是很常見的，經(jīng)常會碰到。當遇到方法參數(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)建一個Smoke類型的變量，而這個對象實際是Student
            Smoke s = new Student();
            //調(diào)用method方法
            method(s);
        }
        
        //定義一個方法method，用來接收一個Smoke類型對象，在方法中調(diào)用Smoke對象的show方法
        public static void method(Smoke sm){//接口作為參數(shù)
            //通過sm變量調(diào)用smoking方法，這時實際調(diào)用的是Student對象中的smoking方法
            sm.smoking();
        }
    }

* B:?    接口作為方法返回值
    接口作為方法返回值的情況，在后面的學習中會碰到。當遇到方法返回值是接口類型時，那么該方法需要返回一個接口實現(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方法，獲取返回的會吸煙的對象
            Smoke s = method();
            //通過s變量調(diào)用smoking方法,這時實際調(diào)用的是Student對象中的smoking方法
            s.smoking();
        }
        
        //定義一個方法method，用來獲取一個具備吸煙功能的對象，并在方法中完成吸煙者的創(chuàng)建
        public static Smoke method(){
            Smoke sm = new Student();
            return sm;
        }
    }

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

11星級酒店案例

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

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

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

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

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

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

B:
?    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("給顧客倒酒");
}

}

? 經(jīng)理
/*

經(jī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("哪個員工讓顧客不滿意，我扣誰錢");
};

}

? 廚師
/*

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

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("做菜加量加料");
}

}

云服務器 GPU云服務器 python類修飾符類控件變量 python類變量內(nèi)部類循環(huán)變量

文章版權歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。

轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/67170.html

Java 學習筆記

摘要：參考資料程序設計北大唐大仕零基礎學語言浙大翁愷面向?qū)ο蟪绦蛟O計語言浙大翁愷在里面搜索可以查看和修改快捷鍵自動補全代碼格式化簡介歷史與一起發(fā)展萬維網(wǎng)所有信息用鏈接連接起來靜態(tài)網(wǎng)頁動態(tài)網(wǎng)頁的出現(xiàn)年開發(fā)工具包語法增加廣泛動態(tài)編譯腳本參考資料 Java程序設計 - 北大 - 唐大仕零基礎學Java語言 - 浙大 - 翁愷面向?qū)ο蟪绦蛟O計——Java語言 - 浙大 - 翁愷 Ecl...

tianlai 2019-08-16 17:03 評論0 收藏0
java學習(三) —— 面對對象

摘要：前言是面對對象的語言，因此有必要單獨紀錄下對象的各種定義和理解。面對對象基本概述概述是基于面向過程的變成思想，是對面向過程的一種封裝。面對對象開發(fā)就是不斷的創(chuàng)建對象，使用對象，指揮對象做事情。面對對象設計其實就是在管理和維護對象之間的關系。前言 java是面對對象的語言，因此有必要單獨紀錄下對象的各種定義和理解。面對對象，主要包括：面向?qū)ο笏枷?，類與對象及其使用，對象的內(nèi)存圖，成...

褰辯話 2019-08-19 11:04 評論0 收藏0
夯實基礎系列一：Java 基礎總結

摘要：可實現(xiàn)單例模式代碼塊初始化靜態(tài)變量，只被執(zhí)行一次內(nèi)部類不能與外部類重名，只能訪問外部類靜態(tài)數(shù)據(jù)包括私有多分支選擇整型或字符類型變量或整數(shù)表達式開始支持。前言大學期間接觸 Java 的時間也不短了，不論學習還是實習，都讓我發(fā)覺基礎的重要性?；ヂ?lián)網(wǎng)發(fā)展太快了，各種框架各種技術更新迭代的速度非?？欤赡苣銊偤谜莆樟艘婚T技術的應用，它卻已經(jīng)走在淘汰的邊緣了。而學習新技術總要付出一定的時間...

greatwhole 2019-08-19 11:12 評論0 收藏0
Java 抽象類、接口、內(nèi)部類

摘要：即使抽象類里不包含抽象方法，這個抽象類也不能創(chuàng)建實例抽象類可以包含成員變量方法普通方法和抽象方法構造器初始化塊內(nèi)部類接口枚舉種成分。抽象類當編寫一個類時，常常會為該類定義一些方法，這些方法用以描述該類的行為方式，那么這些方法都有具體的方法體。但在某些情況下，某個父類只是知道其子類應該包含怎樣的方法，但無法準確地知道這些子類如何實現(xiàn)這些方法。使用抽象方法即可滿足該要求：抽象方法是只有...

miguel.jiang 2019-08-14 16:52 評論0 收藏0
1、final 關鍵字 2、static 關鍵字 3、匿名對象 4、內(nèi)部類 5、包的聲明與訪問 6、

摘要：可以直接用接口名訪問。其他類也稱為外部類。汽車外部類發(fā)動機內(nèi)部類內(nèi)部類的分類內(nèi)部類分為成員內(nèi)部類與局部內(nèi)部類。我們定義內(nèi)部類時，就是一個正常定義類的過程，同樣包含各種修飾符繼承與實現(xiàn)關系等。并且日常項目的分工也是以包作為邊界。 01final關鍵字概念 * A: 概述繼承的出現(xiàn)提高了代碼的復用性，并方便開發(fā)。但隨之也有問題，有些類在描述完之后，不想被繼承， ...

鄒立鵬 2019-08-14 18:41 評論0 收藏0