14_Java面向物件_第14天（Eclipse高階、類與介面作為引數返回值）_講義

阿新 • • 發佈：2018-12-19

今日內容介紹 1、Eclipse常用快捷鍵操作 2、Eclipse文件註釋匯出幫助文件 3、Eclipse專案的jar包匯出與使用jar包 4、不同修飾符混合使用細節 5、辨析何時定義變數為成員變數 6、類、抽象類、介面作為方法引數 7、類、抽象類、介面作為方法返回值 01eclipse快捷鍵 A: Ctrl+T：檢視所選中類的繼承樹例如，在下面程式碼中，選中Teacher類名，然後按Ctrl+T，就會顯示出Teacher類的繼承關係 B:檢視所選中方法的原始碼 Ctrl+滑動滑鼠點選方法名，或者選中方法名後，按F3鍵檢視所選中方法的原始碼。

package cn.itcast.demo01;
//ctrl+T 方便快速確定一個類的繼承關係
public abstract class Employee {
	public abstract void work();
}

package cn.itcast.demo01;

public class JavaEE extends Employee {
	public void work(){
		System.out.println("haha");
	}
}

package cn.itcast.demo01;

public class Test {

	public static void main(String[] args) {
		JavaEE ee = new JavaEE();
		//Ctrl+滑動滑鼠點選類名，或者選中類名後，按F3鍵檢視所選中類的原始碼。
		ee.work();
	}

}

在這裡插入圖片描述

02java中的文件註釋和製作 A: 在eclipse使用時，可以配合文件註釋，匯出對類的說明文件，從而供其他人閱讀學習與使用。

  通過使用文件註釋，將類或者方法進行註釋用@簡單標註基本資訊。
  如@author 作者、@version程式碼版本、@param方法引數、@return方法返回值等。

在eclipse使用時，可以配合文件註釋，匯出對類的說明文件，從而供其他人閱讀學習與使用。通過使用文件註釋，將類或者方法進行註釋用@簡單標註基本資訊。如@author 作者、@version程式碼版本、@param方法引數、@return方法返回值等。使用Eclipse匯出javadoc文件即可，操作步驟如下圖：在這裡插入圖片描述

03eclipse生成jar包 jar包是一個可以包含許多.class檔案的壓縮檔案。我們可以將一個jar包加入到專案的依賴中，從而該專案可以使用該jar下的所有類；也可以把專案中所有的類打包到指定的jar包，提供給其他專案使用。  匯出jar包：即把專案中所有類，打包到指定的jar包中，步驟如下圖：在這裡插入圖片描述

 匯入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包加入後，加入的類也必須導包，如果加入的類其包名與現有類包名相同，則視作在同一個包下。(不常見)

import cn.itcast.sum.*;
/*
	設定環境變數:classpath告知JVM,去哪個路徑下找到執行的class檔案
	set classpath
*/
public class Test{
	
	public static void main(String[] args){
		//呼叫GetSum類方法getSum求和計算
		int sum = GetSum.getSum(1,2);
		System.out.println(sum);
	}
	
}

在這裡插入圖片描述 04JAVA_HOME配置檢查是否環境配置成功第2章面向物件 2.1 不同修飾符使用細節常用來修飾類、方法、變數的修飾符如下：  public 許可權修飾符，公共訪問, 類,方法,成員變數  protected 許可權修飾符，受保護訪問, 方法,成員變數  預設什麼也不寫也是一種許可權修飾符，預設訪問, 類,方法,成員變數  private 許可權修飾符，私有訪問, 方法,成員變數  static 靜態修飾符方法,成員變數  final 最終修飾符類,方法,成員變數,區域性變數  abstract 抽象修飾符類 ,方法

我們編寫程式時，許可權修飾符一般放於所有修飾符之前，不同的許可權修飾符不能同時使用；同時，abstract與private不能同時使用；同時，abstract(抽象類沒有主體)與static(而類名直接呼叫,矛盾)不能同時使用；同時，abstract(需要繼承重寫)與final(不給重寫)不能同時使用。  修飾類能夠使用的修飾符：修飾類只能使用public、預設的、final、abstract關鍵字使用最多的是 public關鍵字

