1:如何制作幫助文檔(了解)
(1)寫一個類
(2)加入文檔注釋
(3)通過javadoc工具生成即可
javadoc -d 目錄 -author -version arraytool.java
/*
我想要對數組進行操作
在同一個檔案夾下，類定義在兩個檔案中和定義在一個檔案中其實一樣的。
*/
class arraydemo {
public static void main(string[] args) {
//定義數組
int[] arr = {28,55,37,46,19};
//需求：周遊數組
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
system.out.println(arr[x]);
}else {
system.out.print(arr[x]+", ");
}
//如果我有多個數組都要進行周遊，那麼，代碼的重複度就很高
//如何改進呢?用方法改進
//調用
//靜态方法
//printarray(arr);
//非靜态方法
//arraydemo ad = new arraydemo();
//ad.printarray(arr);
//測試類的作用：建立其他類的對象，調用其他類的功能。
//而我們現在的操作是跟數組相關的，是以，你應該把這些操作定義到數組操作類中
//定義一個數組的操作類
//有了數組操作類之後的調用
//arraytool at = new arraytool();
//at.printarray(arr);
//方法改進為靜态後，就可以直接通過類名調用
arraytool.printarray(arr);
public static void printarray(int[] arr) {
//假設該方法不是靜态的
public void printarray(int[] arr) {
lass arraytool {
//把構造方法私有，外界就不能在建立對象了
private arraytool(){}
如何制作一個說明書呢?
a:寫一個工具類
b:對這個類加入文檔注釋
怎麼加呢?
加些什麼東西呢?
c:用工具解析文檔注釋
javadoc工具
d:格式
目錄：就可以寫一個檔案夾的路徑
制作幫助文檔出錯：
找不到可以文檔化的公共或受保護的類：告訴我們類的權限不夠
//周遊
//擷取最值
int max = arraytool.getmax(arr);
system.out.println("max:"+max);
//擷取55的索引值
int index = arraytool.getindex(arr,55);
system.out.println("index:"+index);
/**
* 這是針對數組進行操作的工具類
* @author 劉意
* @version v.10
public class arraytool {
* 這是私有構造
* 這是周遊數組的方法，周遊後的格式是：[元素1, 元素2, 元素3, ...]
* @param arr 這是要被周遊的數組
system.out.print("[");
system.out.println(arr[x]+"]");
* 這是擷取數組中最大值的方法
* @param arr 這是要擷取最大值的數組
* @return 傳回數組中的最大值
public static int getmax(int[] arr) {
int max = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
return max;
* 擷取指定元素在數組中第一次出現的索引，如果元素不存在，就傳回-1
* @param arr 被查找的數組
* @param value 要查找的元素
* @return 傳回元素在數組中的索引，如果不存在，傳回-1
public static int getindex(int[] arr,int value) {
int index = -1;
if(arr[x] == value) {
index = x;
break;
return index;
2:通過jdk提供的api學習了math類(掌握)
(1)api(application programming interface)
應用程式程式設計接口(幫助文檔)
(2)如何使用呢?
請參照
day08\code\02_如何使用jdk提供的幫助文檔\如何使用幫助文檔.txt
(3)math類
a:是針對數學進行操作的類
b:沒有構造方法，因為它的成員都是靜态的
c:産生随機數
public static double random(): [0.0,1.0)
d:如何産生一個1-100之間的随機數
int number = (int)(math.random()*100)+1;
e:猜數字小遊戲
math:類包含用于執行基本數學運算的方法
由于math類在java.lang包下，是以不需要導包。
特點：
沒有構造方法，因為它的成員全部是靜态的。
掌握一個方法：
擷取随機數
public static double random():傳回帶正号的 double 值，該值大于等于 0.0 且小于 1.0。
class mathdemo {
//擷取一個随機數
//double d = math.random();
//system.out.println(d);
//需求：我要擷取一個1-100之間的随機數，腫麼辦?
for(int x=0; x<100; x++) {
system.out.println(number);
猜數字小遊戲(資料在1-100之間)
分析：
a:程式産生一個随機數。(被猜的)
b:鍵盤錄入資料。(你猜的)
c:把你猜的和被猜的進行比較
a:大了
b:小了
c:猜中了
d:給出多次猜的機會，猜中就結束。
while()循環，猜中就break
import java.util.scanner;
class guessnumber {
//程式産生一個随機數。(被猜的)
//system.out.println(number);
//給出多次猜的機會，猜中就結束。
while(true) {
//鍵盤錄入資料。(你猜的)
scanner sc = new scanner(system.in);
system.out.println("請輸入你要猜的資料(1-100):");
int guessnumber = sc.nextint();
//把你猜的和被猜的進行比較
if(guessnumber > number) {
system.out.println("你猜的資料"+guessnumber+"大了");
}else if(guessnumber < number) {
system.out.println("你猜的資料"+guessnumber+"小了");
system.out.println("恭喜你，猜中了");
3:代碼塊(了解)
(1)用{}括起來的代碼。
(2)分類：
a:局部代碼塊
用于限定變量的生命周期，及早釋放，提高記憶體使用率。
b:構造代碼塊
把多個構造方法中相同的代碼可以放到這裡，每個構造方法執行前，首先執行構造代碼塊。
c:靜态代碼塊
對類的資料進行初始化，僅僅隻執行一次。
(3)靜态代碼塊,構造代碼塊,構造方法的順序問題?
靜态代碼塊 > 構造代碼塊 > 構造方法
代碼塊：在java中，使用{}括起來的代碼被稱為代碼塊。
根據其位置和聲明的不同，可以分為
局部代碼塊:局部位置,用于限定變量的生命周期。
構造代碼塊:在類中的成員位置,用{}括起來的代碼。每次調用構造方法執行前，都會先執行構造代碼塊。
作用：可以把多個構造方法中的共同代碼放到一起，對對象進行初始化。
靜态代碼塊:在類中的成員位置,用{}括起來的代碼,隻不過它用static修飾了。
作用：一般是對類進行初始化。
面試題?
靜态代碼塊,構造代碼塊,構造方法的執行順序?
靜态代碼塊 -- 構造代碼塊 -- 構造方法
靜态代碼塊：隻執行一次
構造代碼塊：每次調用構造方法都執行
class code {
static {
int a = 1000;
system.out.println(a);
//構造代碼塊
{
int x = 100;
system.out.println(x);
//構造方法
public code(){
system.out.println("code");
public code(int a){
int y = 200;
system.out.println(y);
//靜态代碼塊
int b = 2000;
system.out.println(b);
class codedemo {
//局部代碼塊
int x = 10;
//找不到符号
//system.out.println(x);
int y = 20;
system.out.println("---------------");
code c = new code();
code c2 = new code();
code c3 = new code(1);
寫程式的執行結果。
林青霞都60了，我很傷心
我是main方法
student 靜态代碼塊
student 構造代碼塊
student 構造方法
class student {
system.out.println("student 靜态代碼塊");
system.out.println("student 構造代碼塊");
public student() {
system.out.println("student 構造方法");
class studentdemo {
system.out.println("林青霞都60了，我很傷心");
system.out.println("我是main方法");
student s1 = new student();
student s2 = new student();
4:繼承(掌握)
(1)把多個類中相同的成員給提取出來定義到一個獨立的類中。然後讓這多個類和該獨立的類産生一個關系，
這多個類就具備了這些内容。這個關系叫繼承。
(2)java中如何表示繼承呢?格式是什麼呢?
a:用關鍵字extends表示
b:格式：
class 子類名 extends 父類名 {}
(3)繼承的好處：
a:提高了代碼的複用性
b:提高了代碼的維護性
c:讓類與類産生了一個關系，是多态的前提
(4)繼承的弊端：
a:讓類的耦合性增強。這樣某個類的改變，就會影響其他和該類相關的類。
原則：低耦合，高内聚。
耦合：類與類的關系
内聚：自己完成某件事情的能力
b:打破了封裝性
繼承概述：
把多個類中相同的内容給提取出來定義到一個類中。
如何實作繼承呢?
java提供了關鍵字：extends
格式：
好處：
c:讓類與類之間産生了關系，是多态的前提
類與類産生了關系，其實也是繼承的一個弊端：
類的耦合性增強了。
開發的原則：低耦合，高内聚。
内聚：就是自己完成某件事情的能力
//使用繼承前
public void eat() {
system.out.println("吃飯");
public void sleep() {
system.out.println("睡覺");
class teacher {
//使用繼承後
class person {
class student extends person {}
class teacher extends person {}
class extendsdemo {
student s = new student();
s.eat();
s.sleep();
system.out.println("-------------");
teacher t = new teacher();
t.eat();
t.sleep();
(5)java中繼承的特點
a:java中類隻支援單繼承
b:java中可以多層(重)繼承(繼承體系)
java中繼承的特點：
a:java隻支援單繼承，不支援多繼承。
有些語言是支援多繼承，格式：extends 類1,類2,...
b:java支援多層繼承(繼承體系)
class father {}
class mother {}
class son exnteds father {} //正确的
class son extends father,mother {} // 錯誤的
class grandfather {
public void show() {
system.out.println("我是爺爺");
class father extends grandfather {
public void method(){
system.out.println("我是老子");
class son extends father {}
class extendsdemo2 {
son s = new son();
s.method(); //使用父親的
s.show(); //使用爺爺的
(6)繼承的注意事項：
a:子類不能繼承父類的私有成員
b:子類不能繼承父類的構造方法，但是可以通過super去通路
c:不要為了部分功能而去繼承
繼承的注意事項：
a:子類隻能繼承父類所有非私有的成員(成員方法和成員變量)
b:子類不能繼承父類的構造方法，但是可以通過super(馬上講)關鍵字去通路父類構造方法。
class a {
public void show1(){}
public void show2(){}
class b {
public void show3(){}
//我們發現b類中出現了和a類一樣的show2()方法，是以，我們就用繼承來展現
class b extends a {
這樣其實不好，因為這樣你不但有了show2(),還多了show1()。
有可能show1()不是你想要的。
那麼，我們什麼時候考慮使用繼承呢?
繼承其實展現的是一種關系："is a"。
person
student
teacher
水果
蘋果
香蕉
橘子
采用假設法。
如果有兩個類a,b。隻有他們符合a是b的一種，或者b是a的一種，就可以考慮使用繼承。
class father {
private int num = 10;
public int num2 = 20;
//私有方法，子類不能繼承
private void method() {
system.out.println(num);
system.out.println(num2);
class son extends father {
public void function() {
//num可以在father中通路private
//system.out.println(num); //子類不能繼承父類的私有成員變量
class extendsdemo3 {
// 建立對象
//s.method(); //子類不能繼承父類的私有成員方法
s.show();
s.function();
(7)什麼時候使用繼承呢?
a:繼承展現的是：is a的關系。
b:采用假設法
(8)java繼承中的成員關系
a:成員變量
a:子類的成員變量名稱和父類中的成員變量名稱不一樣，這個太簡單
b:子類的成員變量名稱和父類中的成員變量名稱一樣，這個怎麼通路呢?
子類的方法通路變量的查找順序：
在子類方法的局部範圍找，有就使用。
在子類的成員範圍找，有就使用。
在父類的成員範圍找，有就使用。
找不到，就報錯。
b:構造方法
a:子類的構造方法預設會去通路父類的無參構造方法
是為了子類通路父類資料的初始化
b:父類中如果沒有無參構造方法，怎麼辦?
子類通過super去明确調用帶參構造
子類通過this調用本身的其他構造，但是一定會有一個去通路了父類的構造
讓父類提供無參構造
c:成員方法
a:子類的成員方法和父類中的成員方法名稱不一樣，這個太簡單
b:子類的成員方法和父類中的成員方法名稱一樣，這個怎麼通路呢?
通過子類對象通路一個方法的查找順序：
在子類中找，有就使用
在父類中找，有就使用
找不到，就報錯
類的組成：
成員變量：
構造方法：
成員方法：
而現在我們又講解了繼承，是以，我們就應該來考慮一下，類的組成部分的各自關系。
繼承中成員變量的關系:
a:子類中的成員變量和父類中的成員變量名稱不一樣，這個太簡單。
b:子類中的成員變量和父類中的成員變量名稱一樣，這個怎麼玩呢?
在子類方法中通路一個變量的查找順序：
a:在子類方法的局部範圍找，有就使用
b:在子類的成員範圍找，有就使用
c:在父類的成員範圍找，有就使用
d:如果還找不到，就報錯。
public int num = 10;
public void method() {
int num = 50;
public int num = 30;
int num = 40;
// 找不到符号
system.out.println(num3);
class extendsdemo4 {
//建立對象
(9)兩個面試題：
a:override和overload的差別?overload是否可以改變傳回值類型?
b:this和super的差別和各自的作用?
1：方法重寫和方法重載的差別?方法重載能改變傳回值類型嗎?
方法重寫：
在子類中，出現和父類中一模一樣的方法聲明的現象。
方法重載：
同一個類中，出現的方法名相同，參數清單不同的現象。
方法重載能改變傳回值類型，因為它和傳回值類型無關。
override：方法重寫
overload：方法重載
2：this關鍵字和super關鍵字分别代表什麼?以及他們各自的使用場景和作用。
this:代表目前類的對象引用
super:代表父類存儲空間的辨別。(可以了解為父類的引用，通過這個東西可以通路父類的成員)
場景：
this.成員變量
super.成員變量
this(...)
super(...)
this.成員方法
super.成員方法
問題是：
我不僅僅要輸出局部範圍的num，還要輸出本類成員範圍的num。怎麼辦呢?
我還想要輸出父類成員範圍的num。怎麼辦呢?
如果有一個東西和this相似，但是可以直接通路父類的資料就好了。
恭喜你，這個關鍵字是存在的：super。
this和super的差別?
分别是什麼呢?
this代表本類對應的引用。
super代表父類存儲空間的辨別(可以了解為父類引用,可以操作父類的成員)
怎麼用呢?
a:調用成員變量
this.成員變量 調用本類的成員變量
super.成員變量 調用父類的成員變量
b:調用構造方法
調用本類的構造方法
調用父類的構造方法
c:調用成員方法
this.成員方法 調用本類的成員方法
super.成員方法 調用父類的成員方法
public int num = 20;
int num = 30;
system.out.println(this.num);
system.out.println(super.num);
class extendsdemo5 {
繼承中構造方法的關系
a:子類中所有的構造方法預設都會通路父類中空參數的構造方法
b:為什麼呢?
因為子類會繼承父類中的資料，可能還會使用父類的資料。
是以，子類初始化之前，一定要先完成父類資料的初始化。
注意：子類每一個構造方法的第一條語句預設都是：super();
int age;
public father() {
system.out.println("father的無參構造方法");
public father(string name) {
system.out.println("father的帶參構造方法");
public son() {
//super();
system.out.println("son的無參構造方法");
public son(string name) {
system.out.println("son的帶參構造方法");
class extendsdemo6 {
system.out.println("------------");
son s2 = new son("林青霞");
如果父類沒有無參構造方法，那麼子類的構造方法會出現什麼現象呢?
報錯。
如何解決呢?
a:在父類中加一個無參構造方法
b:通過使用super關鍵字去顯示的調用父類的帶參構造方法
c:子類通過this去調用本類的其他構造方法
子類中一定要有一個去通路了父類的構造方法，否則父類資料就沒有初始化。
注意事項：
this(...)或者super(...)必須出現在第一條語句上。
如果不是放在第一條語句上，就可能對父類的資料進行了多次初始化，是以必須放在第一條語句上。
super("随便給");
//super("随便給");
this();
class extendsdemo7 {
system.out.println("----------------");
son ss = new son("林青霞");
繼承中成員方法的關系:
a:子類中的方法和父類中的方法聲明不一樣，這個太簡單。
b:子類中的方法和父類中的方法聲明一樣，這個該怎麼玩呢?
通過子類對象調用方法：
a:先找子類中，看有沒有這個方法，有就使用
b:再看父類中，有沒有這個方法，有就使用
c:如果沒有就報錯。
system.out.println("show father");
system.out.println("method son");
system.out.println("show son");
class extendsdemo8 {
s.method();
//s.fucntion(); //找不到符号
方法重寫：子類中出現了和父類中方法聲明一模一樣的方法。
本類中出現的方法名一樣，參數清單不同的方法。與傳回值無關。
子類對象調用方法的時候：
先找子類本身，再找父類。
方法重寫的應用：
當子類需要父類的功能，而功能主體子類有自己特有内容時，可以重寫父類中的方法。
這樣，即沿襲了父類的功能，又定義了子類特有的内容。
案例：
a:定義一個手機類。
b:通過研究，我發明了一個新手機，這個手機的作用是在打完電話後，可以聽天氣預報。
按照我們基本的設計，我們把代碼給寫出來了。
但是呢?我們又發現新手機應該是手機，是以，它應該繼承自手機。
其實這個時候的設計，并不是最好的。
因為手機打電話功能，是手機本身就具備的最基本的功能。
是以，我的新手機是不用在提供這個功能的。
但是，這個時候，打電話功能就沒有了。這個不好。
最終，還是加上這個功能。由于它繼承了手機類，是以，我們就直接使用父類的功能即可。
那麼，如何使用父類的功能呢?通過super關鍵字調用
class phone {
public void call(string name) {
system.out.println("給"+name+"打電話");
class newphone extends phone {
//system.out.println("給"+name+"打電話");
super.call(name);
system.out.println("可以聽天氣預報了");
class extendsdemo9 {
newphone np = new newphone();
np.call("林青霞");
方法重寫的注意事項
a:父類中私有方法不能被重寫
因為父類私有方法子類根本就無法繼承
b:子類重寫父類方法時，通路權限不能更低
最好就一緻
c:父類靜态方法，子類也必須通過靜态方法進行重寫
其實這個算不上方法重寫，但是現象确實如此，至于為什麼算不上方法重寫，多态中我會講解
子類重寫父類方法的時候，最好聲明一模一樣。
//private void show() {}
void show() {
public static void method() {
class extendsdemo10 {
看程式寫結果：
a:成員變量的問題
int x = 10; //成員變量是基本類型
student s = new student(); //成員變量是引用類型
b:一個類的初始化過程
成員變量的初始化
預設初始化
顯示初始化
構造方法初始化
c:子父類的初始化(分層初始化)
先進行父類初始化，然後進行子類初始化。
結果：
yxyz
問題：
雖然子類中構造方法預設有一個super()
初始化的時候，不是按照那個順序進行的。
而是按照分層初始化進行的。
它僅僅表示要先初始化父類資料，再初始化子類資料。
class x {
y b = new y();
x() {
system.out.print("x");
class y {
y() {
system.out.print("y");
public class z extends x {
y y = new y();
z() {
//super
system.out.print("z");
new z();
(10)資料初始化的面試題
a:一個類的初始化過程
b:子父類的構造執行過程
c:分層初始化
就近原則
b:this和super的問題
this通路本類的成員
super通路父類的成員
c:子類構造方法執行前預設先執行父類的無參構造方法
d:一個類的初始化過程
成員變量進行初始化
fu
zi
30
20
10
class fu{
public fu(){
system.out.println("fu");
class zi extends fu{
public zi(){
system.out.println("zi");
public void show(){
system.out.println(num); //30
system.out.println(this.num); //20
system.out.println(super.num); //10
class extendstest {
zi z = new zi();
z.show();
a:一個類的靜态代碼塊,構造代碼塊,構造方法的執行流程
b:靜态的内容是随着類的加載而加載
靜态代碼塊的内容會優先執行
c:子類初始化之前先會進行父類的初始化
結果是：
靜态代碼塊fu
靜态代碼塊zi
構造代碼塊fu
構造方法fu
構造代碼塊zi
構造方法zi
class fu {
system.out.println("靜态代碼塊fu");
system.out.println("構造代碼塊fu");
public fu() {
system.out.println("構造方法fu");
class zi extends fu {
system.out.println("靜态代碼塊zi");
system.out.println("構造代碼塊zi");
public zi() {
system.out.println("構造方法zi");
class extendstest2 {
(11)案例：
a:學生和老師案例
繼承前
繼承後
學生案例和老師案例講解
學生：
成員變量；姓名，年齡
構造方法：無參，帶參
成員方法：getxxx()/setxxx()
老師：
//定義學生類
//姓名
private string name;
//年齡
private int age;
public student(string name,int age) {
this.name = name;
this.age = age;
public string getname() {
return name;
public void setname(string name) {
public int getage() {
return age;
public void setage(int age) {
//定義老師類
public teacher() {
public teacher(string name,int age) {
class extendstest3 {
//建立學生對象并測試
//方式1
s1.setname("林青霞");
s1.setage(27);
system.out.println(s1.getname()+"---"+s1.getage());
//方式2
student s2 = new student("林青霞",27);
system.out.println(s2.getname()+"---"+s2.getage());
//對應的老師測試我不想了，留給你們自己練習。
看上面兩個類的成員，發現了很多相同的東西，是以我們就考慮抽取一個共性的類：
人：
學生 繼承 人
老師 繼承 人
//定義人類
public person() {
public person(string name,int age) { //"林青霞",27
class student extends person {
public student() {}
public student(string name,int age) { //"林青霞",27
//this.name = name;
//this.age = age;
super(name,age);
class teacher extends person {
class extendstest4 {
//補齊老師類中的代碼并進行測試。
b:貓狗案例的分析和實作
貓狗案例講解
先找到具體的事物，然後發現具體的事物有共性，才提取出一個父類。
貓：
成員變量：姓名，年齡，顔色
getxxx()/setxxx()
eat()
palygame()
狗：
lookdoor()
共性：
把共性定義到一個類中，這個類的名字叫：動物。
動物類：
成員方法：palygame()
成員方法：lookdoor()
//定義動物類
class animal {
//顔色
private string color;
public animal() {}
public animal(string name,int age,string color) {
this.color = color;
public string getcolor() {
return color;
public void setcolor(string color) {
system.out.println("不要睡了,該吃飯了");
//定義貓類
class cat extends animal {
public cat() {}
public cat(string name,int age,string color) {
super(name,age,color);
public void playgame() {
system.out.println("貓玩英雄聯盟");
//定義狗類
class dog extends animal {
public dog() {}
public dog(string name,int age,string color) {
public void lookdoor() {
system.out.println("狗看家");
//測試類
class extendstest5 {
//測試貓
cat c1 = new cat();
c1.setname("tom");
c1.setage(3);
c1.setcolor("白色");
system.out.println("貓的名字是："+c1.getname()+";年齡是："+c1.getage()+";顔色是："+c1.getcolor());
c1.eat();
c1.playgame();
cat c2 = new cat("傑瑞",5,"土豪金");
system.out.println("貓的名字是："+c2.getname()+";年齡是："+c2.getage()+";顔色是："+c2.getcolor());
c2.eat();
c2.playgame();
//作業：測試狗
java幫幫今日頭條号
java幫幫微信公衆号
java幫幫交流群