JavaSE学习总结第08天_面向对象3
08.01 工具類中使用靜態
例:
1 class ArrayTool2 {3 //將構造方法私有，外界不能創建該類的對象4 private ArrayTool(){}5 //遍歷數組6 public static void print(int[] arr)7 {8 System.out.print("[");9 for(int i = 0;i < arr.length;i++) 10 { 11 if(i == arr.length-1) 12 { 13 System.out.print(arr[i]+"]"); 14 } 15 else 16 System.out.print(arr[i]+","); 17 } 18 System.out.println(); 19 } 20 } 21 22 class Demo 23 { 24 public static void main(String[] args) 25 { 26 int[] arr = {23,53,12,27,32,85,25}; 27 //通過類名直接調用 28 ArrayTool.print(arr); 29 } 30 } 31運行結果:
[23,53,12,27,32,85,25]08.02 工具類的完善
1 class ArrayTool2 {3 //將構造方法私有，外界不能創建該類的對象4 private ArrayTool(){}5 //遍歷數組6 public static void print(int[] arr)7 {8 System.out.print("[");9 for(int i = 0;i < arr.length;i++) 10 { 11 if(i == arr.length-1) 12 { 13 System.out.print(arr[i]+"]"); 14 } 15 else 16 System.out.print(arr[i]+","); 17 } 18 System.out.println(); 19 } 20 //獲取數組中的最大值 21 public static int getMax(int[] arr) 22 { 23 int max = arr[0]; 24 for(int i = 1;i < arr.length;i++) 25 { 26 if(arr[i] > max) 27 max = arr[i]; 28 } 29 return max; 30 } 31 //獲取數組中的元素第1次出現的位置 32 public static int getIndex(int[] arr,int key) 33 { 34 for(int i = 0;i< arr.length;i++) 35 { 36 if(arr[i] == key) 37 return i; 38 } 39 return -1; 40 } 41 } 42 43 class Demo 44 { 45 public static void main(String[] args) 46 { 47 int[] arr = {23,53,12,27,32,85,25}; 48 ArrayTool.print(arr); 49 System.out.println("最大值是:"+ArrayTool.getMax(arr)); 50 System.out.println("位置:"+ArrayTool.getIndex(arr,12)); 51 } 52 }運行結果:
[23,53,12,27,32,85,25] 最大值是:85 位置:208.03 說明書的制作過程
第1步:寫一個工具類
第2步:在工具類中使用JAVA中特有的注釋符/** */對代碼進行注釋
第3步:使用javadoc命令創建幫助文檔
格式:javadoc -d 目錄 -author -version ArrayTool.java
解釋:
-d:輸出文件的目標目錄
目錄:幫助文檔存放的路徑
-author:包含的-author信息
-version:包含的-version信息
ArrayTool.java:需要生成幫助文檔的JAVA源文件
注意:類必須是公共或受保護的才可以文檔化，否則，將報以下錯誤
第4步:執行javadoc命令后會創建一個文件夾，文件夾里就是幫助文檔的網頁文件，點擊index.html即可查看所有的注釋文檔
例:
1 /**2 * 這是對數組進行操作的工具類3 * @author ZHY4 * @version V1.05 */6 public class ArrayTool7 {8 //將構造方法私有，外界不能創建該類的對象9 private ArrayTool(){} 10 /** 11 * 這是遍歷數組的方法，遍歷后的格式是:[元素1,元素2,元素3...] 12 * @param arr 需要被遍歷的數組 13 */ 14 public static void print(int[] arr) 15 { 16 System.out.print("["); 17 for(int i = 0;i < arr.length;i++) 18 { 19 if(i == arr.length-1) 20 { 21 System.out.print(arr[i]+"]"); 22 } 23 else 24 System.out.print(arr[i]+","); 25 } 26 System.out.println(); 27 } 28 /** 29 * 這是獲取數組中的最大值的方法 30 * @param arr 需要被遍歷的數組 31 * @return 返回數組中的最大值 32 */ 33 public static int getMax(int[] arr) 34 { 35 int max = arr[0]; 36 for(int i = 1;i < arr.length;i++) 37 { 38 if(arr[i] > max) 39 max = arr[i]; 40 } 41 return max; 42 } 43 /** 44 * 這是獲取數組中指定元素第1次出現的位置的方法 45 * @param arr 需要被查找的數組 46 * @param key 需要被查找的元素 47 * @return 返回元素第1次出現的位置，不存在則返回-1 48 */ 49 // 50 public static int getIndex(int[] arr,int key) 51 { 52 for(int i = 0;i< arr.length;i++) 53 { 54 if(arr[i] == key) 55 return i; 56 } 57 return -1; 58 } 59 }08.04 工具類配合說明書的使用
注意:如果測試類與工具類的class文件不在同一個目錄，需要設置classpath路徑
08.05 如何使用JDK提供的幫助文檔
1:找到文檔，打開文檔。
2:點擊左上角的顯示變成隱藏，然后點擊索引
3:在輸入框里面輸入要找的類，然后回車。
4:看這個類的結:如果是java.lang包下的類，是可以直接使用的。否則，就需要導包才能使用。
5:看看這個類的說明以及該類的版本。
6:看這個類的結構(需不需要導包)
類的? 成員變量? 對應API的? 字段摘要
類的? 構造方法? 對應API的? 構造方法摘要
類的? 成員方法? 對應API的? 方法摘要
7:看構造方法
?? A:有構造方法，那么，就通過構造方法創建對象使用。
?? B:沒有構造方法，那么，這個類的成員一般都是靜態。通過類名調用。
8:看成員方法
?? 左邊:
?? ?? 是否靜態:如果靜態修飾，那么可以通過類名調用。否則，就必須創建對象調用。
?? ?? 是否有明確返回值:如果是void類型，就直接調用即可。否則，就可以輸出或者賦值。
?? 右邊:
?? ?? 看方法名:不要寫錯了。
?? ?? 看參數:看參數類型及個數。
08.06 通過JDK的幫助文檔學習Math類的隨機數功能
Math類概述:Math包含用于執行基本數學運算的方法，如初等指數、對數、平方根和三角函數。
Math類特點:沒有構造方法，因為成員都是靜態的
Math類的一個方法:獲取隨機數
public static double random():返回帶正號的 double 值，該值大于等于 0.0 且小于 1.0。
例1:System.out.println(Math.random());
運行結果:0.7751943866930362
例2:獲取1~100之間的隨機數
int num = (int)(Math.random()*100)+1;
System.out.println(num);
運行結果:
86
08.07 猜數字小游戲案例
1 import java.util.Scanner;2 class Demo3 {4 public static void main(String[] args)5 {6 int num = (int)(Math.random()*100)+1;7 //記錄猜的次數8 int count = 1;9 Scanner sc = new Scanner(System.in); 10 System.out.println("請輸入一個數:"); 11 int guess = sc.nextInt(); 12 while(guess != num) 13 { 14 if(guess > 100 || guess < 1) 15 { 16 System.out.println("數據只能在1~100之間，請重新輸入:"); 17 guess = sc.nextInt(); 18 } 19 else if(guess > num) 20 { 21 System.out.print("你猜的數"+guess+"大了，"); 22 count++; 23 System.out.println("進行第"+count+"次猜數:"); 24 guess = sc.nextInt(); 25 } 26 else 27 { 28 System.out.print("你猜的數"+guess+"小了，"); 29 count++; 30 System.out.println("進行第"+count+"次猜數:"); 31 guess = sc.nextInt(); 32 } 33 } 34 System.out.println("恭喜你，猜對了，用了"+count+"次機會"); 35 } 36 }運行結果:
?
?
?
?
?
?
?
?
08.08 代碼塊的概述和分類
代碼塊:在Java中，使用{}括起來的代碼被稱為代碼塊，根據其位置和聲明的不同，可以分為局部代碼塊，構造代碼塊，靜態代碼塊，同步代碼塊(多線程部分)。
局部代碼塊:在方法中出現；限定變量生命周期，及早釋放，提高內存利用率
構造代碼塊:在類中方法外出現；多個構造方法方法中相同的代碼存放到一起，每次調用構造都執行，并且在構造方法前執行
靜態代碼塊:在類中方法外出現，加了static修飾在類中方法外出現，并加上static修飾；用于給類進行初始化，在加載的時候就執行，并且值執行一次。
例:
1 class Code2 {3 static4 {5 int x = 10;6 System.out.println("靜態代碼塊，x="+x);7 }8 //構造代碼塊9 { 10 int y = 10; 11 System.out.println("構造代碼塊，y="+y); 12 } 13 //構造方法 14 public Code() 15 { 16 System.out.println("構造方法"); 17 } 18 } 19 class Demo 20 { 21 public static void main(String[] args) 22 { 23 new Code(); 24 //局部代碼塊 25 { 26 int z = 20; 27 System.out.println("局部代碼塊，z="+z); 28 } 29 new Code(); 30 } 31 }運行結果:
靜態代碼塊，x=10 構造代碼塊，y=10 構造方法 局部代碼塊，z=20 構造代碼塊，y=10 構造方法總結:
執行順序:靜態代碼塊>構造代碼塊>構造方法
靜態代碼塊:只執行一次
構造代碼塊:每次調用構造方法都執行
08.09 代碼塊看程序寫結果
1 class Student 2 {3 static 4 {5 System.out.println("Student 靜態代碼塊");6 }7 8 {9 System.out.println("Student 構造代碼塊"); 10 } 11 public Student() 12 { 13 System.out.println("Student 構造方法"); 14 } 15 } 16 class Demo 17 { 18 static 19 { 20 System.out.println("Demo 靜態代碼塊"); 21 } 22 public static void main(String[] args) 23 { 24 System.out.println("main方法"); 25 Student s1 = new Student(); 26 Student s2 = new Student(); 27 } 28 }運行結果:
Demo 靜態代碼塊 main方法 Student 靜態代碼塊 Student 構造代碼塊 Student 構造方法 Student 構造代碼塊 Student 構造方法08.10 繼承的引入和概述
繼承概述:多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中，那么多個類無需再定義這些屬性和行為，只要繼承那個類即可。
通過extends關鍵字可以實現類與類的繼承:class 子類名 extends 父類名 {}?
單獨的這個類稱為父類，基類或者超類；這多個類可以稱為子類或者派生類。
有了繼承以后，我們定義一個類的時候，可以在一個已經存在的類的基礎上，還可以定義自己的新成員。
08.11 繼承案例和繼承的好處
例:
1 class Person 2 {3 public void eat()4 {5 System.out.println("吃飯");6 }7 public void sleep()8 {9 System.out.println("睡覺"); 10 } 11 } 12 //繼承 13 class Student extends Person 14 { 15 16 } 17 //繼承 18 class Teacher extends Person 19 { 20 21 } 22 class Demo 23 { 24 public static void main(String[] args) 25 { 26 Student s = new Student(); 27 s.eat(); 28 s.sleep(); 29 Teacher t = new Teacher(); 30 t.eat(); 31 t.sleep(); 32 } 33 }運行結果:
吃飯 睡覺 吃飯 睡覺繼承的好處:
1.提高了代碼的復用性，多個類相同的成員可以放到同一個類中
2.提高了代碼的維護性，如果功能的代碼需要修改，修改一處即可
3.讓類與類之間產生了關系，是多態的前提。其實這也是繼承的一個弊端:類的耦合性很強
08.12 繼承的弊端
設計原則:低耦合高內聚
簡單的理解:內聚就是自己完成某件事情的能力。耦合就是類與類之間的關系。
在設計的時候原則是:自己能完成的就不麻煩別人，這樣將來別人產生了修改，就對我的影響較小。
08.13 Java中類的繼承特點
1.Java只支持單繼承，不支持多繼承。一個類只能有一個父類，不可以有多個父類。
例:
class SubDemo extends Demo{} //正確
class SubDemo extends Demo1,Demo2...//錯誤
2.Java支持多層繼承(繼承體系)
例:
class A{}
class B extends A{}
class C extends B{}
08.14 繼承的注意事項和什么時候使用繼承
注意事項:
1.子類只能繼承父類所有非私有的成員(成員方法和成員變量)，這也體現了繼承的另一個弊端:打破了封裝性
2.子類不能繼承父類的構造方法，但是可以通過super(后面講解)關鍵字去訪問父類構造方法。
3.不要為了部分功能而去繼承
當繼承中類與類之間體現的是:”is a”的關系就時候使用繼承。例如學生是人的一種
08.15 繼承中成員變量的關系
繼承中成員變量的關系:
A:子類中的成員變量和父類中的成員變量名稱不一樣，直接調用即可。
B:子類中的成員變量和父類中的成員變量名稱一樣時，在子類方法中訪問一個變量的查找順序:
① 在子類方法的局部范圍找，有就使用
② 在子類的成員范圍找，有就使用
③ 在父類的成員范圍找，有就使用
④ 如果還找不到，就報錯
例:
1 class Fu2 {3 //父類成員位置4 public int num = 10;5 }6 class Zi extends Fu7 {8 //子類成員位置9 public int num2 = 20; 10 public int num = 30; 11 public void show() 12 { 13 //子類方法局部位置 14 System.out.println(num); 15 System.out.println(num2); 16 } 17 } 18 class Demo 19 { 20 public static void main(String[] args) 21 { 22 Zi z = new Zi(); 23 z.show(); 24 } 25 }運行結果:
30 2008.16 this和super的區別和應用
例:
1 class Fu2 {3 public int num = 10;4 }5 class Zi extends Fu6 {7 public int num = 20;8 public void show()9 { 10 int num = 30; 11 //局部范圍的num 12 System.out.println(num); 13 //本類成員范圍的num 14 System.out.println(this.num); 15 //父類成員范圍的num 16 System.out.println(super.num); 17 } 18 } 19 class Demo 20 { 21 public static void main(String[] args) 22 { 23 Zi z = new Zi(); 24 z.show(); 25 } 26 }super的用法和this很像，this代表本類對應的引用，super代表父類存儲空間的標識(可以理解為父類引用)
用法:
訪問成員變量: this.成員變量 ?? super.成員變量
訪問構造方法: this(...) ?? ?? super(...)
訪問成員方法: this.成員方法() super.成員方法()
08.17 繼承中構造方法的關系
子類中所有的構造方法默認都會訪問父類中空參數的構造方法
例:
1 class Fu2 {3 Fu()4 {5 System.out.println("父類無參構造方法");6 }7 Fu(String name)8 {9 System.out.println("父類帶參構造方法"); 10 } 11 } 12 class Zi extends Fu 13 { 14 Zi() 15 { 16 System.out.println("子類無參構造方法"); 17 } 18 Zi(String name) 19 { 20 System.out.println("子類帶參構造方法"); 21 } 22 } 23 class Demo 24 { 25 public static void main(String[] args) 26 { 27 Zi z1 = new Zi(); 28 Zi z2 = new Zi("小明"); 29 } 30 }運行結果:
父類無參構造方法 子類無參構造方法 父類無參構造方法 子類帶參構造方法為什么子類中所有的構造方法默認都會訪問父類中空參數的構造方法？
因為子類會繼承父類中的數據，可能還會使用父類的數據。所以，子類初始化之前，一定要先完成父類數據的初始化。
每一個構造方法的第一條語句默認都是:super()
08.18 繼承中構造方法的注意事項
如何父類中沒有構造方法，該怎么辦呢?
如果父類沒有無參的構造方法，那么子類的構造方法將報錯
1.子類可以通過super去顯示調用父類其他的帶參的構造方法
2.子類可以通過this去調用本類的其他構造方法，本類其他構造也必須首先訪問了父類構造
注意:super(...)或者this(...)必須出現在第一條語句上
08.19 繼承中的面試題1
1 class Fu2 {3 public int num = 10;4 public Fu()5 {6 System.out.println("fu");7 }8 }9 class Zi extends Fu 10 { 11 public int num = 20; 12 public Zi() 13 { 14 System.out.println("zi"); 15 } 16 public void show() 17 { 18 int num = 30; 19 System.out.println(num); 20 System.out.println(this.num); 21 System.out.println(super.num); 22 } 23 } 24 class Demo 25 { 26 public static void main(String[] args) 27 { 28 Zi z = new Zi(); 29 z.show(); 30 } 31 }運行結果:
fu zi 30 20 1008.20 繼承中的面試題2
1.靜態隨著類的加載而加載。
2.靜態代碼塊>構造代碼塊>構造方法
3.只要有子父關系，肯定先初始化父親的數據，然后初始化子類的數據。
1 class Fu 2 {3 static 4 {5 System.out.println("靜態代碼塊Fu");6 }7 8 {9 System.out.println("構造代碼塊Fu"); 10 } 11 12 public Fu() 13 { 14 System.out.println("構造方法Fu"); 15 } 16 } 17 18 class Zi extends Fu 19 { 20 static 21 { 22 System.out.println("靜態代碼塊Zi"); 23 } 24 25 { 26 System.out.println("構造代碼塊Zi"); 27 } 28 29 public Zi() 30 { 31 System.out.println("構造方法Zi"); 32 } 33 } 34 35 class Demo 36 { 37 public static void main(String[] args) 38 { 39 Zi z = new Zi(); 40 } 41 }運行結果:
靜態代碼塊Fu 靜態代碼塊Zi 構造代碼塊Fu 構造方法Fu 構造代碼塊Zi 構造方法Zi08.21 繼承中的面試題3
鋪墊知識:
1:成員變量有基本類型和引用類型的
2:類的初始化過程，加載class文件、堆中開辟空間、變量的默認初始化、變量的顯示初始化、構造代碼塊初始化、構造方法初始化
3:類與類有繼承關系時，先初始化父類數據，然后初始化子類數據。
1 class X 2 {3 Y b = new Y();4 X() 5 {6 System.out.print("X");7 }8 }9 class Y 10 { 11 Y() 12 { 13 System.out.print("Y"); 14 } 15 } 16 17 class Demo extends X 18 { 19 Y y = new Y(); 20 Demo() 21 { 22 //super();super在這里僅僅表示要先初始化父類數據 23 System.out.print("Z"); 24 } 25 public static void main(String[] args) 26 { 27 new Demo(); 28 } 29 }運行結果:
YXYZ08.22 繼承中成員方法關系
繼承中成員方法的關系:
1:子類中的方法和父類中的方法聲明不一樣，直接調用方法即可。
2:子類中的方法和父類中的方法聲明一樣，通過子類對象調用方法:
① 先找子類中，看有沒有這個方法，有就使用
② 再看父類中，有沒有這個方法，有就使用
③ 如果沒有就報錯
例:
1 class Fu2 {3 public void show() 4 {5 System.out.println("fu show run");6 }7 }8 class Zi extends Fu9 { 10 public void show() 11 { 12 System.out.println("zi show run"); 13 } 14 } 15 16 class Demo 17 { 18 public static void main(String[] args) 19 { 20 Zi z = new Zi(); 21 z.show(); 22 } 23 }運行結果:
zi show run08.23 方法重寫的應用
方法重寫概述:子類中出現了和父類中方法聲明一模一樣的方法，也被稱為方法覆蓋，方法復寫。
使用特點:
如果方法名不同，就調用對應的方法
如果方法名相同，最終使用的是子類自己的
方法重寫的應用:
當子類需要父類的功能，而功能主體子類有自己特有內容時，可以重寫父類中的方法，這樣，即沿襲了父類的功能，又定義了子類特有的內容。
例:
1 class Phone2 {3 public void call(String name) 4 {5 System.out.println("給"+name+"打電話");6 }7 }8 class NewPhone extends Phone9 { 10 public void call(String name) 11 { 12 //保留父類功能 13 super.call(name); 14 //定義子類特有內容 15 System.out.println("發圖片"); 16 } 17 } 18 19 class Demo 20 { 21 public static void main(String[] args) 22 { 23 NewPhone np = new NewPhone(); 24 np.call("小明"); 25 } 26 }運行結果:
給小明打電話 發圖片08.24 方法重寫的注意事項
方法重寫的注意事項:
1.父類中私有方法不能被重寫
2.子類重寫父類方法時，訪問權限不能更低
3.父類靜態方法，子類也必須通過靜態方法進行重寫
08.25 兩個面試題
1.方法重寫和方法重載的區別?方法重載能改變返回值類型嗎?
方法重寫(Override)是指在子類中出現了方法聲明與父類一模一樣的方法
方法重載(Overload)是指在同一個類中出現的方法名相同，參數列表不同的方法
方法重載能改變返回值類型,因為它和返回值無關
2.this關鍵字和super關鍵字分別代表什么?以及他們各自的使用場景和作用。
super的用法和this很像，this代表本類對應的引用，super代表父類存儲空間的標識(可以理解為父類引用)
用法:
訪問成員變量: this.成員變量 ?? super.成員變量
訪問構造方法: this(...) ?? ?? super(...)
訪問成員方法: this.成員方法() super.成員方法()
08.26 使用繼承前的學生和老師案例?
1 /*2 學生案例和老師案例講解3 4 學生:5 成員變量:姓名，年齡6 構造方法:無參，帶參7 成員方法:getXxx()/setXxx()8 老師:9 成員變量:姓名，年齡10 構造方法:無參，帶參11 成員方法:getXxx()/setXxx()12 */13 //定義學生類14 class Student 15 {16 //姓名17 private String name;18 //年齡19 private int age;20 21 public Student() 22 {23 }24 25 public Student(String name,int age) 26 {27 this.name = name;28 this.age = age;29 }30 31 public String getName() 32 {33 return name;34 }35 36 public void setName(String name) 37 {38 this.name = name;39 }40 41 public int getAge() 42 {43 return age;44 }45 46 public void setAge(int age) 47 {48 this.age = age;49 }50 }51 52 //定義老師類53 class Teacher 54 {55 //姓名56 private String name;57 //年齡58 private int age;59 60 public Teacher() 61 {62 }63 64 public Teacher(String name,int age) 65 {66 this.name = name;67 this.age = age;68 }69 70 public String getName() 71 {72 return name;73 }74 75 public void setName(String name) 76 {77 this.name = name;78 }79 80 public int getAge() 81 {82 return age;83 }84 85 public void setAge(int age) 86 {87 this.age = age;88 }89 }90 class Demo 91 {92 public static void main(String[] args)93 {94 //創建學生對象并測試95 //方式196 Student s1 = new Student();97 s1.setName("旺財");98 s1.setAge(5);99 System.out.println(s1.getName()+"---"+s1.getAge()); 100 101 //方式2 102 Student s2 = new Student("旺財",5); 103 System.out.println(s2.getName()+"---"+s2.getAge()); 104 } 105 }08.27 使用繼承后的學生和老師案例
1 /*2 學生案例和老師案例講解3 4 學生:5 成員變量:姓名，年齡6 構造方法:無參，帶參7 成員方法:getXxx()/setXxx()8 老師:9 成員變量:姓名，年齡 10 構造方法:無參，帶參 11 成員方法:getXxx()/setXxx() 12 13 看上面兩個類的成員，發現了很多相同的東西，所以我們就考慮抽取一個共性的類: 14 人: 15 成員變量:姓名，年齡 16 構造方法:無參，帶參 17 成員方法:getXxx()/setXxx() 18 19 學生 繼承 人 20 老師 繼承 人 21 */ 22 //定義人類 23 class Person 24 { 25 //姓名 26 private String name; 27 //年齡 28 private int age; 29 30 public Person() 31 { 32 } 33 34 public Person(String name,int age) 35 { 36 this.name = name; 37 this.age = age; 38 } 39 40 public String getName() 41 { 42 return name; 43 } 44 45 public void setName(String name) 46 { 47 this.name = name; 48 } 49 50 public int getAge() 51 { 52 return age; 53 } 54 55 public void setAge(int age) 56 { 57 this.age = age; 58 } 59 } 60 //定義學生類 61 class Student extends Person 62 { 63 Student() 64 { 65 } 66 Student(String name,int age) 67 { 68 super(name,age); 69 } 70 } 71 //定義老師類 72 class Teacher extends Person 73 { 74 75 } 76 class Demo 77 { 78 public static void main(String[] args) 79 { 80 //創建學生對象并測試 81 //方式1 82 Student s1 = new Student(); 83 s1.setName("旺財"); 84 s1.setAge(5); 85 System.out.println(s1.getName()+"---"+s1.getAge()); 86 87 //方式2 88 Student s2 = new Student("旺財",5); 89 System.out.println(s2.getName()+"---"+s2.getAge()); 90 } 91 }08.28 貓狗案例分析
貓狗案例講解
?? 先找到具體的事物，然后發現具體的事物有共性，才提取出一個父類。
?? 貓:
?? ?? 成員變量:姓名，年齡，顏色
?? ?? 構造方法:無參，帶參
?? ?? 成員方法:
?? ?? ?? ?? getXxx()/setXxx()
?? ?? ?? ?? eat()
?? ?? ?? ?? palyGame()
?? 狗:
?? ?? 成員變量:姓名，年齡，顏色
?? ?? 構造方法:無參，帶參
?? ?? 成員方法:
?? ?? ?? ?? getXxx()/setXxx()
?? ?? ?? ?? eat()
?? ?? ?? ?? lookDoor()
把共性定義到一個類中，這個類的名字叫:動物。
動物類:
?? ?? 成員變量:姓名，年齡，顏色
?? ?? 構造方法:無參，帶參
?? ?? 成員方法:
?? ?? ?? getXxx()/setXxx()
?? ?? ?? eat()
貓:?
?? 構造方法:無參，帶參
?? 成員方法:palyGame()
狗:
?? 構造方法:無參，帶參
?? 成員方法:lookDoor()
08.29 貓狗案例實現及測試?
1 //定義動物類2 class Animal 3 {4 //姓名5 private String name;6 //年齡7 private int age;8 //顏色9 private String color; 10 11 public Animal() {} 12 public Animal(String name,int age,String color) 13 { 14 this.name = name; 15 this.age = age; 16 this.color = color; 17 } 18 public String getName() 19 { 20 return name; 21 } 22 public void setName(String name) 23 { 24 this.name = name; 25 } 26 public int getAge() 27 { 28 return age; 29 } 30 public void setAge(int age) 31 { 32 this.age = age; 33 } 34 public String getColor() 35 { 36 return color; 37 } 38 public void setColor(String color) 39 { 40 this.color = color; 41 } 42 public void eat() 43 { 44 System.out.println("吃飯"); 45 } 46 } 47 48 //定義貓類 49 class Cat extends Animal 50 { 51 public Cat() {} 52 public Cat(String name,int age,String color) 53 { 54 super(name,age,color); 55 } 56 public void playGame() 57 { 58 System.out.println("貓玩游戲"); 59 } 60 } 61 62 //定義狗類 63 class Dog extends Animal 64 { 65 public Dog() {} 66 public Dog(String name,int age,String color) 67 { 68 super(name,age,color); 69 } 70 public void lookDoor() 71 { 72 System.out.println("狗看家"); 73 } 74 } 75 class Demo 76 { 77 public static void main(String[] args) 78 { 79 //測試貓 80 //方式1 81 Cat c1 = new Cat(); 82 c1.setName("Tom"); 83 c1.setAge(3); 84 c1.setColor("黃色"); 85 System.out.println("貓的名字是:"+c1.getName()+" 年齡是:"+c1.getAge()+" 顏色是:"+c1.getColor()); 86 c1.eat(); 87 c1.playGame(); 88 System.out.println("---------------"); 89 90 //方式2 91 Cat c2 = new Cat("旺財",5,"黑色"); 92 System.out.println("貓的名字是:"+c2.getName()+" 年齡是:"+c2.getAge()+" 顏色是:"+c2.getColor()); 93 c2.eat(); 94 c2.playGame(); 95 } 96 }運行結果:
貓的名字是:Tom 年齡是:3 顏色是:黃色 吃飯 貓玩游戲 --------------- 貓的名字是:旺財年齡是:5 顏色是:黑色 吃飯 貓玩游戲轉載于:https://www.cnblogs.com/hoop-superman/p/5495683.html
總結
以上是生活随笔為你收集整理的JavaSE学习总结第08天_面向对象3的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Linux压缩解压缩命令
- 下一篇： Android安全开发之浅谈密钥硬编码