public class Demo {} //最常用的方式
class Demo2{}
public final class Demo3{}
public abstract class Demo4{}

 修飾成員變數能夠使用的修飾符： public : 公共的 protected : 受保護的 : 預設的 private ：私有的 final : 最終的 static : 靜態的使用最多的是 private

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;

 修飾構造方法能夠使用的修飾符： public : 公共的 protected : 受保護的 : 預設的 private ：私有的使用最多的是 public

	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();//最常用的方式

第3章自定義資料型別的使用 3.1 辨析成員變數與方法引數的設計定義  定義長方形類，包含求周長與求面積的方法  定義數學工具類，包含求兩個數和的二倍與求兩個數積的方法思考：這兩個類的計算方法均需要兩個數參與計算，請問兩個數定義在成員位置還是形參位置更好，為什麼？如果變數是該類的一部分時，定義成成員變數。如果變數不應該是類的一部分，而僅僅是功能當中需要參與計算的數，則定義為形參變數。  數學工具類

package cn.itcast.demo02;
/*
 * 定義數學工具類，包含求兩個數和的二倍與求兩個數積的方法
 */
public class MathTools {
	//沒有使用非靜態變數,直接可以類名呼叫,用靜態方法
	//求兩個數的和的二倍
	public static double sum2times(int number,int number2) {
		return (number+number2)*2;
	}
	//求兩個數的積
	public static double area(int number,int number2) {
		return number*number2;
	}
}

public class MathTool {
	//求兩個數的和的二倍
	public double sum2times(int number,int number2) {
		return (number+number2)*2;
	}
	//求兩個數的積
	public double area(int number,int number2) {
		return number*number2;
	}
}

 長方形類

package cn.itcast.demo02;
/*3.1	辨析成員變數與方法引數的設計定義
 * 定義長方形類，包含求周長與求面積的方法
 * 定義長方形類
 * 	計算面積,周長
 * 邊長,設計的時候,定義為成員變數,兩個計算方法的區域性變數
 * 屬於誰的,屬於長方形事物,每個獨立計算的功能
 * new CXF(10,8)
 */
public class CXF {
	//因為長與寬，在現實事物中屬於事物的一部分，所以定義成員變數
	private int w;
	private int h;
	
	public CXF(int w,int h){
		this.w = w;
		this.h = h;
	}
	public int getArea(){
		return w*h;
	}
	public int getLong(){
		return 2*(w+h);
	}
}

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;
	}
}

3.2 類作為方法引數與返回值  類作為方法引數在編寫程式中，會經常碰到呼叫的方法要接收的是一個類型別的情況，那麼這時，要向方法中傳入該類的物件。如下程式碼演示：

package cn.itcast.classes;

public class Person {
	private String name = "張三";
	public void eat(){
		System.out.println(name + "在吃飯");
	}
}

package cn.itcast.classes;
//類作為方法引數
public class TestArguments {

	public static void main(String[] args) {
		//呼叫方法operatorPerson,看後續還需要使用,就用傳遞Person型別物件
		Person p = new Person();
		operatorPerson(p);
		//傳遞匿名物件(只能用一次),絕不會出現問題
		operatorPerson(new Person());
	}
	/*
	 * 方法operatorPerson,引數型別Person型別
	 * 呼叫方法operatorPerson,必須傳遞Person型別的物件
	 */
	public static void operatorPerson(Person p){
		//可以使用引用資料型別p呼叫Person類的功能
		p.eat();
	}
}

在這裡插入圖片描述

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();
	}
}

 類作為方法返回值寫程式呼叫方法時，我們以後會經常碰到返回一個類型別的返回值，那麼這時，該方法要返回一個該類的物件。如下程式碼演示：

package cn.itcast.classes;
/*類作為方法返回值
 * 定義類,方法返回Person的型別
 */
