1:StringBuffer(掌握)
(1)用字符串做拼接，比較耗時並且也耗內存，而這種拼接操作又是比較常見的，為了解決這個問題，Java就提供了
一個字符串緩沖區類。StringBuffer供我們使用。
(2)StringBuffer的構造方法
A:StringBuffer()
B:StringBuffer(int size)
C:StringBuffer(String str)
(3)StringBuffer的常見功能(自己補齊方法的聲明和方法的解釋)
A:添加功能
B:刪除功能
C:替換功能
D:反轉功能
E:截取功能(注意這個返回值)
(4)StringBuffer的練習(做一遍)
A:String和StringBuffer相互轉換
String -- StringBuffer
構造方法
StringBuffer -- String
toString()方法
B:字符串的拼接
C:把字符串反轉
D:判斷一個字符串是否對稱
(5)面試題
小細節：
StringBuffer：同步的，數據安全，效率低。
StringBuilder：不同步的，數據不安全，效率高。
A:String,StringBuffer,StringBuilder的區別
B:StringBuffer和數組的區別?
(6)注意的問題：
String作為形式參數，StringBuffer作為形式參數。
2:數組高級以及Arrays(掌握)
(1)排序
A:冒泡排序
相鄰元素兩兩比較，大的往后放，第一次完畢，最大值出現在了最大索引處。同理，其他的元素就可以排好。
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以后的元素都進行比較，第一次完畢，最小值出現在了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:基本查找
針對數組無序的情況
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:二分查找(折半查找)
針對數組有序的情況(千萬不要先排序，在查找)
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:是針對數組進行操作的工具類。包括排序和查找等功能。
B:要掌握的方法(自己補齊方法)
把數組轉成字符串：
排序：
二分查找：
(4)Arrays工具類的源碼解析
(5)把字符串中的字符進行排序
舉例：
"edacbgf"
得到結果
"abcdefg"
3:Integer(掌握)
(1)為了讓基本類型的數據進行更多的操作，Java就為每種基本類型提供了對應的包裝類類型
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
(2)Integer的構造方法
A:Integer i = new Integer(100);
B:Integer i = new Integer("100");
注意：這里的字符串必須是由數字字符組成
(3)String和int的相互轉換
A:String -- int
Integer.parseInt("100");
B:int -- String
String.valueOf(100);
(4)其他的功能(了解)
進制轉換
(5)JDK5的新特性
自動裝箱 基本類型--引用類型
自動拆箱 引用類型--基本類型
把下面的這個代碼理解即可：
Integer i = 100;
i += 200;
(6)面試題
-128到127之間的數據緩沖池問題
4:Character(了解)
(1)Character構造方法
Character ch = new Character('a');
(2)要掌握的方法：(自己補齊)
A:判斷給定的字符是否是大寫
B:判斷給定的字符是否是小寫
C:判斷給定的字符是否是數字字符
D:把給定的字符轉成大寫
E:把給定的字符轉成小寫
(3)案例：
統計字符串中大寫，小寫及數字字符出現的次數
1:正則表達式(理解)
(1)就是符合一定規則的字符串
(2)常見規則
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，兩頭的字母包括在內（范圍）
[0-9] 0到9的字符都包括
C:預定義字符類
. 任何字符。我的就是.字符本身，怎么表示呢? \.
\d 數字：[0-9]
\w 單詞字符：[a-zA-Z_0-9]
在正則表達式里面組成單詞的東西必須有這些東西組成
D:邊界匹配器
^ 行的開頭
$ 行的結尾
\b 單詞邊界
就是不是單詞字符的地方。
舉例：hello world?haha;xixi
E:Greedy 數量詞
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():獲取剛才查找過的數據
(4)案例
A:判斷電話號碼和郵箱
B:按照不同的規則分割數據
C:把論壇中的數字替換為*
D:獲取字符串中由3個字符組成的單詞
2:Math(掌握)
(1)針對數學運算進行操作的類
(2)常見方法(自己補齊)
A:絕對值
B:向上取整
C:向下取整
D:兩個數據中的大值
E:a的b次冪
F:隨機數
G:四舍五入
H:正平方根
(3)案例：
A:猜數字小游戲
B:獲取任意范圍的隨機數
3:Random(理解)
(1)用於產生隨機數的類
(2)構造方法:
A:Random() 默認種子，每次產生的隨機數不同
B:Random(long seed) 指定種子，每次種子相同，隨機數就相同
(3)成員方法:
A:int nextInt() 返回int范圍內的隨機數
B:int nextInt(int n) 返回[0,n)范圍內的隨機數
4:System(掌握)
(1)系統類,提供了一些有用的字段和方法
(2)成員方法(自己補齊)
A:運行垃圾回收器
B:退出jvm
C:獲取當前時間的毫秒值
D:數組復制
5:BigInteger(理解)
(1)針對大整數的運算
(2)構造方法
A:BigInteger(String s)
(3)成員方法(自己補齊)
A:加
B:減
C:乘
D:除
E:商和余數
6:BigDecimal(理解)
(1)浮點數據做運算，會丟失精度。所以，針對浮點數據的操作建議采用BigDecimal。(金融相關的項目)
(2)構造方法
A:BigDecimal(String s)
(3)成員方法：
A:加
B:減
C:乘
D:除
E:自己保留小數幾位
7:Date/DateFormat(掌握)
(1)Date是日期類，可以精確到毫秒。
A:構造方法
Date()
Date(long time)
B:成員方法
getTime()
setTime(long time)
C:日期和毫秒值的相互轉換
案例：你來到這個世界多少天了?
(2)DateFormat針對日期進行格式化和針對字符串進行解析的類，但是是抽象類，所以使用其子類SimpleDateFormat
A:SimpleDateFormat(String pattern) 給定模式
yyyy-MM-dd HH:mm:ss
B:日期和字符串的轉換
a:Date -- String
format()
b:String -- Date
parse()
C:案例：
制作了一個針對日期操作的工具類。
8:Calendar(掌握)
(1)日歷類，封裝了所有的日歷字段值，通過統一的方法根據傳入不同的日歷字段可以獲取值。
(2)如何得到一個日歷對象呢?
Calendar rightNow = Calendar.getInstance();
本質返回的是子類對象
(3)成員方法
A:根據日歷字段得到對應的值
B:根據日歷字段和一個正負數確定是添加還是減去對應日歷字段的值
C:設置日歷對象的年月日
(4)案例：
計算任意一年的2月份有多少天?
1:對象數組(掌握)
(1)數組既可以存儲基本數據類型，也可以存儲引用類型。它存儲引用類型的時候的數組就叫對象數組。
(2)案例：
用數組存儲5個學生對象，並遍歷數組。
2:集合(Collection)(掌握)
(1)集合的由來?
我們學習的是Java -- 面向對象 -- 操作很多對象 -- 存儲 -- 容器(數組和StringBuffer) -- 數組
而數組的長度固定，所以不適合做變化的需求，Java就提供了集合供我們使用。
(2)集合和數組的區別?
A:長度區別
數組固定
集合可變
B:內容區別
數組可以是基本類型，也可以是引用類型
集合只能是引用類型
C:元素內容
數組只能存儲同一種類型
集合可以存儲不同類型(其實集合一般存儲的也是同一種類型)
(3)集合的繼承體系結構?
由於需求不同，Java就提供了不同的集合類。這多個集合類的數據結構不同，但是它們都是要提供存儲和遍歷功能的，
我們把它們的共性不斷的向上提取，最終就形成了集合的繼承體系結構圖。
Collection
|--List
|--ArrayList
|--Vector
|--LinkedList
|--Set
|--HashSet
|--TreeSet
(4)Collection的功能概述(自己補齊)
A:添加功能
B:刪除功能
C:判斷功能
D:獲取功能
E:長度功能
F:交集(了解)
G:把集合轉數組(了解)
(5)Collection集合的遍歷
A:把集合轉數組(了解)
B:迭代器(集合專用方式)
(6)迭代器
A:是集合的獲取元素的方式。
B:是依賴於集合而存在的。
C:迭代器的原理和源碼。
a:為什么定義為了一個接口而不是實現類?
b:看了看迭代器的內部類實現。
(7)Collection集合的案例(遍歷方式 迭代器)
集合的操作步驟：
A:創建集合對象
B:創建元素對象
C:把元素添加到集合
D:遍歷集合
A:存儲字符串並遍歷
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class CollectionDemo {
public static void main(String[] args) {
//創建集合對象
Collection c = new ArrayList();
//創建並添加元素
c.add("hello");
c.add("world");
c.add("java");
//遍歷集合
Iterator it = c.iterator();
while(it.hasNext()) {
String s =(String) it.next();
System.out.println(s);
}
}
}
B:存儲自定義對象並遍歷
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name,int age) {
this.name = name;
this.age = age;
}
//getXxx()/setXxx()
}
import java.util.Collection;
import java.util.ArrayList;
import java.util.Iterator;
public class StudentDemo {
public static void main(String[] args) {
//創建集合對象
Collection c = new ArrayList();
//創建學生對象
Student s1 = new Student("林青霞",27);
Student s2 = new Student("風清揚",30);
Student s3 = new Student("劉意",30);
Student s4 = new Student("武鑫",25);
Student s5 = new Student("劉曉曲",16);
//添加元素
c.add(s1);
c.add(s2);
c.add(s3);
c.add(s4);
c.add(s5);
//遍歷集合
Iterator it = c.iterator();
while(it.hasNext()) {
Student s = (Student)it.next();
System.out.println(s.getName()+"---"+s.getAge());
}
}
}
3:集合(List)(掌握)
(1)List是Collection的子接口
特點：有序(存儲順序和取出順序一致)，可重復。
(2)List的特有功能：(自己補齊)
A:添加功能
B:刪除功能
C:獲取功能
D:迭代器功能
E:修改功能
(3)List集合的特有遍歷功能
A:由size()和get()結合。
B:代碼演示
//創建集合對象
List list = new ArrayList();
//創建並添加元素
list.add("hello");
list.add("world");
list.add("java");
//遍歷集合
Iterator it = list.iterator();
while(it.hasNext()) {
String s =(String) it.next();
System.out.println(s);
}
System.out.println("----------");
for(int x=0; x<list.size(); x++) {
String s =(String) list.get(x);
System.out.println(s);
}
(4)列表迭代器的特有功能；(了解)
可以逆向遍歷，但是要先正向遍歷，所以無意義，基本不使用。
(5)並發修改異常
A:出現的現象
迭代器遍歷集合，集合修改集合元素
B:原因
迭代器是依賴於集合的，而集合的改變迭代器並不知道。
C:解決方案
a:迭代器遍歷，迭代器修改(ListIterator)
元素添加在剛才迭代的位置
b:集合遍歷，集合修改(size()和get())
元素添加在集合的末尾
(6)常見數據結構
A:棧 先進后出
B:隊列 先進先出
C:數組 查詢快，增刪慢
D:鏈表 查詢慢，增刪快
(7)List的子類特點(面試題)
ArrayList
底層數據結構是數組，查詢快，增刪慢。
線程不安全，效率高。
Vector
底層數據結構是數組，查詢快，增刪慢。
線程安全，效率低。
LinkedList
底層數據結構是鏈表，查詢慢，增刪快。
線程不安全，效率高。
到底使用誰呢?看需求?
分析：
要安全嗎?
要：Vector(即使要，也不使用這個，后面再說)
不要：ArrayList或者LinkedList
查詢多；ArrayList
增刪多：LinkedList
什么都不知道，就用ArrayList。
(8)List集合的案例(遍歷方式 迭代器和普通for)
A:存儲字符串並遍歷
B:存儲自定義對象並遍歷
1:List的子類(掌握)
(1)List的子類特點
ArrayList:
底層數據結構是數組，查詢快，增刪慢
線程不安全，效率高
Vector:
底層數據結構是數組，查詢快，增刪慢
線程安全，效率低
LinkedList:
底層數據結構是鏈表，查詢慢，增刪快
線程不安全，效率高
(2)ArrayList
A:沒有特有功能需要學習
B:案例
a:ArrayList存儲字符串並遍歷
b:ArrayList存儲自定義對象並遍歷
(3)Vector
A:有特有功能
a:添加
public void addElement(E obj) -- add()
b:獲取
public E elementAt(int index) -- get()
public Enumeration<E> elements() -- iterator()
B:案例
a:Vector存儲字符串並遍歷
b:Vector存儲自定義對象並遍歷
(4)LinkedList
A:有特有功能
a:添加
addFirst()
addLast()
b:刪除
removeFirst()
removeLast()
c:獲取
getFirst()
getLast()
B:案例
a:LinkedList存儲字符串並遍歷
b:LinkedList存儲自定義對象並遍歷
(5)案例：
A:去除集合中的多個字符串的重復元素
如果字符串的內容相同，即為重復元素
B:去除集合中的多個自定義對象的重復元素
如果自定義對象的成員變量值都相同，即為重復元素
C:用LinkedList模擬一個棧數據結構的集合類，並測試。
你要定義一個集合類，只不過內部可以使用LinkedList來實現。
2:泛型(掌握)
(1)泛型概述
是一種把明確類型的工作推遲到創建對象或者調用方法的時候才去明確的特殊的類型。
(2)格式：
<數據類型>
注意：該數據類型只能是引用類型。
(3)好處：
A:把運行時期的問題提前到了編譯期間
B:避免了強制類型轉換
C:優化了程序設計，解決了黃色警告線問題，讓程序更安全
(4)泛型的前世今生
A:泛型的由來
Object類型作為任意類型的時候，在向下轉型的時候，會隱含一個轉型問題
B:泛型類
C:泛型方法
D:泛型接口
E:泛型高級通配符
?
? extends E
? super E
(5)我們在哪里使用呢?
一般是在集合中使用。
3:增強for循環(掌握)
(1)是for循環的一種
(2)格式：
for(元素的數據類型 變量名 : 數組或者Collection集合的對象) {
使用該變量即可，該變量其實就是數組或者集合中的元素。
}
(3)好處：
簡化了數組和集合的遍歷
(4)弊端
增強for循環的目標不能為null。建議在使用前，先判斷是否為null。
4:靜態導入(了解)
(1)可以導入到方法級別的導入
(2)格式：
import static 包名....類名.方法名;
(3)注意事項：
A:方法必須是靜態的
B:如果多個類下有同名的方法，就不好區分了，還得加上前綴。
所以一般我們並不使用靜態導入，但是一定要能夠看懂。
5:可變參數(掌握)
(1)如果我們在寫方法的時候，參數個數不明確，就應該定義可變參數。
(2)格式：
修飾符 返回值類型 方法名(數據類型... 變量) {}
注意：
A:該變量其實是一個數組名
B:如果一個方法有多個參數，並且有可變參數，可變參數必須在最后
(3)Arrays工具類的一個方法
asList()把數組轉成集合。
注意：這個集合的長度不能改變。
6:練習(掌握)
A:集合的嵌套遍歷
B:產生10個1-20之間的隨機數，要求隨機數不能重復
C:鍵盤錄入多個數據，以0結束，並在控制台輸出最大值
7:要掌握的代碼
集合存儲元素，加入泛型，並可以使用增強for遍歷。
1:登錄注冊案例(理解)
2:Set集合(理解)
(1)Set集合的特點
無序,唯一
(2)HashSet集合(掌握)
A:底層數據結構是哈希表(是一個元素為鏈表的數組)
B:哈希表底層依賴兩個方法：hashCode()和equals()
執行順序：
首先比較哈希值是否相同
相同：繼續執行equals()方法
返回true：元素重復了，不添加
返回false：直接把元素添加到集合
不同：就直接把元素添加到集合
C:如何保證元素唯一性的呢?
由hashCode()和equals()保證的
D:開發的時候，代碼非常的簡單，自動生成即可。
E:HashSet存儲字符串並遍歷
F:HashSet存儲自定義對象並遍歷(對象的成員變量值相同即為同一個元素)
(3)TreeSet集合
A:底層數據結構是紅黑樹(是一個自平衡的二叉樹)
B:保證元素的排序方式
a:自然排序(元素具備比較性)
讓元素所屬的類實現Comparable接口
b:比較器排序(集合具備比較性)
讓集合構造方法接收Comparator的實現類對象
C:把我們講過的代碼看一遍即可
(4)案例：
A:獲取無重復的隨機數
B:鍵盤錄入學生按照總分從高到底輸出
3:Collection集合總結(掌握)
Collection
|--List 有序,可重復
|--ArrayList
底層數據結構是數組，查詢快，增刪慢。
線程不安全，效率高
|--Vector
底層數據結構是數組，查詢快，增刪慢。
線程安全，效率低
|--LinkedList
底層數據結構是鏈表，查詢慢，增刪快。
線程不安全，效率高
|--Set 無序,唯一
|--HashSet
底層數據結構是哈希表。
如何保證元素唯一性的呢?
依賴兩個方法：hashCode()和equals()
開發中自動生成這兩個方法即可
|--LinkedHashSet
底層數據結構是鏈表和哈希表
由鏈表保證元素有序
由哈希表保證元素唯一
|--TreeSet
底層數據結構是紅黑樹。
如何保證元素排序的呢?
自然排序
比較器排序
如何保證元素唯一性的呢?
根據比較的返回值是否是0來決定
4:針對Collection集合我們到底使用誰呢?(掌握)
唯一嗎?
是：Set
排序嗎?
是：TreeSet
否：HashSet
如果你知道是Set，但是不知道是哪個Set，就用HashSet。
否：List
要安全嗎?
是：Vector
否：ArrayList或者LinkedList
查詢多：ArrayList
增刪多：LinkedList
如果你知道是List，但是不知道是哪個List，就用ArrayList。
如果你知道是Collection集合，但是不知道使用誰，就用ArrayList。
如果你知道用集合，就用ArrayList。
5:在集合中常見的數據結構(掌握)
ArrayXxx:底層數據結構是數組，查詢快，增刪慢
LinkedXxx:底層數據結構是鏈表，查詢慢，增刪快
HashXxx:底層數據結構是哈希表。依賴兩個方法：hashCode()和equals()
TreeXxx:底層數據結構是二叉樹。兩種方式排序：自然排序和比較器排序
1:Map(掌握)
(1)將鍵映射到值的對象。一個映射不能包含重復的鍵；每個鍵最多只能映射到一個值。
(2)Map和Collection的區別?
A:Map 存儲的是鍵值對形式的元素，鍵唯一，值可以重復。夫妻對
B:Collection 存儲的是單獨出現的元素，子接口Set元素唯一，子接口List元素可重復。光棍
(3)Map接口功能概述(自己補齊)
A:添加功能
B:刪除功能
C:判斷功能
D:獲取功能
E:長度功能
(4)Map集合的遍歷
A:鍵找值
a:獲取所有鍵的集合
b:遍歷鍵的集合,得到每一個鍵
c:根據鍵到集合中去找值
B:鍵值對對象找鍵和值
a:獲取所有的鍵值對對象的集合
b:遍歷鍵值對對象的集合，獲取每一個鍵值對對象
c:根據鍵值對對象去獲取鍵和值
代碼體現：
Map<String,String> hm = new HashMap<String,String>();
hm.put("it002","hello");
hm.put("it003","world");
hm.put("it001","java");
//方式1 鍵找值
Set<String> set = hm.keySet();
for(String key : set) {
String value = hm.get(key);
System.out.println(key+"---"+value);
}
//方式2 鍵值對對象找鍵和值
Set<Map.Entry<String,String>> set2 = hm.entrySet();
for(Map.Entry<String,String> me : set2) {
String key = me.getKey();
String value = me.getValue();
System.out.println(key+"---"+value);
}
(5)HashMap集合的練習
A:HashMap<String,String>
B:HashMap<Integer,String>
C:HashMap<String,Student>
D:HashMap<Student,String>
(6)TreeMap集合的練習
A:TreeMap<String,String>
B:TreeMap<Student,String>
(7)案例
A:統計一個字符串中每個字符出現的次數
B:集合的嵌套遍歷
a:HashMap嵌套HashMap
b:HashMap嵌套ArrayList
c:ArrayList嵌套HashMap
d:多層嵌套
2:Collections(理解)
(1)是針對集合進行操作的工具類
(2)面試題：Collection和Collections的區別
A:Collection 是單列集合的頂層接口，有兩個子接口List和Set
B:Collections 是針對集合進行操作的工具類，可以對集合進行排序和查找等
(3)常見的幾個小方法：
A:public static <T> void sort(List<T> list)
B:public static <T> int binarySearch(List<?> list,T key)
C:public static <T> T max(Collection<?> coll)
D:public static void reverse(List<?> list)
E:public static void shuffle(List<?> list)
(4)案例
A:ArrayList集合存儲自定義對象的排序
B:模擬斗地主洗牌和發牌
C:模擬斗地主洗牌和發牌並對牌進行排序
1:異常(理解)
(1)程序出現的不正常的情況。
(2)異常的體系
Throwable
|--Error 嚴重問題，我們不處理。
|--Exception
|--RuntimeException 運行期異常，我們需要修正代碼
|--非RuntimeException 編譯期異常，必須處理的，否則程序編譯不通過
(3)異常的處理：
A:JVM的默認處理
把異常的名稱,原因,位置等信息輸出在控制台，但是呢程序不能繼續執行了。
B:自己處理
a:try...catch...finally
自己編寫處理代碼,后面的程序可以繼續執行
b:throws
把自己處理不了的，在方法上聲明，告訴調用者，這里有問題
(4)面試題
A:編譯期異常和運行期異常的區別?
編譯期異常 必須要處理的，否則編譯不通過
運行期異常 可以不處理，也可以處理
B:throw和throws是的區別
throw:
在方法體中,后面跟的是異常對象名,並且只能是一個
throw拋出的是一個異常對象，說明這里肯定有一個異常產生了
throws:
在方法聲明上,后面跟的是異常的類名,可以是多個
throws是聲明方法有異常，是一種可能性，這個異常並不一定會產生
(5)finally關鍵字及其面試題
A:finally用於釋放資源，它的代碼永遠會執行。特殊情況：在執行到finally之前jvm退出了
B:面試題
a:final,finally,finalize的區別?
b:如果在catch里面有return,請問finally還執行嗎?如果執行,在return前還是后
會，前。
實際上在中間。這個上課我們講過
C:異常處理的變形
try...catch...finally
try...catch...
try...catch...catch...
try...catch...catch...fianlly
try...finally
(6)自定義異常
繼承自Exception或者RuntimeException,只需要提供無參構造和一個帶參構造即可
(7)異常的注意實現
A:父的方法有異常拋出,子的重寫方法在拋出異常的時候必須要小於等於父的異常
B:父的方法沒有異常拋出,子的重寫方法不能有異常拋出
C:父的方法拋出多個異常,子的重寫方法必須比父少或者小
2:File(掌握)
(1)IO流操作中大部分都是對文件的操作，所以Java就提供了File類供我們來操作文件
(2)構造方法
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:創建功能
B:刪除功能
C:重命名功能
D:判斷功能
E:獲取功能
F:高級獲取功能
G:過濾器功能
(4)案例：
A:輸出指定目錄下指定后綴名的文件名稱
a:先獲取所有的，在遍歷的時候判斷，再輸出
b:先判斷，再獲取，最后直接遍歷輸出即可
B:批量修改文件名稱