計算機的基礎知識
1:計算機概述(了解)
(1)計算機
(2)計算機硬件
(3)計算機軟件
系統(tǒng)軟件：window,linux,mac
應用軟件：qq,yy,飛秋
(4)軟件開發(fā)(理解)
軟件：是由數(shù)據(jù)和指令組成的你弦。(計算器)
開發(fā)：就是把軟件做出來县钥。
如何實現(xiàn)軟件開發(fā)呢?
就是使用開發(fā)工具和計算機語言做出東西來
(5)語言
自然語言：人與人交流溝通的
計算機語言：人與計算機交流溝通的
C,C++,C#,Java
(6)人機交換
圖形界面：操作方便只管
DOS命令：需要記憶一些常見的命令
2:鍵盤功能鍵的認識和快捷鍵(掌握)
(1)功能鍵的認識
tab
shift
ctrl
alt
windos
空格
上下左右
回車
截圖
(2)快捷鍵
全選 Ctrl+A
復制 Ctrl+C
粘貼 Ctrl+V
剪切 Ctrl+X
撤銷 Ctrl+Z
保存 Ctrl+S
3:常見的DOS命令(掌握)
(1)常見的如下
盤符的切換
d:回車
目錄的進入
cd javase
cd javase\day01\code
目錄的回退
cd..
cd\
清屏
cls
退出
exit
(2)其他的幾個(了解)
創(chuàng)建目錄
mkdir
刪除目錄
rmdir
創(chuàng)建文件
edit
刪除文件
del
顯示目錄下的內(nèi)容
dir
刪除帶內(nèi)容的目錄
rd /s/q
4:Java語言概述(了解)
(1)Java語言的發(fā)展史
Java之父
JDK1.4.2
JDK5
JDK7
(2)Java語言的特點
有很多小特點隙畜，重點有兩個開源螺捐，跨平臺
(3)Java語言是跨平臺的灰殴，請問是如何保證的呢?(理解)
我們是通過翻譯的案例講解的脖阵。
針對不同的操作系統(tǒng)拇派，提供不同的jvm來實現(xiàn)的拍屑。
(4)Java語言的平臺
JavaSE
JavaME--Android
JavaEE
5:JDK,JRE,JVM的作用及關系(掌握)
(1)作用
JVM：保證Java語言跨平臺
JRE：Java程序的運行環(huán)境
JDK：Java程序的開發(fā)環(huán)境
(2)關系
JDK：JRE+工具
JRE：JVM+類庫
6:JDK的下載,安裝,卸載(掌握)
(1)下載到官網(wǎng)途戒。
A:也可以到百度搜索即可。
B:我給你僵驰。
(2)安裝
A:綠色版 解壓就可以使用
B:安裝版 必須一步一步的安裝喷斋，一般只要會點擊下一步即可
注意：
建議所有跟開發(fā)相關的軟件都不要安裝在有中文或者空格的目錄下。
(3)卸載
A:綠色版 直接刪除文件夾
B:安裝版
a:控制面板 -- 添加刪除程序
b:通過專業(yè)的軟件卸載工具矢渊。(比如360的軟件管家卸載)
7:第一個程序：HelloWorld案例(掌握)
class HelloWorld {
public static void main(String[] args) {
System.out.println("HelloWorld");
}
}
(1)程序解釋：
A:Java程序的最基本單位是類继准，所以我們要定義一個類。
格式：class 類名
舉例：class HelloWorld
B:在類中寫內(nèi)容的時候矮男，用大括號括起來移必。
C:Java程序要想執(zhí)行，必須有main方法毡鉴。
格式：public static void main(String[] args)
D:要指向哪些東西呢崔泵，也用大括號括起來。
E:你要做什么呢?今天我們僅僅做了一個簡單的輸出
格式：System.out.println("HelloWorld");
注意：""里面的內(nèi)容是可以改動的猪瞬。
(2)Java程序的開發(fā)執(zhí)行流程：
A:編寫java源程序(.java)
B:通過javac命令編譯生成.class文件
C:通過java命令運行.class文件
8:常見的問題(掌握)
(1)擴展名被隱藏
如何找到：工具--文件夾選項--查看--去除隱藏擴展名的那個勾勾
(2)我要求文件名稱和類名一致憎瘸。
實際上不這樣做也是可以的。
但是陈瘦，注意：
javac后面跟的是文件名+擴展名
java后面跟的類名不帶擴展名
(3)Java語言嚴格區(qū)分大小寫幌甘，請注意。
還有就是單詞不要寫錯了痊项。
(4)見到非法字符: \65307肯定是中文問題锅风。
我們寫程序要求標點符號必須全部是英文狀態(tài)。
(5)括號的配對問題鞍泉。
一般來說皱埠，括號都是成對出現(xiàn)的。
(6)遇到
在類 HelloWorld 中找不到主方法, 請將主方法定義為
public static void main(String[] args)
肯定是主方法的格式問題咖驮。
9:path環(huán)境變量(掌握)
(1)path環(huán)境變量的作用
保證javac命令可以在任意目錄下運行边器。
同理可以配置qq等
(2)path配置的兩種方案：
A:方案1(了解)
B:方案2
找到環(huán)境變量的位置训枢，在系統(tǒng)變量里面
新建：
變量名：JAVA_HOME
變量值：D:\develop\Java\jdk1.7.0_60
修改：
變量名：Path
變量值：%JAVA_HOME%\bin;以前的內(nèi)容
10:classpath環(huán)境變量(理解)
(1)classpath環(huán)境變量的作用
保證class文件可以在任意目錄下運行
(2)classpath環(huán)境變量的配置
找到環(huán)境變量的位置，在系統(tǒng)變量里面
新建：
變量名：classpath
變量值：E:\JavaSE\day01\code\HelloWorld案例
Java語言基礎
1:關鍵字(掌握)
(1)被Java語言賦予特定含義的單詞
(2)特點：
全部小寫忘巧。
(3)注意事項：
A:goto和const作為保留字存在恒界。
B:類似于Notepad++這樣的高級記事本會對關鍵字有特殊顏色標記
2:標識符(掌握)
(1)就是給類，接口砚嘴，方法仗处，變量等起名字的字符序列
(2)組成規(guī)則：
A:英文大小寫字母
B:數(shù)字
C:$和_
(3)注意事項：
A:不能以數(shù)字開頭
B:不能是java中的關鍵字
C:區(qū)分大小寫
(4)常見的命名規(guī)則(見名知意)
A:包 全部小寫
單級包：小寫
舉例：liuyi,com
多級包：小寫娜汁，并用.隔開
舉例：cn.itcast,com.baidu
B:類或者接口
一個單詞：首字母大寫
舉例：Student,Demo
多個單詞：每個單詞首字母大寫
舉例：HelloWorld,StudentName
C:方法或者變量
一個單詞：首字母小寫
舉例：name,main
多個單詞：從第二個單詞開始趴拧，每個單詞首字母大寫
舉例：studentAge,showAllNames()
D:常量
全部大寫
一個單詞：大寫
舉例：PI
多個單詞：大寫，并用_隔開
舉例：STUDENT_MAX_AGE
3:注釋(掌握)
(1)就是對程序進行解釋說明的文字
(2)分類：
A:單行注釋 //
B:多行注釋 /**/
C:文檔注釋(后面講) /** */
(3)把HelloWorld案例寫了一個帶注釋的版本羹饰。
后面我們要寫一個程序的過程也颤。
需求：
分析：
實現(xiàn)：
代碼體現(xiàn)：
(4)注釋的作用
A:解釋說明程序洋幻，提高了代碼的閱讀性。
B:可以幫助我們調(diào)試程序翅娶。
后面我們會講解一個更高端的一個調(diào)試工具
4:常量(掌握)
(1)在程序執(zhí)行的過程中文留，其值不發(fā)生改變的量
(2)分類：
A:字面值常量
B:自定義常量(后面講)
(3)字面值常量
A:字符串常量 "hello"
B:整數(shù)常量 12,23
C:小數(shù)常量 12.345
D:字符常量 'a','A','0'
E:布爾常量 true,false
F:空常量 null(后面講)
(4)在Java中針對整數(shù)常量提供了四種表現(xiàn)形式
A:二進制 由0，1組成竭沫。以0b開頭燥翅。
B:八進制 由0，1蜕提，...7組成森书。以0開頭。
C:十進制 由0谎势，1凛膏，...9組成。整數(shù)默認是十進制脏榆。
D:十六進制 由0猖毫，1，...9,a,b,c,d,e,f(大小寫均可)組成须喂。以0x開頭吁断。
5:進制轉(zhuǎn)換(了解)
(1)其他進制到十進制
系數(shù)：就是每一個位上的數(shù)值
基數(shù)：x進制的基數(shù)就是x
權(quán)：對每一個位上的數(shù)據(jù)，從右坞生，并且從0開始編號仔役，對應的編號就是該數(shù)據(jù)的權(quán)。
結(jié)果：系數(shù)*基數(shù)^權(quán)次冪之和恨胚。
(2)十進制到其他進制
除基取余骂因，直到商為0炎咖，余數(shù)反轉(zhuǎn)赃泡。
(3)進制轉(zhuǎn)換的快速轉(zhuǎn)換法
A:十進制和二進制間的轉(zhuǎn)換
8421碼寒波。
B:二進制到八進制，十六進制的轉(zhuǎn)換
6:變量(掌握)
(1)在程序的執(zhí)行過程中升熊，其值在某個范圍內(nèi)可以發(fā)生改變的量
(2)變量的定義格式：
A:數(shù)據(jù)類型 變量名 = 初始化值;
B:數(shù)據(jù)類型 變量名;
變量名 = 初始化值;
7:數(shù)據(jù)類型(掌握)
(1)Java是一種強類型語言俄烁，針對每種數(shù)據(jù)都提供了對應的數(shù)據(jù)類型。
(2)分類：
A:基本數(shù)據(jù)類型：4類8種
B:引用數(shù)據(jù)類型：類级野，接口页屠，數(shù)組。
(3)基本數(shù)據(jù)類型
A:整數(shù) 占用字節(jié)數(shù)
byte 1
short 2
int 4
long 8
B:浮點數(shù)
float 4
double 8
C:字符
char 2
D:布爾
boolean 1
注意：
整數(shù)默認是int類型蓖柔，浮點數(shù)默認是double辰企。
長整數(shù)要加L或者l。
單精度的浮點數(shù)要加F或者f况鸣。
8:數(shù)據(jù)類型轉(zhuǎn)換(掌握)
(1)boolean類型不參與轉(zhuǎn)換
(2)默認轉(zhuǎn)換
A:從小到大
B:byte,short,char -- int -- long -- float -- double
C:byte,short,char之間不相互轉(zhuǎn)換牢贸，直接轉(zhuǎn)成int類型參與運算。
(3)強制轉(zhuǎn)換
A:從大到小
B:可能會有精度的損失镐捧，一般不建議這樣使用潜索。
C:格式：
目標數(shù)據(jù)類型 變量名 = (目標數(shù)據(jù)類型) (被轉(zhuǎn)換的數(shù)據(jù));
(4)思考題和面試題：
A:下面兩種方式有區(qū)別嗎?
float f1 = 12.345f;//本來就是float
float f2 = (float)12.345;//double轉(zhuǎn)float
B:下面的程序有問題嗎，如果有懂酱，在哪里呢?
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;//b1+b2是int,需要強轉(zhuǎn)(byte)(b1 + b2)
byte b4 = 3 + 4;//會先判斷3+4的值是否在byte區(qū)間內(nèi),區(qū)間內(nèi)就沒問題
C:下面的操作結(jié)果是什么呢?
byte b = (byte)130;//-126
D:字符參與運算
是查找ASCII里面的值
'a' 97
'A' 65
'0' 48
System.out.println('a');//a
System.out.println('a' + 1);//98
E:字符串參與運算
這里其實是字符串的連接
System.out.println("hello"+'a'+1);//helloa1
System.out.println('a'+1+"hello");//98hello
System.out.println("5+5="+5+5);//5+5=55
System.out.println(5+5+"=5+5");//10=5+5
1:運算符(掌握)
(1)算術運算符
A:+,-,*,/,%,++,--
B:+的用法
a:加法
b:正號
c:字符串連接符
C:/和%的區(qū)別
數(shù)據(jù)做除法操作的時候竹习，/取得是商，%取得是余數(shù)
D:++和--的用法
a:他們的作用是自增或者自減
b:使用
**單獨使用
放在操作數(shù)據(jù)的前面和后面效果一樣列牺。
a++或者++a效果一樣整陌。
**參與操作使用
放在操作數(shù)的前面：先自增或者自減，再參與操作
int a = 10;
int b = ++a;
放在操作數(shù)的后面：先參與操作瞎领，再自增或者自減
int a = 10;
int b = a++;
(2)賦值運算符
A:=,+=,-=,*=,/=,%=等
B:=叫做賦值運算符蔓榄，也是最基本的賦值運算符
int x = 10; 把10賦值給int類型的變量x。
C:擴展的賦值運算符的特點
隱含了自動強制轉(zhuǎn)換默刚。
面試題：
short s = 1;
s = s + 1;//有問題,需要強轉(zhuǎn)(short)(s + 1)
short s = 1;
s += 1;//沒問題,隱含了自動強制轉(zhuǎn)換
請問上面的代碼哪個有問題?
(3)比較運算符
A:==,!=,>,>=,<,<=
B:無論運算符兩端簡單還是復雜最終結(jié)果是boolean類型甥郑。
C:千萬不要把==寫成了=
(4)邏輯運算符
A:&,|,^,!,&&,||
B:邏輯運算符用于連接boolean類型的式子
C:結(jié)論
&:有false則false
|:有true則true
^:相同則false，不同則true荤西。
情侶關系澜搅。
!:非true則false，非false則true
&&:結(jié)果和&是一樣的邪锌，只不過有短路效果勉躺。左邊是false，右邊不執(zhí)行觅丰。
||:結(jié)果和|是一樣的饵溅，只不過有短路效果。左邊是true妇萄，右邊不執(zhí)行蜕企。
(5)位運算符(了解)
A:^的特殊用法
一個數(shù)據(jù)針對另一個數(shù)據(jù)位異或兩次咬荷，該數(shù)不變
B:面試題
a:請實現(xiàn)兩個變量的交換
**采用第三方變量
**用位異或運算符
左邊a,b,a
右邊a^b
b:請用最有效率的方式計算出2乘以8的結(jié)果
2<<3
(6)三元運算符
A:格式
比較表達式?表達式1:表達式2;
B:執(zhí)行流程：
首先計算比較表達式的值，看是true還是false轻掩。
如果是true幸乒，表達式1就是結(jié)果。
如果是false唇牧，表達式2就是結(jié)果罕扎。
C:案例：
a:比較兩個數(shù)據(jù)是否相等
System.out.println(a == b ? true : false);
b:獲取兩個數(shù)據(jù)中的最大值
System.out.println(a > b ? a : b);
c:獲取三個數(shù)據(jù)中的最大值
System.out.println((a>b?a:b)>c?(a>b?a:b):c);
2:鍵盤錄入(掌握)
(1)實際開發(fā)中，數(shù)據(jù)是變化的丐重，為了提高程序的靈活性腔召，我們加入鍵盤錄入數(shù)據(jù)。
(2)如何實現(xiàn)呢?目前就記住
A:導包
import java.util.Scanner;
位置：在class的上邊
B:創(chuàng)建對象
Scanner sc = new Scanner(System.in);
C:獲取數(shù)據(jù)
int x = sc.nextInt();
(3)把三元運算符的案例加入鍵盤錄入改進扮惦。
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println(a > b ? a : b);
3:流程控制語句
(1)順序結(jié)構(gòu) 從上往下宴咧，依次執(zhí)行
(2)選擇結(jié)構(gòu) 按照不同的選擇，執(zhí)行不同的代碼
(3)循環(huán)結(jié)構(gòu) 做一些重復的代碼
4:if語句(掌握)
(1)三種格式
A:格式1
if(比較表達式) {
語句體;
}
執(zhí)行流程：
判斷比較表達式的值径缅，看是true還是false
如果是true掺栅，就執(zhí)行語句體
如果是false，就不執(zhí)行語句體
B:格式2
if(比較表達式) {
語句體1;
}else {
語句體2;
}
執(zhí)行流程：
判斷比較表達式的值纳猪，看是true還是false
如果是true氧卧，就執(zhí)行語句體1
如果是false，就執(zhí)行語句體2
C:格式3
if(比較表達式1) {
語句體1;
}else if(比較表達式2){
語句體2;
}
...
else {
語句體n+1;
}
執(zhí)行流程：
判斷比較表達式1的值氏堤，看是true還是false
如果是true沙绝，就執(zhí)行語句體1
如果是false，就繼續(xù)判斷比較表達式2的值鼠锈，看是true還是false
如果是true闪檬，就執(zhí)行語句體2
如果是false，就繼續(xù)判斷比較表達式3的值购笆，看是true還是false
...
如果都不滿足粗悯，就執(zhí)行語句體n+1
(2)注意事項
A:比較表達式無論簡單還是復雜，結(jié)果是boolean類型
B:if語句控制的語句體如果是一條語句同欠，是可以省略大括號的样傍；如果是多條，不能省略铺遂。
建議：永遠不要省略衫哥。
C:一般來說，有左大括號襟锐，就沒有分號撤逢，有分號，就沒有左大括號。
D:else后面如果沒有if蚊荣，是不會出現(xiàn)比較表達式的初狰。
E:三種if語句其實都是一個語句，只要有一個執(zhí)行妇押，其他的就不再執(zhí)行。
(3)案例：
A:比較兩個數(shù)是否相等
if (a == b) {
System.out.println("a == b");
}
B:獲取兩個數(shù)中的最大值
if (a > b) {
System.out.println(a);
} else if (a < b) {
System.out.println(b);
}
C:獲取三個數(shù)中的最大值(if語句的嵌套)
if (a > b) {
if (a > c) {
System.out.println(a);
} else if (c > a) {
System.out.println(c);
} else if (b > a) {
if (b > c) {
System.out.println(b);
} else if (c > b) {
System.out.println(c);
}
}
D:根據(jù)成績輸出對應的等級
if (score > 0 && score < 60) {
System.out.println("不及格");
} else if (score >= 60 && score < 90) {
System.out.println("合格");
} else if (score >= 90 && score <= 100) {
System.out.println("優(yōu)秀");
}
E:根據(jù)月份姓迅，輸出對應的季節(jié)
F:根據(jù)x計算對應y的值并輸出
(4)三元運算符和if語句第二種格式的關系
所有的三元運算符能夠?qū)崿F(xiàn)的敲霍，if語句的第二種格式都能實現(xiàn)。
反之不成立丁存。
如果if語句第二種格式控制的語句體是輸出語句肩杈，就不可以。
因為三元運算符是一個運算符解寝，必須要有一個結(jié)果返回扩然，不能是一個輸出語句。
1:switch語句(掌握)
(1)格式：
switch(表達式) {
case 值1:
語句體1;
break;
case 值2:
語句體2;
break;
...
default:
語句體n+1;
break;
}
格式解釋說明：
switch:說明這是switch語句聋伦。
表達式:可以是byte,short,int,char
JDK5以后可以是枚舉
JDK7以后可以是字符串
case:后面的值就是要和表達式進行比較的值
break:表示程序到這里中斷夫偶，跳出switch語句
default:如果所有的情況都不匹配,就執(zhí)行這里,相當于if語句中的else
(2)面試題
switch語句的表達式可以是byte嗎?可以是long嗎?可以是String嗎?
可以,不可以,JDK7以后可以
(3)執(zhí)行流程:
A:首先計算表達式的值
B:和每一個case進行匹配，如果有就執(zhí)行對應的語句體觉增，看到break就結(jié)束兵拢。
C:如果沒有匹配，就執(zhí)行default的語句體n+1逾礁。
(4)注意事項:
A:case后面只能是常量说铃，不能是變量，而且嘹履，多個case后面的值不能出現(xiàn)相同的
B:default可以省略嗎?
可以省略腻扇，但是不建議，因為它的作用是對不正確的情況給出提示砾嫉。
特殊情況：
case就可以把值固定幼苛。
A,B,C,D
C:break可以省略嗎?
可以省略，但是結(jié)果可能不是我們想要的焕刮。
會出現(xiàn)一個現(xiàn)象：case穿透蚓峦。
最終我們建議不要省略
D:default一定要在最后嗎?
不是，可以在任意位置济锄。但是建議在最后暑椰。
E:switch語句的結(jié)束條件
a:遇到break就結(jié)束了
b:執(zhí)行到末尾就結(jié)束了
(5)案例：
A:鍵盤錄入一個數(shù)字(1-7),輸出對應的星期幾。
Scanner sc = new Scanner(System.in);
switch (sc.nextInt()) {
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("Thursday");
break;
case 5:
System.out.println("Friday");
break;
case 6:
System.out.println("Saturday");
break;
case 7:
System.out.println("Sunday");
break;
default:
System.out.println("wrong");
}
B:單項選擇題
C:鍵盤錄入一個字符串的問題
String s = sc.nextLine();
D:根據(jù)給定的月份,輸出對應的季節(jié)
(6)if語句和switch語句各自的場景
A:if
針對boolean類型的判斷
針對一個范圍的判斷
針對幾個常量的判斷
B:switch
針對幾個常量的判斷
2:循環(huán)語句(掌握)
(1)有三種:for,while,do...while
(2)for循環(huán)語句
A:格式
for(初始化語句;判斷條件語句;控制條件語句){
循環(huán)體語句;
}
執(zhí)行流程：
a:執(zhí)行初始化語句
b:執(zhí)行判斷條件語句
如果這里是true荐绝，就繼續(xù)
如果這里是false一汽，循環(huán)就結(jié)束
c:執(zhí)行循環(huán)體語句
d:執(zhí)行控制條件語句
e:回到b
B:注意事項
a:判斷條件語句無論簡單還是復雜，結(jié)果是boolean類型
b:循環(huán)體語句如果是一條，可以省略大括號召夹，但是不建議
c:有分號就沒有左大括號岩喷，有左大括號就沒有分號
C:案例
a:輸出10次HelloWorld
for (int i = 0; i < 10; i++) {
System.out.println("HelloWorld");
}
b:輸出1-10的數(shù)據(jù)
for (int i = 1; i < 11; i++) {
System.out.println(i);
}
c:輸出10-1的數(shù)據(jù)
for (int i = 10; i > 0; i--) {
System.out.println(i);
}
d:求1-10的和
int sum = 0;
for (int i = 1; i < 11; i++) {
sum += i;
}
System.out.println(sum);
e:求1-100的和,求1-100的偶數(shù)和,求1-100的奇數(shù)和
int sum = 0;
int oddSum = 0;
int evenSum = 0;
for (int i = 1; i < 101; i++) {
sum += i;
}
System.out.println("sum:" + sum);
for (int i = 1; i < 101; i+=2) {
oddSum += i;
}
System.out.println("oddSum:" + oddSum);
for (int i = 2; i < 101; i+=2) {
evenSum += i;
}
System.out.println("evenSum:" + evenSum);
f:求5的階乘
int sum = 1;
for (int i = 5; i > 0; i--) {
sum *= i;
}
System.out.println(sum);
g:在控制臺打印水仙花數(shù)(個位,十位,百位的立方和等于該數(shù))
for (int i = 100; i < 1000; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
if (Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3) == i) {
System.out.println(i);
}
}
h:統(tǒng)計水仙花個數(shù)
int flag = 0;
for (int i = 100; i < 1000; i++) {
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 100 % 10;
if (Math.pow(ge, 3) + Math.pow(shi, 3) + Math.pow(bai, 3) == i) {
flag++;
}
}
System.out.println(flag);
i:改進版的回文數(shù)
一個五位數(shù)
個位 = 萬位
十位 = 千位
個位 + 十位 + 千位 + 萬位 = 百位
for (int i = 10000; i < 100000; i++) {
int ge = i % 10;
int shi = i / 10 %10;
int bai = i / 100 % 10;
int qian = i /1000 % 10;
int wan = i / 10000 % 10;
if (ge == wan && shi == qian && (ge + shi + qian + wan) == bai) {
System.out.println(i);
}
}
j:統(tǒng)計1-1000之間同時滿足如下條件的數(shù)據(jù)有多少個
x%3==2
x%5==3
x%7==2
int flag = 0;
for (int i = 1; i < 1001; i++) {
if (i % 3 == 2 && i % 5 == 3 && i % 7 == 2) {
flag++;
}
}
System.out.println(flag);
(3)while循環(huán)
A:基本格式
while(判斷條件語句) {
循環(huán)體語句;
}
擴展格式：
初始化語句;
while(判斷條件語句){
循環(huán)體語句;
控制條件語句;
}
通過查看這個格式，我們就知道while循環(huán)可以和for循環(huán)等價轉(zhuǎn)換监憎。
B:while的練習
把for語句的練習用while改進
C:for和while的區(qū)別
a:使用上的區(qū)別
for語句的那個控制條件變量,在循環(huán)結(jié)束后不能在使用了纱意。
而while的可以繼續(xù)使用。
b:理解上的區(qū)別
for適合于一個范圍的判斷
while適合次數(shù)不明確的
舉例:吃葡萄
D:案例：
a:珠穆朗瑪峰問題
b:小芳存錢問題(break以后才能做)
(4)do...while循環(huán)
A:基本格式
do {
循環(huán)體語句;
}while(判斷條件語句);
擴展格式：
初始化語句;
do {
循環(huán)體語句;
控制條件語句;
}while(判斷條件語句);
通過查看格式鲸阔，我們就可以看出其實三種循環(huán)的格式可以是統(tǒng)一的偷霉。
B:三種循環(huán)的區(qū)別
a:do...while循環(huán)至少執(zhí)行一次循環(huán)體
b:for和while必須先判斷條件是否是true，然后后才能決定是否執(zhí)行循環(huán)體
(5)循環(huán)使用的注意事項(死循環(huán))
A:一定要注意修改控制條件,否則容易出現(xiàn)死循環(huán)褐筛。
B:最簡單的死循環(huán)格式
a:while(true){...}
b:for(;;){}
3:控制跳轉(zhuǎn)語句(掌握)
(1)break:中斷的意思
A:用在循環(huán)和switch語句中类少，離開此應用場景無意義。
B:作用
a:跳出單層循環(huán)
b:跳出多層循環(huán)渔扎，需要標簽語句的配合
(2)continue:繼續(xù)
A:用在循環(huán)中硫狞，離開此應用場景無意義。
B:作用
a:跳出單層循環(huán)的一次晃痴，可以繼續(xù)下一次
C:填空題
for(int x=1; x<=10; x++) {
if(x%3 == 0) {
//補齊代碼
}
System.out.println("Java基礎班");
}
如何讓控制臺輸出2次：Java基礎班
break;
如何讓控制臺輸出7次：Java基礎班
continue;
如何讓控制臺輸出13次：Java基礎班
System.out.println("Java基礎班");
(3)return:返回
A:用于結(jié)束方法的残吩，后面還會在繼續(xù)講解和使用。
B:一旦遇到return,程序就不會在繼續(xù)往后執(zhí)行倘核。
1:方法(掌握)
(1)方法：就是完成特定功能的代碼塊世剖。
注意：在很多語言里面有函數(shù)的定義，而在Java中笤虫，函數(shù)被稱為方法旁瘫。
(2)格式：
修飾符 返回值類型 方法名(參數(shù)類型 參數(shù)名1,參數(shù)類型 參數(shù)名2...) {
方法體語句;
return 返回值;
}
修飾符：目前就用 public static。后面再詳細講解其他修飾符
返回值類型：就是功能結(jié)果的數(shù)據(jù)類型
方法名：就是起了一個名字琼蚯，方便我們調(diào)用該方法酬凳。
參數(shù)類型：就是參數(shù)的數(shù)據(jù)類型
參數(shù)名：就是變量
參數(shù)分類：
實參：實際參與運算的數(shù)據(jù)
形參：方法上定義的，用于接收實際參數(shù)的變量
方法體語句：就是完成功能的代碼塊
return：結(jié)束方法
返回值：就是功能的結(jié)果遭庶，由return帶給調(diào)用者宁仔。
(3)兩個明確：
返回值類型：結(jié)果的數(shù)據(jù)類型
參數(shù)列表：參數(shù)的個數(shù)及對應的數(shù)據(jù)類型
(4)方法調(diào)用
A:有明確返回值的方法
a:單獨調(diào)用，沒有意義
b:輸出調(diào)用峦睡，不是很好翎苫，因為我可能需要不結(jié)果進行進一步的操作。但是講課一般我就用了榨了。
c:賦值調(diào)用煎谍，推薦方案
B:void類型修飾的方法
a:單獨調(diào)用
(5)案例：
A:求和方案
public static void sum(int a, int b) {
System.out.println("a + b = " + (a + b));
}
B:獲取兩個數(shù)中的較大值
public static void max(int a, int b) {
if (a > b) {
System.out.println(a);
} else if (b > a) {
System.out.println(b);
}
}
C:比較兩個數(shù)據(jù)是否相同
public static void isEquals(int a, int b) {
if (a == b) {
System.out.println("a == b");
}
}
D:獲取三個數(shù)中的最大值
public static void max(int a, int b, int c) {
if (a > b) {
if (a > c) {
System.out.println(a);
} else if (c > a) {
System.out.println(c);
}
} else if (b > a) {
if (b > c) {
System.out.println(b);
} else if (c > b) {
System.out.println(c);
}
}
}
E:輸出m行n列的星形
public static void printStar(int row, int column) {
for (int m = 0; m < row; m++) {
String star = "";
for (int n = 0; n < column; n++) {
star += "*";
}
System.out.println(star);
}
System.out.println("--------------");
for (int m = 0; m < row; m++) {
String star = "";
for (int n = 0; n <= m; n++) {
star += "*";
}
System.out.println(star);
}
System.out.println("---------------");
for (int m = row; m > 0; m--) {
String star = "";
for (int n = 0; n < m; n++) {
star += "*";
}
System.out.println(star);
}
}
F:輸出nn乘法表
public static void chengfabiao(int n) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(j + " * " + i + " = " + (j * i) + "\t");
}
System.out.println();
}
}
(6)方法的注意事項
A:方法不調(diào)用不執(zhí)行
B:方法之間是平級關系，不能嵌套定義
C:方法定義的時候龙屉，參數(shù)是用呐粘，隔開的
D:方法在調(diào)用的時候满俗，不用在傳遞數(shù)據(jù)類型
E:如果方法有明確的返回值類型，就必須有return語句返回作岖。
(7)方法重載
在同一個類中唆垃，方法名相同，參數(shù)列表不同痘儡。與返回值無關辕万。
參數(shù)列表不同：
參數(shù)的個數(shù)不同。
參數(shù)的對應的數(shù)據(jù)類型不同沉删。
(8)方法重載案例
不同的類型的多個同名方法的比較渐尿。
2:數(shù)組(掌握)
(1)數(shù)組：存儲同一種數(shù)據(jù)類型的多個元素的容器。
(2)特點：每一個元素都有編號丑念，從0開始涡戳，最大編號是長度-1结蟋。
編號的專業(yè)叫法：索引
(3)定義格式
A:數(shù)據(jù)類型[] 數(shù)組名;
B:數(shù)據(jù)類型 數(shù)組名[];
推薦是用A方式脯倚，B方法就忘了吧。
但是要能看懂
(4)數(shù)組的初始化
A:動態(tài)初始化
只給長度嵌屎，系統(tǒng)給出默認值
舉例：int[] arr = new int[3];
B:靜態(tài)初始化
給出值推正，系統(tǒng)決定長度
舉例：int[] arr = new int[]{1,2,3};
簡化版：int[] arr = {1,2,3};
(5)Java的內(nèi)存分配
A:棧 存儲局部變量
B:堆 存儲所有new出來的
C:方法區(qū)(面向?qū)ο蟛糠衷敿氈v解)
D:本地方法區(qū)(系統(tǒng)相關)
E:寄存器(CPU使用)
注意：
a:局部變量 在方法定義中或者方法聲明上定義的變量。
b:棧內(nèi)存和堆內(nèi)存的區(qū)別
棧：數(shù)據(jù)使用完畢宝惰，就消失植榕。
堆：每一個new出來的東西都有地址
每一個變量都有默認值
byte,short,int,long 0
float,double 0.0
char '\u0000'
boolean false
引用類型 null
數(shù)據(jù)使用完畢后，在垃圾回收器空閑的時候回收尼夺。
(6)數(shù)組內(nèi)存圖
A:一個數(shù)組
B:二個數(shù)組
C:三個數(shù)組(兩個棧變量指向同一個堆內(nèi)存)
(7)數(shù)組的常見操作
A:遍歷
方式1：
public static void printArray(int[] arr) {
for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}
}
方式2：
public static void printArray(int[] arr) {
System.out.print("[");
for(int x=0; x<arr.length; x++) {
if(x == arr.length-1) {
System.out.println(arr[x]+"]");
}else {
System.out.println(arr[x]+", ");
}
}
}
B:最值
最大值：
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;
}
最小值：
public static int getMin(int[] arr) {
int min = arr[0];
for(int x=1; x<arr.length; x++) {
if(arr[x] < min) {
min = arr[x];
}
}
return min;
}
C:逆序
方式1：
public static void reverse(int[] arr) {
for(int x=0; x<arr.length/2; x++) {
int temp = arr[x];
arr[x] = arr[arr.length-1-x];
arr[arr.length-1-x] = temp;
}
}
方式2：
public static void reverse(int[] arr) {
for(int start=0,end=arr.length-1; start<=end; start++,end--) {
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
D:查表
public static String getString(String[] strArray,int index) {
return strArray[index];
}
E:基本查找
方式1：
public static int getIndex(int[] arr,int value) {
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
return x;
}
}
return -1;
}
方式2：
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
Java面向?qū)ο?/h2>
1:成員變量和局部變量的區(qū)別(理解)
(1)在類中的位置不同
成員變量：類中方法外
局部變量：方法定義中或者方法聲明上
(2)在內(nèi)存中的位置不同
成員變量：在堆中
局部變量：在棧中
(3)生命周期不同
成員變量：隨著對象的創(chuàng)建而存在尊残，隨著對象的消失而消失
局部變量：隨著方法的調(diào)用而存在，隨著方法的調(diào)用完畢而消失
(4)初始化值不同
成員變量：有默認值
局部變量：沒有默認值淤堵，必須定義寝衫，賦值，然后才能使用
2:類作為形式參數(shù)的問題?(理解)
(1)如果你看到一個方法需要的參數(shù)是一個類名拐邪，就應該知道這里實際需要的是一個具體的對象慰毅。
3:匿名對象(理解)
(1)沒有名字的對象
(2)應用場景
A:調(diào)用方法，僅僅只調(diào)用一次的時候扎阶。
b:可以作為實際參數(shù)傳遞汹胃。
4:封裝(理解)
(1)隱藏實現(xiàn)細節(jié)，提供公共的訪問方式
(2)好處：
A:隱藏實現(xiàn)細節(jié)东臀，提供公共的訪問方式
B:提高代碼的復用性
C:提高代碼的安全性
(3)設計原則
把不想讓外界知道的實現(xiàn)細節(jié)給隱藏起來着饥，提供公共的訪問方式
(4)private是封裝的一種體現(xiàn)。
封裝：類惰赋，方法贱勃，private修飾成員變量
5:private關鍵字(掌握)
(1)私有的意義，可以修飾成員變量和成員方法
(2)特點：
被private修飾的后的成員只能在本類中被訪問
(3)private的應用：
以后再寫一個類的時候：
把所有的成員變量給private了
提供對應的getXxx()/setXxx()方法
6:this關鍵字(掌握)
(1)代表當前類的引用對象
記住：哪個對象調(diào)用方法贵扰，該方法內(nèi)部的this就代表那個對象
(2)this的應用場景：
A:解決了局部變量隱藏成員變量的問題
B:其實this還有其他的應用仇穗，明天講解。
7:構(gòu)造方法(掌握)
(1)作用：用于對對象的數(shù)據(jù)進行初始化
(2)格式：
A:方法名和類名相同
B:沒有返回值類型戚绕，連void都不能有
C:沒有返回值
思考題：構(gòu)造方法中可不可以有return語句呢?
可以纹坐。只要我們寫成這個樣子就OK了：return;
其實，在任何的void類型的方法的最后你都可以寫上：return;
(3)構(gòu)造方法的注意事項
A:如果我們沒寫構(gòu)造方法舞丛，系統(tǒng)將提供一個默認的無參構(gòu)造方法
B:如果我們給出了構(gòu)造方法耘子，系統(tǒng)將不再提供默認構(gòu)造方法
如果這個時候，我們要使用無參構(gòu)造方法球切，就必須自己給出谷誓。
推薦：永遠手動自己給出無參構(gòu)造方法。
(4)給成員變量賦值的方式
A:setXxx()
B:帶參構(gòu)造方法
(5)標準案例
class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
測試：
class StudentDemo {
public static void main(String[] args) {
//方式1
Student s1 = new Student();
s1.setName("林青霞");
s1.setAge(27);
System.out.println(s1.getName()+"---"+s1.getAge());
//方式2
Student s2 = new Student("劉意",30);
System.out.println(s2.getName()+"---"+s2.getAge());
}
}
8:代碼：Student s = new Student();做了哪些事情?(理解)
(1)把Student.class文件加載到內(nèi)存
(2)在棧內(nèi)存為s開辟空間
(3)在堆內(nèi)存為學生對象申請空間
(4)給學生的成員變量進行默認初始化吨凑。null,0
(5)給學生的成員變量進行顯示初始化捍歪。林青霞,27
(6)通過構(gòu)造方法給成員變量進行初始化。劉意,30
(7)對象構(gòu)造完畢鸵钝，把地址賦值給s變量
9:面向?qū)ο蟮木毩曨}(掌握)
(1)標準的手機類的定義和測試
(2)Demo類有求和方法糙臼，Test類進行測試。
什么時候定義成員變量?
當該變量是用來描述一個類的時候恩商。
(3)長方形案例
(4)員工案例
(5)MyMath案例(自己提供加減乘除并測試)
public class MyMath {
public MyMath() {
}
public static void add(int a, int b) {
System.out.println("add" + (a + b));
}
public static void subtract(int a, int b) {
System.out.println("subtract" + (a - b));
}
public static void multiply(int a, int b) {
System.out.println("multiply" + (a * b));
}
public static void divide(int a, int b) {
System.out.println("divide" + (a / b));
}
}
10:static關鍵字(理解)
(1)靜態(tài)的意思变逃。可以修飾成員變量和成員方法怠堪。
(2)靜態(tài)的特點：
A:隨著類的加載而加載
B:優(yōu)先于對象存在
C:被類的所有對象共享
這其實也是我們判斷該不該使用靜態(tài)的依據(jù)揽乱。
舉例：飲水機和水杯的問題思考
D:可以通過類名調(diào)用
既可以通過對象名調(diào)用，也可以通過類名調(diào)用粟矿，建議通過類名調(diào)用凰棉。
(3)靜態(tài)的內(nèi)存圖
靜態(tài)的內(nèi)容在方法區(qū)的靜態(tài)區(qū)
(4)靜態(tài)的注意事項；
A:在靜態(tài)方法中沒有this對象
B:靜態(tài)只能訪問靜態(tài)(代碼測試過)
(5)靜態(tài)變量和成員變量的區(qū)別
A:所屬不同
靜態(tài)變量：屬于類嚷炉，類變量
成員變量：屬于對象渊啰，對象變量，實例變量
B:內(nèi)存位置不同
靜態(tài)變量：方法區(qū)的靜態(tài)區(qū)
成員變量：堆內(nèi)存
C:生命周期不同
靜態(tài)變量：靜態(tài)變量是隨著類的加載而加載申屹，隨著類的消失而消失
成員變量：成員變量是隨著對象的創(chuàng)建而存在绘证，隨著對象的消失而消失
D:調(diào)用不同
靜態(tài)變量：可以通過對象名調(diào)用，也可以通過類名調(diào)用
成員變量：只能通過對象名調(diào)用
(6)main方法是靜態(tài)的
public:權(quán)限最大
static:不用創(chuàng)建對象調(diào)用
void:返回值給jvm沒有意義
main:就是一個常見的名稱哗讥。
String[] args:可以接收數(shù)據(jù)拌牲，提供程序的靈活性
格式：java MainDemo hello world java
java MainDemo 10 20 30
1:如何制作幫助文檔(了解)
(1)寫一個類
(2)加入文檔注釋
(3)通過javadoc工具生成即可
javadoc -d 目錄 -author -version ArrayTool.java
2:通過JDK提供的API學習了Math類(掌握)
(1)API(Application Programming Interface)
應用程序編程接口(幫助文檔)
(2)如何使用呢?
請參照
day08\code\02_如何使用JDK提供的幫助文檔\如何使用幫助文檔.txt
(3)Math類
A:是針對數(shù)學進行操作的類
B:沒有構(gòu)造方法氯檐，因為它的成員都是靜態(tài)的
C:產(chǎn)生隨機數(shù)
public static double random(): [0.0,1.0)
D:如何產(chǎn)生一個1-100之間的隨機數(shù)
int number = (int)(Math.random()*100)+1;
E:猜數(shù)字小游戲
3:代碼塊(理解)
(1)用{}括起來的代碼德谅。
(2)分類：
A:局部代碼塊
用于限定變量的生命周期，及早釋放腐泻，提高內(nèi)存利用率。
B:構(gòu)造代碼塊
把多個構(gòu)造方法中相同的代碼可以放到這里队询，每個構(gòu)造方法執(zhí)行前派桩，首先執(zhí)行構(gòu)造代碼塊。
C:靜態(tài)代碼塊
對類的數(shù)據(jù)進行初始化蚌斩，僅僅只執(zhí)行一次铆惑。
(3)靜態(tài)代碼塊,構(gòu)造代碼塊,構(gòu)造方法的順序問題?
靜態(tài)代碼塊 > 構(gòu)造代碼塊 > 構(gòu)造方法
4:繼承(掌握)
(1)把多個類中相同的成員給提取出來定義到一個獨立的類中。然后讓這多個類和該獨立的類產(chǎn)生一個關系员魏，
這多個類就具備了這些內(nèi)容砰盐。這個關系叫繼承列疗。
(2)Java中如何表示繼承呢?格式是什么呢?
A:用關鍵字extends表示
B:格式：
class 子類名 extends 父類名 {}
(3)繼承的好處：
A:提高了代碼的復用性
B:提高了代碼的維護性
C:讓類與類產(chǎn)生了一個關系，是多態(tài)的前提
(4)繼承的弊端：
A:讓類的耦合性增強。這樣某個類的改變，就會影響其他和該類相關的類栽烂。
原則：低耦合躏仇，高內(nèi)聚。
耦合：類與類的關系
內(nèi)聚：自己完成某件事情的能力
B:打破了封裝性
(5)Java中繼承的特點
A:Java中類只支持單繼承
B:Java中可以多層(重)繼承(繼承體系)
(6)繼承的注意事項：
A:子類不能繼承父類的私有成員
B:子類不能繼承父類的構(gòu)造方法腺办，但是可以通過super去訪問
C:不要為了部分功能而去繼承
(7)什么時候使用繼承呢?
A:繼承體現(xiàn)的是：is a的關系焰手。
B:采用假設法
(8)Java繼承中的成員關系
A:成員變量
a:子類的成員變量名稱和父類中的成員變量名稱不一樣，這個太簡單
b:子類的成員變量名稱和父類中的成員變量名稱一樣怀喉，這個怎么訪問呢?
子類的方法訪問變量的查找順序：
在子類方法的局部范圍找书妻，有就使用。
在子類的成員范圍找躬拢，有就使用躲履。
在父類的成員范圍找，有就使用聊闯。
找不到工猜，就報錯。
B:構(gòu)造方法
a:子類的構(gòu)造方法默認會去訪問父類的無參構(gòu)造方法
是為了子類訪問父類數(shù)據(jù)的初始化
b:父類中如果沒有無參構(gòu)造方法菱蔬，怎么辦?
子類通過super去明確調(diào)用帶參構(gòu)造
子類通過this調(diào)用本身的其他構(gòu)造篷帅，但是一定會有一個去訪問了父類的構(gòu)造
讓父類提供無參構(gòu)造
C:成員方法
a:子類的成員方法和父類中的成員方法名稱不一樣，這個太簡單
b:子類的成員方法和父類中的成員方法名稱一樣拴泌，這個怎么訪問呢?
通過子類對象訪問一個方法的查找順序：
在子類中找魏身，有就使用
在父類中找，有就使用
找不到弛针，就報錯
(9)兩個面試題：
A:Override和Overload的區(qū)別?Overload是否可以改變返回值類型?
B:this和super的區(qū)別和各自的作用?
(10)數(shù)據(jù)初始化的面試題
A:一個類的初始化過程
B:子父類的構(gòu)造執(zhí)行過程
C:分層初始化
(11)案例：
A:學生和老師案例
繼承前
繼承后
B:貓狗案例的分析和實現(xiàn)
1:final關鍵字(掌握)
(1)是最終的意思叠骑，可以修飾類，方法削茁，變量宙枷。
(2)特點：
A:它修飾的類掉房，不能被繼承。
B:它修飾的方法慰丛，不能被重寫卓囚。
C:它修飾的變量，是一個常量诅病。
(3)面試相關：
A:局部變量
a:基本類型 值不能發(fā)生改變
b:引用類型 地址值不能發(fā)生改變哪亿，但是對象的內(nèi)容是可以改變的
B:初始化時機
a:只能初始化一次。
b:常見的給值
定義的時候贤笆。(推薦)
構(gòu)造方法中蝇棉。
2:多態(tài)(掌握)
(1)同一個對象在不同時刻體現(xiàn)出來的不同狀態(tài)。
(2)多態(tài)的前提：
A:有繼承或者實現(xiàn)關系芥永。
B:有方法重寫篡殷。
C:有父類或者父接口引用指向子類對象。
多態(tài)的分類：
a:具體類多態(tài)
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象類多態(tài)
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多態(tài)
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多態(tài)中的成員訪問特點
A:成員變量
編譯看左邊埋涧，運行看左邊
B:構(gòu)造方法
子類的構(gòu)造都會默認訪問父類構(gòu)造
C:成員方法
編譯看左邊板辽，運行看右邊
D:靜態(tài)方法
編譯看左邊，運行看左邊
為什么?
因為成員方法有重寫棘催。
(4)多態(tài)的好處：
A:提高代碼的維護性(繼承體現(xiàn))
B:提高代碼的擴展性(多態(tài)體現(xiàn))
(5)多態(tài)的弊端：
父不能使用子的特有功能劲弦。
現(xiàn)象：
子可以當作父使用，父不能當作子使用醇坝。
(6)多態(tài)中的轉(zhuǎn)型
A:向上轉(zhuǎn)型
從子到父
B:向下轉(zhuǎn)型
從父到子
(7)孔子裝爹的案例幫助大家理解多態(tài)
(8)多態(tài)的練習
A:貓狗案例
B:老師和學生案例
3:抽象類(掌握)
(1)把多個共性的東西提取到一個類中邑跪，這是繼承的做法。
但是呢纲仍，這多個共性的東西呀袱，在有些時候贸毕，方法聲明一樣郑叠，但是方法體。
也就是說明棍，方法聲明一樣乡革，但是每個具體的對象在具體實現(xiàn)的時候內(nèi)容不一樣。
所以摊腋，我們在定義這些共性的方法的時候沸版，就不能給出具體的方法體。
而一個沒有具體的方法體的方法是抽象的方法兴蒸。
在一個類中如果有抽象方法视粮，該類必須定義為抽象類。
(2)抽象類的特點
A:抽象類和抽象方法必須用關鍵字abstract修飾
B:抽象類中不一定有抽象方法,但是有抽象方法的類一定是抽象類
C:抽象類不能實例化
D:抽象類的子類
a:是一個抽象類橙凳。
b:是一個具體類蕾殴。這個類必須重寫抽象類中的所有抽象方法笑撞。
(3)抽象類的成員特點：
A:成員變量
有變量，有常量
B:構(gòu)造方法
有構(gòu)造方法
C:成員方法
有抽象钓觉，有非抽象
(4)抽象類的練習
A:貓狗案例練習
B:老師案例練習
C:學生案例練習
D:員工案例練習
(5)抽象類的幾個小問題
A:抽象類有構(gòu)造方法茴肥，不能實例化，那么構(gòu)造方法有什么用?
用于子類訪問父類數(shù)據(jù)的初始化
B:一個類如果沒有抽象方法,卻定義為了抽象類荡灾，有什么用?
為了不讓創(chuàng)建對象
C:abstract不能和哪些關鍵字共存
a:final 沖突
b:private 沖突
c:static 無意義
4:接口(掌握)
(1)回顧貓狗案例瓤狐，它們僅僅提供一些基本功能。
比如：貓鉆火圈批幌，狗跳高等功能础锐，不是動物本身就具備的，
是在后面的培養(yǎng)中訓練出來的荧缘，這種額外的功能郁稍，java提供了接口表示。
(2)接口的特點：
A:接口用關鍵字interface修飾
interface 接口名 {}
B:類實現(xiàn)接口用implements修飾
class 類名 implements 接口名 {}
C:接口不能實例化
D:接口的實現(xiàn)類
a:是一個抽象類胜宇。
b:是一個具體類耀怜，這個類必須重寫接口中的所有抽象方法。
(3)接口的成員特點：
A:成員變量
只能是常量
默認修飾符：public static final
B:構(gòu)造方法
沒有構(gòu)造方法
C:成員方法
只能是抽象的
默認修飾符：public abstract
(4)類與類,類與接口,接口與接口
A:類與類
繼承關系桐愉，只能單繼承财破，可以多層繼承
B:類與接口
實現(xiàn)關系，可以單實現(xiàn)从诲，也可以多實現(xiàn)左痢。
還可以在繼承一個類的同時，實現(xiàn)多個接口
C:接口與接口
繼承關系系洛，可以單繼承俊性，也可以多繼承
(5)抽象類和接口的區(qū)別(自己補齊)?
A:成員區(qū)別
抽象類：可以是變量可以是常量
接口：只能是常量
B:關系區(qū)別:
類與類：繼承
類與接口：實現(xiàn)
接口與接口：繼承
C:設計理念不同
抽象類：is a，抽象類中定義的是共性功能描扯。
接口：like a定页，接口中定義的是擴展功能。
(6)練習：
A:貓狗案例绽诚，加入跳高功能
B:老師和學生案例典徊，加入抽煙功能0
1:形式參數(shù)和返回值的問題(理解)
(1)形式參數(shù)：
類名：需要該類的對象
抽象類名：需要該類的子類對象
接口名：需要該接口的實現(xiàn)類對象
(2)返回值類型：
類名：返回的是該類的對象
抽象類名：返回的是該類的子類對象
接口名：返回的是該接口的實現(xiàn)類的對象
(3)鏈式編程
對象.方法1().方法2().......方法n();
這種用法：其實在方法1()調(diào)用完畢后，應該一個對象恩够；
方法2()調(diào)用完畢后卒落，應該返回一個對象。
方法n()調(diào)用完畢后蜂桶，可能是對象儡毕，也可以不是對象。
2:包(理解)
(1)其實就是文件夾
(2)作用：
A:區(qū)分同名的類
B:對類進行分類管理
a:按照功能分
b:按照模塊分
(3)包的定義(掌握)
package 包名;
多級包用.分開扑媚。
(4)注意事項：(掌握)
A:package語句必須在文件中的第一條有效語句
B:在一個java文件中腰湾，只能有一個package
C:如果沒有package贾费，默認就是無包名
(5)帶包的編譯和運行
A:手動式
B:自動式(掌握)
javac -d . HelloWorld.java
3:導包(掌握)
(1)我們多次使用一個帶包的類，非常的麻煩檐盟，這個時候褂萧，Java就提供了一個關鍵字import。
(2)格式：
import 包名...類名;
另一種：
import 包名...*;(不建議)
(3)package,import,class的順序
package > import > class
4:權(quán)限修飾符(掌握)
(1)權(quán)限修飾符
本類 同一個包下 不同包下的子類 不同包下的無關類
private Y
默認 Y Y
protected Y Y Y
public Y Y Y Y
(2)這四種權(quán)限修飾符在任意時刻只能出現(xiàn)一種葵萎。
public class Demo {}
5:常見的修飾符(理解)
(1)分類：
權(quán)限修飾符：private,默認,protected,public
狀態(tài)修飾符：static,final
抽象修飾符：abstract
(2)常見的類及其組成的修飾
類：
默認,public,final,abstract
常用的：public
成員變量：
private,默認,protected,public,static,final
常用的：private
構(gòu)造方法：
private,默認,protected,public
常用的：public
成員方法：
private,默認,protected,public,static,final,abstract
常用的：public
(3)另外比較常見的：
public static final int X = 10;
public static void show() {}
public final void show() {}
public abstract void show();
6:內(nèi)部類(理解)
(1)把類定義在另一個類的內(nèi)部导犹，該類就被稱為內(nèi)部類。
舉例：把類B定義在類A中羡忘，類B就被稱為內(nèi)部類谎痢。
(2)內(nèi)部類的訪問規(guī)則
A:可以直接訪問外部類的成員，包括私有
B:外部類要想訪問內(nèi)部類成員卷雕，必須創(chuàng)建對象
(3)內(nèi)部類的分類
A:成員內(nèi)部類
B:局部內(nèi)部類
(4)成員內(nèi)部類
A:private 為了數(shù)據(jù)的安全性
B:static 為了訪問的方便性
成員內(nèi)部類不是靜態(tài)的：
外部類名.內(nèi)部類名 對象名 = new 外部類名.new 內(nèi)部類名();
成員內(nèi)部類是靜態(tài)的：
外部類名.內(nèi)部類名 對象名 = new 外部類名.內(nèi)部類名();
(5)成員內(nèi)部類的面試題(填空)
30,20,10
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public viod show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
(6)局部內(nèi)部類
A:局部內(nèi)部類訪問局部變量必須加final修飾节猿。
B:為什么呢?
因為局部變量使用完畢就消失，而堆內(nèi)存的數(shù)據(jù)并不會立即消失漫雕。
所以滨嘱，堆內(nèi)存還是用該變量，而改變量已經(jīng)沒有了浸间。
為了讓該值還存在太雨，就加final修飾。
通過反編譯工具我們看到了魁蒜，加入final后囊扳，堆內(nèi)存直接存儲的是值，而不是變量名兜看。
(7)匿名內(nèi)部類(掌握)
A:是局部內(nèi)部類的簡化形式
B:前提
存在一個類或者接口
C:格式:
new 類名或者接口名() {
重寫方法;
}
D:本質(zhì)：
其實是繼承該類或者實現(xiàn)接口的子類匿名對象
(8)匿名內(nèi)部類在開發(fā)中的使用
我們在開發(fā)的時候锥咸，會看到抽象類，或者接口作為參數(shù)细移。
而這個時候搏予，我們知道實際需要的是一個子類對象。
如果該方法僅僅調(diào)用一次葫哗，我們就可以使用匿名內(nèi)部類的格式簡化缔刹。
interface Person {
public abstract void study();
}
class PersonDemo {
public void method(Person p) {
p.study();
}
}
class PersonTest {
public static void main(String[] args) {
PersonDemo pd = new PersonDemo();
pd.method(new Person() {
public void study() {
System.out.println("好好學習，天天向上");
}
});
}
}
(9)匿名內(nèi)部類的面試題(補齊代碼)
interface Inter {
void show();
}
class Outer {
public static Inter method() {
return new Inter() {
public void show() {
System.out.println("HelloWorld");
}
};
}
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show(); //"HelloWorld"
}
}
Java開發(fā)工具
1:Eclipse的概述使用(掌握)
請參照ppt和課堂練習.txt
2:API的概述(了解)
(1)應用程序編程接口劣针。
(2)就是JDK提供給我們的一些提高編程效率的java類。
3:Object類(掌握)
(1)Object是類層次結(jié)構(gòu)的根類亿扁，所有的類都直接或者間接的繼承自Object類捺典。
(2)Object類的構(gòu)造方法有一個，并且是無參構(gòu)造
這其實就是理解當時我們說過从祝，子類構(gòu)造方法默認訪問父類的構(gòu)造是無參構(gòu)造
(3)要掌握的方法：
A:toString()
返回對象的字符串表示襟己，默認是由類的全路徑+'@'+哈希值的十六進制表示引谜。
這個表示其實是沒有意義的，一般子類都會重寫該方法擎浴。
如何重寫呢?過程我也講解過了员咽，基本上就是要求信息簡單明了。
但是最終還是自動生成贮预。
B:equals()
比較兩個對象是否相同贝室。默認情況下，比較的是地址值是否相同仿吞。
而比較地址值是沒有意義的滑频，所以，一般子類也會重寫該方法唤冈。
重寫過程峡迷，我也詳細的講解和分析了。
但是最終還是自動生成你虹。
(4)要了解的方法：
A:hashCode() 返回對象的哈希值绘搞。不是實際地址值，可以理解為地址值傅物。
B:getClass() 返回對象的字節(jié)碼文件對象看杭，反射中我們會詳細講解
C:finalize() 用于垃圾回收，在不確定的時間
D:clone() 可以實現(xiàn)對象的克隆挟伙，包括成員變量的數(shù)據(jù)復制楼雹，但是它和兩個引用指向同一個對象是有區(qū)別的。
(5)兩個注意問題尖阔；
A:直接輸出一個對象名稱贮缅，其實默認調(diào)用了該對象的toString()方法。
B:面試題
==和equals()的區(qū)別?
A:==
基本類型：比較的是值是否相同
引用類型：比較的是地址值是否相同
B:equals()
只能比較引用類型介却。默認情況下谴供，比較的是地址值是否相同。
但是齿坷，我們可以根據(jù)自己的需要重寫該方法桂肌。
Java常見對象
1:Scanner的使用(了解)
(1)在JDK5以后出現(xiàn)的用于鍵盤錄入數(shù)據(jù)的類。
(2)構(gòu)造方法：
A:講解了System.in這個東西永淌。
它其實是標準的輸入流,對應于鍵盤錄入
B:構(gòu)造方法
InputStream is = System.in;
Scanner(InputStream is)
C:常用的格式
Scanner sc = new Scanner(System.in);
(3)基本方法格式：
A:hasNextXxx() 判斷是否是某種類型的
B:nextXxx() 返回某種類型的元素
(4)要掌握的兩個方法
A:public int nextInt()
B:public String nextLine()
(5)需要注意的小問題
A:同一個Scanner對象崎场，先獲取數(shù)值，再獲取字符串會出現(xiàn)一個小問題遂蛀。
B:解決方案：
a:重新定義一個Scanner對象
b:把所有的數(shù)據(jù)都用字符串獲取谭跨，然后再進行相應的轉(zhuǎn)換
2:String類的概述和使用(掌握)
(1)多個字符組成的一串數(shù)據(jù)。
其實它可以和字符數(shù)組進行相互轉(zhuǎn)換。
(2)構(gòu)造方法：
A:public String()
B:public String(byte[] bytes)
C:public String(byte[] bytes,int offset,int length)
D:public String(char[] value)
E:public String(char[] value,int offset,int count)
F:public String(String original)
下面的這一個雖然不是構(gòu)造方法螃宙，但是結(jié)果也是一個字符串對象
G:String s = "hello";
(3)字符串的特點
A:字符串一旦被賦值蛮瞄，就不能改變。
注意：這里指的是字符串的內(nèi)容不能改變谆扎，而不是引用不能改變挂捅。
B:字面值作為字符串對象和通過構(gòu)造方法創(chuàng)建對象的不同
String s = new String("hello");和String s = "hello"的區(qū)別?
new String("hello")會在堆內(nèi)存開辟空間,另一種不會,但是最終的值都在字符串緩存區(qū).
(4)字符串的面試題(看程序?qū)懡Y(jié)果)
A:==和equals()
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2);// false
System.out.println(s1.equals(s2));// true
String s3 = new String("hello");
String s4 = "hello";
System.out.println(s3 == s4);// false
System.out.println(s3.equals(s4));// true
String s5 = "hello";
String s6 = "hello";
System.out.println(s5 == s6);// true(常量會先去緩存區(qū)找,存在就不創(chuàng)建新的對象)
System.out.println(s5.equals(s6));// true
B:字符串的拼接
String s1 = "hello";
String s2 = "world";
String s3 = "helloworld";
System.out.println(s3 == s1 + s2);// false
System.out.println(s3.equals((s1 + s2)));// true
System.out.println(s3 == "hello" + "world");// false 這個我們錯了，應該是true
System.out.println(s3.equals("hello" + "world"));// true
(5)字符串的功能(自己補齊方法中文意思)
A:判斷功能
boolean equals(Object obj)
boolean equalsIgnoreCase(String str)
boolean contains(String str)
boolean startsWith(String str)
boolean endsWith(String str)
boolean isEmpty()
B:獲取功能
int length()
char charAt(int index)
int indexOf(int ch)
int indexOf(String str)
int indexOf(int ch,int fromIndex)
int indexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
C:轉(zhuǎn)換功能
byte[] getBytes()
char[] toCharArray()
static String valueOf(char[] chs)
static String valueOf(int i)
String toLowerCase()
String toUpperCase()
String concat(String str)
D:其他功能
a:替換功能
String replace(char old,char new)
String replace(String old,String new)
b:去空格功能
String trim()
c:按字典比較功能
int compareTo(String str)
int compareToIgnoreCase(String str)
(6)字符串的案例
A:模擬用戶登錄
public static void login(String userName, String passwd) {
if (userName == "Xmos" && passwd == "123") {
System.out.println("login success");
}
}
B:字符串遍歷
public static void printString(String s) {
char[] c = s.toCharArray();
for (int i = 0; i < c.length; i++) {
System.out.print(c[i]);
}
}
C:統(tǒng)計字符串中大寫堂湖，小寫及數(shù)字字符的個數(shù)
public static void method(String s) {
char[] c = s.toCharArray();
int lowerCaseNum = 0;
int upperCaseNum = 0;
int num = 0;
for (char c1 : c) {
if (c1 >= 'a' && c1 <= 'z') {
lowerCaseNum++;
} else if (c1 >= 'A' && c1 <= 'Z') {
upperCaseNum++;
} else if (c1 >= '0' && c1 <= '9') {
num++;
}
}
D:把字符串的首字母轉(zhuǎn)成大寫闲先，其他小寫
public static void method1(String s) {
String s1 = s.substring(0, 1);
String s2 = s.substring(1, s.length());
String s3 = s1.toUpperCase() + s2.toLowerCase();
System.out.println(s3);
}
E:把int數(shù)組拼接成一個指定格式的字符串
//方法一
public static void method3(int[] i) {
String s = Arrays.toString(i);
System.out.println(s);
}
//方法二
public static void method3(int[] i) {
String s = "";
for (int i1 : i) {
s += String.valueOf(i1);
}
System.out.println(s);
}
F:字符串反轉(zhuǎn)
public static void revers(String s) {
char[] c = s.toCharArray();
for (int i = 0; i < c.length / 2; i++) {
char tmp = c[i];
c[i] = c[c.length - 1 - i];
c[c.length - 1 - i] = tmp;
}
System.out.println(String.valueOf(c));
}
G:統(tǒng)計大串中小串出現(xiàn)的次數(shù)
1:StringBuffer(掌握)
(1)用字符串做拼接，比較耗時并且也耗內(nèi)存苗缩，而這種拼接操作又是比較常見的饵蒂，為了解決這個問題，Java就提供了
一個字符串緩沖區(qū)類酱讶。StringBuffer供我們使用退盯。
(2)StringBuffer的構(gòu)造方法
A:StringBuffer()
B:StringBuffer(int size)
C:StringBuffer(String str)
(3)StringBuffer的常見功能(自己補齊方法的聲明和方法的解釋)
A:添加功能
appen();
B:刪除功能
delete();
C:替換功能
replace()
D:反轉(zhuǎn)功能
reverse()
E:截取功能(注意這個返回值)
String substring()
(4)StringBuffer的練習(做一遍)
A:String和StringBuffer相互轉(zhuǎn)換
String -- StringBuffer
構(gòu)造方法
StringBuffer -- String
toString()方法
B:字符串的拼接
StringBuffer sb = new StringBuffer("hello");
StringBuffer sb2 = new StringBuffer("world");
StringBuffer sb3 = sb.append(sb2);
C:把字符串反轉(zhuǎn)
StringBuffer sb = new StringBuffer("abc");
StringBuffer sb1 = sb.reverse();
D:判斷一個字符串是否對稱
public static void method(StringBuffer sb) {
if (sb.toString().equals(sb.reverse().toString())) {
System.out.println(true);
} else {
System.out.println(false);
}
}
(5)面試題
小細節(jié)：
StringBuffer：同步的，數(shù)據(jù)安全泻肯，效率低渊迁。
StringBuilder：不同步的，數(shù)據(jù)不安全灶挟，效率高琉朽。
A:String,StringBuffer,StringBuilder的區(qū)別
String 字符串常量
StringBuffer 字符串變量（線程安全）
StringBuilder 字符串變量（非線程安全）
B:StringBuffer和數(shù)組的區(qū)別?
StringBuffer : 可以存放任意類型的數(shù)據(jù)
數(shù)組 : 只能存放同類型的數(shù)據(jù)
(6)注意的問題：
String作為形式參數(shù)，StringBuffer作為形式參數(shù)稚铣。
String : 不會受影響
StringBuffer : 除了=操作箱叁，其他操作會受影響
2:數(shù)組高級以及Arrays(掌握)
(1)排序
A:冒泡排序
相鄰元素兩兩比較，大的往后放惕医，第一次完畢耕漱，最大值出現(xiàn)在了最大索引處。同理抬伺，其他的元素就可以排好螟够。
public static void bubbleSort(int[] arr) {
for(int x=0; x<arr.length-1; x++) {
for(int y=0; y<arr.length-1-x; y++) {
if(arr[y] > arr[y+1]) {
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+1] = temp;
}
}
}
}
B:選擇排序
把0索引的元素，和索引1以后的元素都進行比較峡钓，第一次完畢妓笙，最小值出現(xiàn)在了0索引。同理能岩，其他的元素就可以排好寞宫。
public static void selectSort(int[] arr) {
for(int x=0; x<arr.length-1; x++) {
for(int y=x+1; y<arr.length; y++) {
if(arr[y] < arr[x]) {
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}
}
(2)查找
A:基本查找
針對數(shù)組無序的情況
public static int getIndex(int[] arr,int value) {
int index = -1;
for(int x=0; x<arr.length; x++) {
if(arr[x] == value) {
index = x;
break;
}
}
return index;
}
B:二分查找(折半查找)
針對數(shù)組有序的情況(千萬不要先排序，在查找)
public static int binarySearch(int[] arr,int value) {
int min = 0;
int max = arr.length-1;
int mid = (min+max)/2;
while(arr[mid] != value) {
if(arr[mid] > value) {
max = mid - 1;
}else if(arr[mid] < value) {
min = mid + 1;
}
if(min > max) {
return -1;
}
mid = (min+max)/2;
}
return mid;
}
(3)Arrays工具類
A:是針對數(shù)組進行操作的工具類捧灰。包括排序和查找等功能淆九。
B:要掌握的方法(自己補齊方法)
把數(shù)組轉(zhuǎn)成字符串：
Arrays.toString();
排序：
Arrays.sort();
二分查找：
Arrays.binarySearch();
(4)Arrays工具類的源碼解析
(5)把字符串中的字符進行排序
舉例：
"edacbgf"
得到結(jié)果
"abcdefg"
String s = "edacbgf";
char[] c = s.toCharArray();
Arrays.sort(c);
System.out.println(Arrays.toString(c));
3:Integer(掌握)
(1)為了讓基本類型的數(shù)據(jù)進行更多的操作统锤，Java就為每種基本類型提供了對應的包裝類類型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
(2)Integer的構(gòu)造方法
A:Integer i = new Integer(100);
B:Integer i = new Integer("100");
注意：這里的字符串必須是由數(shù)字字符組成
(3)String和int的相互轉(zhuǎn)換
A:String -- int
Integer.parseInt("100");
B:int -- String
String.valueOf(100);
(4)其他的功能(了解)
進制轉(zhuǎn)換
Integer.toBinaryString();
Integer.toHexString();
Integer.toOctalString();
(5)JDK5的新特性
自動裝箱 基本類型--引用類型
自動拆箱 引用類型--基本類型
把下面的這個代碼理解即可：
Integer i = 100;
i += 200;
(6)面試題
-128到127之間的數(shù)據(jù)緩沖池問題
4:Character(了解)
(1)Character構(gòu)造方法
Character ch = new Character('a');
(2)要掌握的方法：(自己補齊)
A:判斷給定的字符是否是大寫
isUpperCase();
B:判斷給定的字符是否是小寫
isLowerCase();
C:判斷給定的字符是否是數(shù)字字符
isDigit();
D:把給定的字符轉(zhuǎn)成大寫
toUpperCase();
E:把給定的字符轉(zhuǎn)成小寫
toLowerCase();
(3)案例：
統(tǒng)計字符串中大寫毛俏，小寫及數(shù)字字符出現(xiàn)的次數(shù)
String s = "abcDEF123";
char[] c = s.toCharArray();
int lowerCaseNum = 0;
int upperCaseNum = 0;
int digitNum = 0;
for (char c1 : c) {
if (Character.isLowerCase(c1)) {
lowerCaseNum++;
} else if (Character.isUpperCase(c1)) {
upperCaseNum++;
} else if (Character.isDigit(c1)) {
digitNum++;
}
}
System.out.println("lowerCase:" + lowerCaseNum + "\t" + "upperCase:" + upperCaseNum + "\t" + "digit:" + digitNum);
1:正則表達式(理解)
(1)就是符合一定規(guī)則的字符串
(2)常見規(guī)則
A:字符
x 字符 x炭庙。舉例：'a'表示字符a
\\ 反斜線字符。
\n 新行（換行）符 ('\u000A')
\r 回車符 ('\u000D')
B:字符類
[abc] a煌寇、b 或 c（簡單類）
[^abc] 任何字符焕蹄，除了 a、b 或 c（否定）
[a-zA-Z] a到 z 或 A到 Z阀溶，兩頭的字母包括在內(nèi)（范圍）
[0-9] 0到9的字符都包括
C:預定義字符類
. 任何字符腻脏。我的就是.字符本身，怎么表示呢? \.
\d 數(shù)字：[0-9]
\w 單詞字符：[a-zA-Z_0-9]
在正則表達式里面組成單詞的東西必須有這些東西組成
D:邊界匹配器
^ 行的開頭
$ 行的結(jié)尾
\b 單詞邊界
就是不是單詞字符的地方银锻。
舉例：hello world?haha;xixi
E:Greedy 數(shù)量詞
X? X永品，一次或一次也沒有
X* X，零次或多次
X+ X击纬，一次或多次
X{n} X鼎姐，恰好 n 次
X{n,} X，至少 n 次
X{n,m} X更振，至少 n 次炕桨，但是不超過 m 次
(3)常見功能：(分別用的是誰呢?)
A:判斷功能
String類的public boolean matches(String regex)
B:分割功能
String類的public String[] split(String regex)
C:替換功能
String類的public String replaceAll(String regex,String replacement)
D:獲取功能
Pattern和Matcher
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
find():查找存不存在
group():獲取剛才查找過的數(shù)據(jù)
(4)案例
A:判斷電話號碼和郵箱
//普安段郵箱
public static boolean checkMail(String s){
String regex = "\\d*\\w*@sina\\.com";
return s.matches(regex);
}
//判斷電話號碼
public static boolean checkPhoneNum(String s) {
String regex = "\\d{11}";
return s.matches(regex);
}
B:按照不同的規(guī)則分割數(shù)據(jù)
public static String[] split(String s) {
String regex = ",";
String[] result = s.split(regex);
return result;
}
C:把論壇中的數(shù)字替換為*
//替換為和數(shù)字等量的*
public static String replaceStar(String s) {
String regex = "\\d";
return s.replaceAll(regex, "*");
}
//所有相連數(shù)字替換為一個*
public static String replaceStar(String s) {
String regex = "\\d+";
return s.replaceAll(regex, "*");
}
D:獲取字符串中由3個字符組成的單詞
public static List<String> method(String s) {
Pattern p = Pattern.compile("a\\d{3}b");
Matcher m = p.matcher(s);
List<String> result = new ArrayList<String>();
while (m.find()) {
result.add(m.group());
}
return result;
}
2:Math(掌握)
(1)針對數(shù)學運算進行操作的類
(2)常見方法(自己補齊)
A:絕對值
Math.abs();
B:向上取整
Math.ceil();
C:向下取整
Math.floor();
D:兩個數(shù)據(jù)中的大值
Math.max();
E:a的b次冪
Math.pow(a, b);
F:隨機數(shù)
Math.random();
G:四舍五入
Math.round();
H:正平方根
Math.sqrt();
(3)案例：
A:猜數(shù)字小游戲
Scanner sc = new Scanner(System.in);
int i = (int)(Math.random() * 100) + 1;
int answer;
while ((answer = sc.nextInt()) != i) {
if (answer > i) {
System.out.println("bigger than result,go on");
} else if (answer < i) {
System.out.println("smaller than result,go on");
}
}
System.out.println("you are right");
B:獲取任意范圍的隨機數(shù)
Scanner sc = new Scanner(System.in);
System.out.println("請輸入起始:");
int start = sc.nextInt();
System.out.println("請輸入結(jié)束:");
int end = sc.nextInt();
int i = (int)(Math.random() * (end - start)) + start;
System.out.println(i);
3:Random(理解)
(1)用于產(chǎn)生隨機數(shù)的類
(2)構(gòu)造方法:
A:Random() 默認種子，每次產(chǎn)生的隨機數(shù)不同
B:Random(long seed) 指定種子肯腕，每次種子相同献宫，隨機數(shù)就相同
(3)成員方法:
A:int nextInt() 返回int范圍內(nèi)的隨機數(shù)
B:int nextInt(int n) 返回[0,n)范圍內(nèi)的隨機數(shù)
4:System(掌握)
(1)系統(tǒng)類,提供了一些有用的字段和方法
(2)成員方法(自己補齊)
A:運行垃圾回收器
System.gc();
B:退出jvm
System.exit(0);
C:獲取當前時間的毫秒值
System.currentTimemillis();
D:數(shù)組復制
System.arraycopy();
5:BigInteger(理解)
(1)針對大整數(shù)的運算
(2)構(gòu)造方法
A:BigInteger(String s)
(3)成員方法(自己補齊)
A:加
add();
B:減
subtract();
C:乘
multiply();
D:除
divide();
E:商和余數(shù)
divideAndRemainder();
6:BigDecimal(理解)
(1)浮點數(shù)據(jù)做運算，會丟失精度实撒。所以姊途，針對浮點數(shù)據(jù)的操作建議采用BigDecimal。(金融相關的項目)
(2)構(gòu)造方法
A:BigDecimal(String s)
(3)成員方法：
A:加
add();
B:減
subtract();
C:乘
multiply();
D:除
divide();
E:自己保留小數(shù)幾位
setScale();
7:Date/DateFormat(掌握)
(1)Date是日期類知态，可以精確到毫秒捷兰。
A:構(gòu)造方法
Date()
Date(long time)
B:成員方法
getTime()
setTime(long time)
C:日期和毫秒值的相互轉(zhuǎn)換
案例：你來到這個世界多少天了?
(2)DateFormat針對日期進行格式化和針對字符串進行解析的類，但是是抽象類肴甸，所以使用其子類SimpleDateFormat
A:SimpleDateFormat(String pattern) 給定模式
yyyy-MM-dd HH:mm:ss
B:日期和字符串的轉(zhuǎn)換
a:Date -- String
format()
b:String -- Date
parse()
C:案例：
制作了一個針對日期操作的工具類寂殉。
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(d));
8:Calendar(掌握)
(1)日歷類，封裝了所有的日歷字段值原在，通過統(tǒng)一的方法根據(jù)傳入不同的日歷字段可以獲取值友扰。
(2)如何得到一個日歷對象呢?
Calendar rightNow = Calendar.getInstance();
本質(zhì)返回的是子類對象
(3)成員方法
A:根據(jù)日歷字段得到對應的值
Calendar c =Calendar.getInstance();
System.out.println(c.get(Calendar.YEAR));
System.out.println(c.get(Calendar.MONTH));
System.out.println(c.get(Calendar.DAY_OF_MONTH));
B:根據(jù)日歷字段和一個正負數(shù)確定是添加還是減去對應日歷字段的值
add(Calendar.DAY_OF_MONTH, +3);
C:設置日歷對象的年月日
set(2018,5,30);
set(Calendar.YEAR, 2018);
set(Calendar.MONTH, 2018);
set(Calendar.DAY_OF_MONTH, 2018);
(4)案例：
計算任意一年的2月份有多少天?
Scanner sc = new Scanner(System.in);
Calendar c =Calendar.getInstance();
c.set(Calendar.YEAR, sc.nextInt());
System.out.println(c.get(Calendar.DAY_OF_MONTH));
Java集合框架
JavaIO流
1:異常(理解)
(1)程序出現(xiàn)的不正常的情況。
(2)異常的體系
Throwable
|--Error 嚴重問題庶柿，我們不處理村怪。
|--Exception
|--RuntimeException 運行期異常，我們需要修正代碼
|--非RuntimeException 編譯期異常浮庐，必須處理的甚负，否則程序編譯不通過
(3)異常的處理：
A:JVM的默認處理
把異常的名稱,原因,位置等信息輸出在控制臺柬焕，但是程序不能繼續(xù)執(zhí)行了。
B:自己處理
a:try...catch...finally
自己編寫處理代碼,后面的程序可以繼續(xù)執(zhí)行
b:throws
把自己處理不了的梭域，在方法上聲明斑举，告訴調(diào)用者，這里有問題
(4)面試題
A:編譯期異常和運行期異常的區(qū)別?
編譯期異常 必須要處理的病涨，否則編譯不通過
運行期異常 可以不處理富玷，也可以處理
B:throw和throws是的區(qū)別
throw:
在方法體中,后面跟的是異常對象名,并且只能是一個
throw拋出的是一個異常對象，說明這里肯定有一個異常產(chǎn)生了
throws:
在方法聲明上,后面跟的是異常的類名,可以是多個
throws是聲明方法有異常既穆，是一種可能性赎懦，這個異常并不一定會產(chǎn)生
(5)finally關鍵字及其面試題
A:finally用于釋放資源，它的代碼永遠會執(zhí)行幻工。特殊情況：在執(zhí)行到finally之前jvm退出了
B:面試題
a:final,finally,finalize的區(qū)別?
final : 關鍵字,修飾類励两、方法、變量,被修飾的類無法被繼承,方法無法重寫,變量值不能改變.
finally : try...catch...finally,一定會執(zhí)行.
finalize : 對象被垃圾回收器回收時執(zhí)行的方法.
b:如果在catch里面有return,請問finally還執(zhí)行嗎?如果執(zhí)行,在return前還是后
會囊颅，前当悔。
實際上在中間。這個上課我們講過
C:異常處理的變形
try...catch...finally
try...catch...
try...catch...catch...
try...catch...catch...fianlly
try...finally
(6)自定義異常
繼承自Exception或者RuntimeException,只需要提供無參構(gòu)造和一個帶參構(gòu)造即可
public class MyException extends RuntimeException {
public MyException(String message) {
super(message);
}
public MyException() {
super();
}
}
(7)異常的注意實現(xiàn)
A:父的方法有異常拋出,子的重寫方法在拋出異常的時候必須要小于等于父的異常
B:父的方法沒有異常拋出,子的重寫方法不能有異常拋出
C:父的方法拋出多個異常,子的重寫方法必須比父少或者小
2:File(掌握)
(1)IO流操作中大部分都是對文件的操作迁酸，所以Java就提供了File類供我們來操作文件
(2)構(gòu)造方法
A:File file = new File("e:\\demo\\a.txt");
B:File file = new File("e:\\demo","a.txt");
C:File file = new File("e:\\demo");
File file2 = new File(file,"a.txt");
(3)File類的功能(自己補齊)
A:創(chuàng)建功能
createNewFile();
mkdir();
mkdirs();
B:刪除功能
delete();
C:重命名功能
renameTo();
D:判斷功能
isFile();
isDirectory();
exists();
canRea();
canWrite();
isAbsolute();
isHidden();
E:獲取功能
getAbsoluteFile();
getAbsolutePath();
getPath();
getParent();
getParentFile();
getName();
length();
lastModified();
F:高級獲取功能
list();
listFiles();
G:過濾器功能
list(FilenameFilter filter);
String[] s = file1.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return new File(dir, name).isFile() && name.endsWith(".jpg");
}
});
listFiles(FilenameFilter filter);
(4)案例：
A:輸出指定目錄下指定后綴名的文件名稱
a:先獲取所有的先鱼，在遍歷的時候判斷，再輸出
File file = new File("D:\\Movie\\M");
String[] s = file.list();
for (String result : s) {
if (result.endsWith(".mp4")) {
System.out.println(result);
}
}
b:先判斷奸鬓，再獲取焙畔，最后直接遍歷輸出即可
String[] s1 = file.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".mp4");
}
});
for (String result : s1) {
System.out.println(result);
}
B:批量修改文件名稱
File file = new File("D:\\Movie");
String[] s = file.list(new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.startsWith("相對宇宙");
}
});
for (String result : s) {
System.out.println("beforeRename : " + result);
File file1 = new File(file,result.replaceAll("WEB.*影視\\.", ""));
File file2 = new File(file, result);
file2.renameTo(file1);
System.out.println("afterRename : " + file1.exists() + ", " + file1.getName());
}
Java多線程
1:遞歸(理解)
(1)方法定義中調(diào)用方法本身的現(xiàn)象
舉例：老和尚給小和尚講故事，我們學編程
(2)遞歸的注意事項串远；
A:要有出口宏多，否則就是死遞歸
B:次數(shù)不能過多，否則內(nèi)存溢出
C:構(gòu)造方法不能遞歸使用
(3)遞歸的案例：
A:遞歸求階乘
B:兔子問題
C:遞歸輸出指定目錄下所有指定后綴名的文件絕對路徑
D:遞歸刪除帶內(nèi)容的目錄(小心使用)
2:IO流(掌握)
(1)IO用于在設備間進行數(shù)據(jù)傳輸?shù)牟僮?
(2)分類：
A:流向
輸入流 讀取數(shù)據(jù)
輸出流 寫出數(shù)據(jù)
B:數(shù)據(jù)類型
字節(jié)流
字節(jié)輸入流
字節(jié)輸出流
字符流
字符輸入流
字符輸出流
注意：
a:如果我們沒有明確說明按照什么分澡罚，默認按照數(shù)據(jù)類型分伸但。
b:除非文件用windows自帶的記事本打開我們能夠讀懂，才采用字符流留搔，否則建議使用字節(jié)流更胖。
(3)FileOutputStream寫出數(shù)據(jù)
A:操作步驟
a:創(chuàng)建字節(jié)輸出流對象
b:調(diào)用write()方法
c:釋放資源
B:代碼體現(xiàn)：
FileOutputStream fos = new FileOutputStream("fos.txt");
fos.write("hello".getBytes());
fos.close();
C:要注意的問題?
a:創(chuàng)建字節(jié)輸出流對象做了幾件事情?
b:為什么要close()?
c:如何實現(xiàn)數(shù)據(jù)的換行?
d:如何實現(xiàn)數(shù)據(jù)的追加寫入?
(4)FileInputStream讀取數(shù)據(jù)
A:操作步驟
a:創(chuàng)建字節(jié)輸入流對象
b:調(diào)用read()方法
c:釋放資源
B:代碼體現(xiàn)：
FileInputStream fis = new FileInputStream("fos.txt");
//方式1
int by = 0;
while((by=fis.read())!=-1) {
System.out.print((char)by);
}
//方式2
byte[] bys = new byte[1024];
int len = 0;
while((len=fis.read(bys))!=-1) {
System.out.print(new String(bys,0,len));
}
fis.close();
(5)案例：2種實現(xiàn)
A:復制文本文件
B:復制圖片
C:復制視頻
(6)字節(jié)緩沖區(qū)流
A:BufferedOutputStream
B:BufferedInputStream
(7)案例：4種實現(xiàn)
A:復制文本文件
B:復制圖片
C:復制視頻
3:自學字符流
IO流分類
字節(jié)流：
InputStream
FileInputStream
BufferedInputStream
OutputStream
FileOutputStream
BufferedOutputStream
字符流：
Reader
FileReader
BufferedReader
Writer
FileWriter
BufferedWriter
1:字符流(掌握)
(1)字節(jié)流操作中文數(shù)據(jù)不是特別的方便，所以就出現(xiàn)了轉(zhuǎn)換流。
轉(zhuǎn)換流的作用就是把字節(jié)流轉(zhuǎn)換字符流來使用。
(2)轉(zhuǎn)換流其實是一個字符流
字符流 = 字節(jié)流 + 編碼表
(3)編碼表
A:就是由字符和對應的數(shù)值組成的一張表
B:常見的編碼表
ASCII
ISO-8859-1
GB2312
GBK
GB18030
UTF-8
C:字符串中的編碼問題
編碼
String -- byte[]
解碼
byte[] -- String
(4)IO流中的編碼問題
A:OutputStreamWriter
OutputStreamWriter(OutputStream os):默認編碼巢音，GBK
OutputStreamWriter(OutputStream os,String charsetName):指定編碼骏啰。
B:InputStreamReader
InputStreamReader(InputStream is):默認編碼取具，GBK
InputStreamReader(InputStream is,String charsetName):指定編碼
C:編碼問題其實很簡單
編碼只要一致即可
(5)字符流
Reader
|--InputStreamReader
|--FileReader
|--BufferedReader
Writer
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
(6)復制文本文件(5種方式)
2:IO流小結(jié)(掌握)
IO流
|--字節(jié)流
|--字節(jié)輸入流
InputStream
int read():一次讀取一個字節(jié)
int read(byte[] bys):一次讀取一個字節(jié)數(shù)組
|--FileInputStream
|--BufferedInputStream
|--字節(jié)輸出流
OutputStream
void write(int by):一次寫一個字節(jié)
void write(byte[] bys,int index,int len):一次寫一個字節(jié)數(shù)組的一部分
|--FileOutputStream
|--BufferedOutputStream
|--字符流
|--字符輸入流
Reader
int read():一次讀取一個字符
int read(char[] chs):一次讀取一個字符數(shù)組
|--InputStreamReader
|--FileReader
|--BufferedReader
String readLine():一次讀取一個字符串
|--字符輸出流
Writer
void write(int ch):一次寫一個字符
void write(char[] chs,int index,int len):一次寫一個字符數(shù)組的一部分
|--OutputStreamWriter
|--FileWriter
|--BufferedWriter
void newLine():寫一個換行符
void write(String line):一次寫一個字符串
3:案例(理解 練習一遍)
A:復制文本文件 5種方式(掌握)
B:復制圖片(二進制流數(shù)據(jù)) 4種方式(掌握)
C:把集合中的數(shù)據(jù)存儲到文本文件
D:把文本文件中的數(shù)據(jù)讀取到集合并遍歷集合
E:復制單級文件夾
F:復制單級文件夾中指定的文件并修改名稱
回顧一下批量修改名稱
G:復制多級文件夾
H:鍵盤錄入學生信息按照總分從高到低存儲到文本文件
I:把某個文件中的字符串排序后輸出到另一個文本文件中
J:用Reader模擬BufferedReader的特有功能
K:模擬LineNumberReader的特有功能