public class GetPerson {
	/*
	 * 方法返回值是Person型別
	 * 方法的return語句後面一定是Person型別的物件
	 * 方法裡面需要：new
	 */
	public Person get(){
		Person p = new Person();
		return p;
	}
}

package cn.itcast.classes;

public class TestReturn {

	public static void main(String[] args) {
		//呼叫GetPerson型別的方法get
		//返回值是Person型別
		GetPerson get = new GetPerson();
		Person p = get.get();
		p.eat();
		//方法呼叫鏈條
		new GetPerson().get().eat();
	}

}

在這裡插入圖片描述

class Person{
	public void show(){
		System.out.println("show方法執行了");
	}
}
//測試類
public class Test {
	public static void main(String[] args) {
		//呼叫method方法，獲取返回的Person物件
		Person p = method();
		//呼叫p物件中的show方法
		p.show();
	}
	
	//定義一個方法method，用來獲取一個Person物件，在方法中完成Person物件的建立
	public static Person method(){
		Person p = new Person();
		return p;
	}
}

3.3 抽象類作為方法引數與返回值  抽象類作為方法引數今後開發中，抽象類作為方法引數的情況也很多見。當遇到方法引數為抽象類型別時，要傳入一個實現抽象類所有抽象方法的子類物件。如下程式碼演示：

package cn.itcast.abstractclass;
/*
 * 將抽象類型別,作為方法引數的傳遞
 */
public abstract class Animal {
	public abstract void eat();
}

package cn.itcast.abstractclass;

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("小貓吃魚");
	}

}

package cn.itcast.abstractclass;

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("狗吃骨頭");
	}

}

package cn.itcast.abstractclass;
/*
 * 將抽象類型別,作為方法引數的傳遞
 */
public class TestAnimal {
	public static void main(String[] args) {
		//呼叫operatorAnimal,傳遞子類物件
		Cat c = new Cat();
		operatorAnimal(c);
		//呼叫operatorAnimal,傳遞子類的匿名物件
		operatorAnimal(new Dog());
	}
	/*
	 * 方法operatorAnimal,引數是一個抽象類
	 * 呼叫方法,傳遞Animal型別物件,Animal抽象類沒有物件
	 * 只能傳遞Animal類的子類的物件(多型)
	 * 可以傳遞Animal的任意子類物件(多型的魅力,讓程式的擴充套件性增強)
	 */
	public static void operatorAnimal(Animal a){
		//引用變數a,呼叫方法eat
		a.eat();//執行的是子類的內容
	}
}

在這裡插入圖片描述

//抽象類
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();	
}
}

 抽象類作為方法返回值抽象類作為方法返回值的情況，也是有的，這時需要返回一個實現抽象類所有抽象方法的子類物件。如下程式碼演示：

package cn.itcast.abstractclass;

public class GetAnimal {
	/*
	 * 定義方法,方法的返回值是Animal型別
	 * 抽象類,抽象類沒有物件,因此在方法的return後,返回Animal的子類物件
	 */
	//屬於多型,提高系統的擴充套件性,一個方法,可以返回多個Animal子類物件
	public Animal getAnimal(int i){
		if(0 == i)
			return new Cat();
		return new Dog();
	}
	public Animal getAnimal1(){
		return new Dog();
	}
}

package cn.itcast.abstractclass;

public class TestReturn {

	public static void main(String[] args) {
		//呼叫GetAnimal類的方法,getAnimal,返回值是Animal
		GetAnimal g = new GetAnimal();
		//大到小,需要強制轉換
		//用Cat接受,需要強轉,因為方法的返回值是Animal型別
		//Cat c = (Cat) g.getAnimal();//方法的返回值Animal型別,實際返回的Cat的物件(new Cat)
		//屬於多型,提高系統的擴充套件性
		Animal a = g.getAnimal(0);
		a.eat();
		Animal b = g.getAnimal1();
		b.eat();
	}

}

在這裡插入圖片描述

//抽象類
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;
	}
}

3.4 介面作為方法引數與返回值  介面作為方法引數介面作為方法引數的情況是很常見的，經常會碰到。當遇到方法引數為介面型別時，那麼該方法要傳入一個介面實現類物件。如下程式碼演示。

package cn.itcast.interfaces;

public interface Smoking {
	public static final int A = 1;
	public abstract void smoking();
}

package cn.itcast.interfaces;

public class Student implements Smoking {

	@Override
	public void smoking() {
		System.out.println("學生不要吸菸");
	}

}

package cn.itcast.interfaces;
//介面作為方法引數
public class TestAruguments {
	public static void main(String[] args) {
		//呼叫noSmoking方法,傳遞實現類的物件
		//實現類物件是自己的物件
		Student s = new Student();
		noSmoking(s);
		//呼叫匿名物件
		noSmoking(new Student());
		//多型性的呼叫
		//實現類物件,是採用多型創建出來的
		Smoking sm = new Student();
		noSmoking(sm);
	}
	/*
	 * 定義方法,方法引數,介面型別
	 * 方法的引數是Smoking的介面型別
	 * 呼叫方法,必須是傳遞介面的任意的實現類的物件
	 */
	public static void noSmoking(Smoking s){
		//呼叫介面中的常量A
		System.out.println(Smoking.A);
		//介面的引用變數s,呼叫方法
		s.smoking();
	}
}

在這裡插入圖片描述

//介面
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();
	}
}

 介面作為方法返回值介面作為方法返回值的情況，在後面的學習中會碰到。當遇到方法返回值是介面型別時，那麼該方法需要返回一個介面實現類物件。如下程式碼演示。

package cn.itcast.interfaces;

public class GetSmoking {
	/*
	 * 定義方法,方法的返回值是介面型別
	 * 介面是不能建立物件,return語句後面返回的是他實現類的物件
	 */
	public Smoking getSmoking(){
		return new Student();
	}
}

package cn.itcast.interfaces;

public class TestReturn {
	public static void main(String[] args) {
		//呼叫GetSmoking類的方法,getSmoking獲取Smoking介面的實現類的物件
		GetSmoking g = new GetSmoking();
		Smoking s = g.getSmoking();//方法的執行結果是介面的實現類物件new Student()
		s.smoking();
	}
}

在這裡插入圖片描述

//介面
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;
	}
}

第4章星級酒店案例 4.1 案例介紹某五星級酒店，資金雄厚，要招聘多名員工（經理、廚師、服務員）。入職的員工需要記錄個人資訊（姓名、工號、經理特有獎金屬性）。他們都有自己的工作要做。本案例要完成如下需求：  獲取酒店幸運員工；  酒店開設VIP服務，酒店的廚師與服務員可以提供VIP服務。（廚師做菜加量、服務員給顧客倒酒）。  編寫測試類  向酒店中，增加多名員工（其中包含1名經理，1名廚師、2名服務員）；  呼叫酒店員工的工作功能  呼叫酒店員工的VIP服務功能

4.2 案例需求分析  根據“某五星級酒店，資金雄厚……都有自己的工作要做。”分析出，該題目中包含酒店，可以把它封裝成類，多名員工）。

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服務{ 重寫服務方法 }

4.3 實現程式碼步驟在這裡插入圖片描述

package cn.itcast.hotel;

public interface VIP {
	public abstract void service();
}

package cn.itcast.hotel;
/*
 * 抽象類：員工類
 * 屬性：姓名
 * 屬性：工號
 * 方法：工作
 */
public abstract class YuanGong {
	private String name;
	private String id;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	//無參構造方法
	public YuanGong() {
	}
	//滿參構造方法
	public YuanGong(String name,String id){
		this.id = id;
		this.name = name;
	}
	public abstract void work();
}

package cn.itcast.hotel;

public class ChuShi extends YuanGong implements VIP {
	//無參構造方法
	public ChuShi() {		
	}
	//滿參構造方法
	public ChuShi(String name, String id) {
		super(name, id);	
	}

	@Override
	public void service() {
		System.out.println("給VIP加菜");
	}

	@Override
	public void work() {
		System.out.println("做菜");
	}

}

package cn.itcast.hotel;
/*
 * 服務員類
 */
public class FuWuYuan extends YuanGong implements VIP {
	
	@Override
	public void service() {
		System.out.println("給VIP倒酒");
	}
	//無參構造方法
	public FuWuYuan() {	
	}
	//滿參構造方法
	public FuWuYuan(String name, String id) {
		super(name, id);	
	}

	@Override
	public void work() {
		System.out.println("上菜");
	}

}

package cn.itcast.hotel;
/*
 * 經理類
 */
public class JingLi extends YuanGong {
	private double wage;
	
	public double getWage() {
		return wage;
	}
	
	public void setWage(double wage) {
		this.wage = wage;
	}
	//無參構造方法
	public JingLi() {
		
	}
	//滿參構造方法
	public JingLi(String name, String id,double wage) {
		super(name, id);
		this.wage = wage;
	}

	@Override
	public void work() {
		System.out.println("看誰不幹活,罰款");
	}
	
	public void haveWage(){
		System.out.println("經理工資：" + wage);
	}
}

package cn.itcast.hotel;

public class TestHotel {

	public static void main(String[] args) {
		//測試類,新增一個廚師,服務員,經理
		JingLi j1 = new JingLi("王大哥","董事會001",122356.25);
		j1.haveWage();
		j1.work();
		
		ChuShi c1 = new ChuShi();
		c1.work();
		c1.service();
		
		FuWuYuan f1 = new FuWuYuan();
		f1.work();
		f1.service();				
	}
}

在這裡插入圖片描述第5章總結 5.1 知識點總結  不同修飾符的使用  類，最常使用public修飾  成員變數，最常使用private修飾  成員方法，最常使用public修飾  自定義資料型別的使用  類作為方法引數時，說明要向方法中傳入該類的物件  類作為方法返回值時，說明該方法要返回一個該類的物件。  抽象類作為方法引數時，說明要傳入一個實現抽象類所有抽象方法的子類物件。  抽象類作為方法返回值時，說明需要返回一個實現抽象類所有抽象方法的子類物件。  介面作為方法引數時，說明該方法要傳入一個介面實現類物件。  介面作為方法返回值時，說明該方法需要返回一個介面實現類物件。

14_Java面向物件_第14天（Eclipse高階、類與介面作為引數返回值）_講義

14_Java面向物件_第14天（Eclipse高階、類與介面作為引數返回值）_講義

11_Java面向對象_第11天（接口、多態）_講義

12_Java面向對象_第12天（構造方法、this、super）_講義

02_Java基礎_第2天（變量、運算符）_講義

08_Java基礎語法_第8天（Eclipse）

11_Java面向物件_第11天（介面、多型）_講義

13_Java面向物件_第13天（static、final、匿名物件、內部類、包、修飾符、程式碼塊）_講義

09_Java面向對象_第9天（類、封裝）

10_Java面向對象_第10天（繼承、抽象類）

13_Java面向對象_第13天（static、final、匿名對象、內部類、包、修飾符、代碼塊）

04_Java基礎語法_第4天（數組）_講義

19_集合_第19天（List、Set）_講義

20_集合_第20天（Map、可變參數、Collections）_講義

29_Java_數據庫_第29天（JDBC、DBUtils）_講義

20_集合_第20天（Map、可變引數、Collections）_講義

03_Java基礎語法_第3天（Scanner、Random、流程控制語句）

05_Java基礎語法_第5天（方法）

21_異常_第21天（異常、企業面試題，思維導圖下載）

Python全棧開發記錄_第八篇（模組收尾工作 json & pickle & shelve & xml）

JAVA面向物件程式設計——描述一個人類（有姓名、年齡、生日等屬性），並繼承出子類

14_Java面向物件_第14天（Eclipse高階、類與介面作為引數返回值）_講義

相關推薦