1 集合的特点
集合
Collection(单列集合)
(1)List(有序,可重复)
A: ArrayList
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
B: Vector
底层数据结构是数组,查询快,增删慢
线程安全,效率低
C: LinkedList
底层数据结构是链表,查询慢,增删快
线程不安全,效率高
(2)Set(无序,唯一)
A: HashSet
底层数据结构是哈希表
哈希表依赖两个方法:hashCode()和equals()
执行顺序:
首先判断hashCode()值是否相同
相同:继续执行equals()方法
返回true:元素重复了,不添加
返回false:直接把元素添加到集合
不同:就直接把元素添加到集合
最终:
自动生成hashCode()和equals()即可
a: LinkedHashSet
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
B: TreeSet
底层数据结构是红黑树(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象
Map(双列集合)
A:Map集合的数据结构仅仅针对键有效,与值无关。
B:存储的是键值对形式的元素,键唯一,值可重复
(1)HashMap
底层数据结构是哈希表。线程不安全,效率高。
哈希表依赖两个方法:hashCode()和equals()
执行顺序:
首先判断hashCode()值是否相同
相同:继续执行equals()方法
返回true:元素重复了,不添加
返回false:直接把元素添加到集合
不同:就直接把元素添加到集合
最终:
自动生成hashCode()和equals()即可
A: LinkedHashMap
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
(2)Hashtable
底层数据结构是哈希表。线程安全,效率低。
哈希表依赖两个方法:hashCode()和equals()
执行顺序:
首先判断hashCode()值是否相同
相同:继续执行equals()方法
返回true:元素重复了,不添加
返回false:直接把元素添加到集合
不同:就直接把元素添加到集合
最终:
自动生成hashCode()和equals()即可
A: LinkedHashMap
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
(3)TreeMap
底层数据结构是红黑树(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象
2 异常
(1)程序出现了不正常的情况
举例:今天天气很好,班长出去旅行,骑着自行车,去山里面呼吸新鲜空气
问题1:山路坍塌了,班长及时停住了,但是过不去了。严重的问题。
问题2:班长出门推自行车,发现气没了,把气吹起来。出发前就应该检查的问题。
问题3:班长骑着车在山路上惬意的行驶着,山路两边是有小石子的,中间是光滑的水泥路。
一直在平坦的水泥路上行驶,是没有任何问题的,但是,他偏偏要骑到小石子上,结果爆胎了。旅道的过程中出现的问题、
(2)
程序的异常:Throwable
严重问题:Error 我们不处理,这种问题一般都是很严重的,比如说内存溢出。
问题:Exception
编译期问题:不是RuntimeException的异常 必须进行处理的,因为你不处理,编译就不能通过。
运行期问题:RuntimeException 这种问题我们也不处理,因为是你的问题,而且这个问题出现肯定是我们的代码不够严谨,需要修改代码。
(3)JVM默认处理异常:
如果程序出现了问题,我们没有做任何处理,最终jvm会做出默认的处理。
把异常的名称,原因以及出现的问题等信息输出在控制台。
同时会结束程序。
(4)我们自己如何进行处理异常呢?
A:try...catch...finally
B:throws 抛出
try...catch...finally的处理格式:
try{
可能出现问题的代码:
}catch(异常名 变量){
针对问题的处理:
}finally {
释放资源;
}
变形格式:
try{
可能出现问题的代码;
}catch(异常名 变量){
针对问题的处理;
}
***注意事项:
1:能明确的尽量明确,不要用大的来处理。
2:平级关系的异常谁前谁后无关系,如果出现了子父关系,父必须在后面
***注意:
A:try里面的代码越少越好。
B:catch里面必须有内容,哪怕是给出一个简单的提示
C:一旦try里面出了问题,就会在这里把问题给抛出去,然后和catch里面的问题进行匹配。一旦有匹配的,就执行了catch里面的处理,然后结束了try...catch。继续执行后面的语句。
------------------------------------------------
A:一个异常
B:二个异常
a:每一个写一个try...catch
b:写一个try,多个catch
------------------------------------------------
//一个异常的处理
int a = 10;
//int b =2;
int b =0;
try{
System.out.println(a/b);
}catch(ArithmeticException ae){
System.out.println("除数不能为0");
}
System.out.println("over");
//输出: 除数不能为0
over
------------------------------------------------
//两个异常的处理
int a = 10;
int b = 0;
int[] arr = {1,2,3};
try{
System.out.println(arr[3]);
System.out.println(a/b);
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("你访问了不该访问的索引");
}
System.out.println("over");
//输出: 你访问了不该访问的索引
over
-------------------------------------------------
//如果无法明确异常
int a = 10;
int b = 0;
int[] arr = {1,2,3};
try{
System.out.println(arr[3]);
System.out.println(a/b);
System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
}catch(Exception e){
System.out.println("出问题了");
}
System.out.println("over");
//输出: 出问题了
over
---------------------------------------------------
//正常情况
try{
System.out.println(arr[3]);
System.out.println(a/b);
System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("你访问了不该访问的索引");
}catch(Exception e){
System.out.println("出问题了");
}
---------------------------------------------------
(5) JDK7针对多个异常的处理方案
try{
}catch(异常名1 | 异常名2 | ... 变量) {
}
注意:这个方法虽然简洁,但是也不够好。
A:处理方式是一致的(实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理)
B:多个异常间必须是平级关系。(Exception会出错)
//jdk7的处理方案
try{
System.out.println(arr[3]);
System.out.println(a/b);
}catch(ArithmeticException | ArrayIndexOutOfBoundsException e){
System.out.println("出问题了");
}
3 编译期异常和运行期异常
区别
编译期异常:Java程序必须显示处理,否则程序就会发生错误,无法通过编译
运行期异常:无需显示处理,也可以和编译时异常一样处理
在try里面发现问题后,jvm会帮我们生成一个异常对象,然后把这个对象抛出,和catch里面的类进行匹配。
如果该对象是某个类型的,就会执行该catch里面的处理信息。
4 Throwable的几个常见方法
异常中要了解的几个方法:
public String getMessage():异常的消息字符串
public String toString():返回异常的简单信息描述
此对象的类name(全路径名)
":"(冒号和一个空格)
调用此对象getLocalizedMessage()方法的结果(默认返回的是getMessage()内容)
printStackTrace() 获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void,把信息输出在控制台。
String s = "2014-11-20";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try{
Date d = sdf.parse(s);
System.out.println(d);
}catch(ParseException e){ //ParseException e = new ParseException();
//getMessage()
//System.out.println(e.getMessage());
//Unparseable date:"2014-11-20"
//toString()
//System.out.println(e.toString());
//java.text.parseException:Unparseable date:"2014-11-20"
e.printStackTrace();
//跳转到某个指定的页面(index.html)
}
System.out.println("over");
5 throws的方式处理异常
有些时候,我们是可以对异常进行处理的,但是又有些时候,我们根本就没有权限去处理某个异常。
或者说,我处理不了,就不处理了。
为了结局出错问题,java针对这种情况,就提供了另一种处理方案:抛出。
格式:
throws 异常类名
注意:这个格式必须跟在方法的括号后面
注意:尽量不要在main方法上抛出异常
但是讲课为了方便就这样做了。。。
小结:
编译期异常抛出,将来调用者必须处理。
运行期异常抛出,将来调用可以不用处理。
-------------------------------------------------------------
System.out.println("今天天气真好!");
//编译时异常处理
try{
method();
}catch(ParseException e){
e.printStackTrace();
}
System.out.println("但是就是不该有雾霾");
method2();
//运行期异常的抛出 不需要异常处理
public static void method2() throws ParseException(){
int a = 10;
int b =0;
System.out.println(a/b);
}
//编译时异常的抛出
public static void method() throws ParseException(){
String s = "2014-11-20";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(s);
System.out.println(d);
}
//输出: 今天天气真好!
一段java错误提示...
但是就是不该有雾霾
一段java错误提示...
---------------------------------------------------------------
6 throw的概述以及和throws的区别
throw:如果出现了异常情况,我们可以把异常抛出,这个时候抛出的应该是异常的对象
(在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时,就用throw把异常对象抛出)
***
throws
用在方法声明后面,跟的是异常类名
可以跟多个异常类名,用逗号隔开
表示抛出异常,由该方法的调用者来处理
throws表示出现异常的一种可能性,并不一定会发生这些异常
throw
用在方法体内,跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常,由方法体内的语句处理
throw则是抛出了异常,执行throw则一定抛出了某种异常
public static void method(){
int a = 10;
int b = 0;
if(b ==0){
throw new ArithmeticException();
}else{
System.out.println(a/b);
}
}
7 异常处理使用情况
原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws。
区别:
后续程序需要继续运行就try
后续程序不需要继续运行就throws
***8 finally
(1)finally:异常处理,一般都会执行
格式
try...catch...finally
----------------------------
(2)面试题 final finally finalize 三者的区别
final:最终的意思,可以修饰类,成员变量,成员方法
修饰类,类不能被继承
修饰变量,变量是常量
修饰方法,方法不能被重写
finally:是异常处理的一部分,用于释放资源
一般来说,代码肯定会执行。特殊情况:在执行到finally之前,jvm退出,例如System.exit();
finalize:是Object类的一个方法,用于垃圾回收。
(3)面试题 如果catch里面有return语句,请问finally里面的代码还有执行吗
如果会,请问在return前,还是return后。
会,因为除非jvm退出,否则finally能执行。
前。
更准确的说,是在return 的中间。
int a = 10;
try{
System.out.println(a/0);
a = 20;
}catch (ArithmeticException e){
a = 30;
return a;
// return a 在程序执行到这一步的首,这里不是return a,而是return 30 ,这个返回路径就完成了。
// 但是,它发现后面还有finally ,所以继续执行finally的内容, a =40
//再次回到以前的返回路径,继续走return 30
}finally{
a = 40;
//return a; 如果这里有return a 则返回的是 40
}
return a;
}
9 异常注意事项
A:子类重写父类方法时,子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
10 File类的概述和构造方法
我们要想实现IO的操作,就必须知道硬盘上文件的表现形式
而java提供了一个类File供我们使用
File:文件和目录(文件夹)路径名的抽象表示形式
(1)构造方法:
File(String pathname):根据一个路径得到File对象
File(String parent,String child):根据一个目录和一个子文件/目录得到File对象
File(File parent,String child):根据一个父File对象和一个子文件/目录得到File对象
----------------------------------
//File(String pathname):根据一个路径得到File对象
//把e:\\demo\\a.txt封装成一个File对象
File file = new File("E:\\demo\\a.txt");
//File(String parent,String child):根据一个目录和一个子文件/目录得到File对象
File file2 = new File("E:\\demo","a.txt");
//File(File parent,String child):根据一个父File对象和一个子文件/目录得到File对象
File file3 = new File("e:\\demo");
File file4 = new File(file3,"a.txt");
//以上三种方式其实一样
(2)创建功能
public boolean createNewFile():创建文件
public boolean mkdir():创建文件夹,如果存在这样的文件夹,就不创建了
public Boolean mkdirs():创建文件夹,如果目录不存在,则创建该目录
//需求,在e盘目录下创建一个文件夹demo
File file = new File("e:\\demo");
System.out.println("mkdir:"+file.mkdir());
//需求:在e盘目录demo下创建一个文件a.txt
File file2 = new File("e:\\demo\\a.txt");
System.out.println("createNewFile:"+file2.createNewFile());
//需求:在e盘目录test下创建一个文件b.txt
File file3 = new File("e:\\test\\a.txt");
System.out.println("createNewFile:"+file3.createNewFile());
//会报错! 注意:想要在某个目录下创建内容,该目录必须存在
//需求,在e盘目录test下创建目录aaa
File file4 = new File("e:\\test\\aaa");
System.out.println("mkdir:"+file4.mkdir());
//会报错,需要一步一步来
File file5 = new File("e:\\test");
System.out.println("mkdir:"+file5.mkdir());
File file6 = new File("e:\\test\\aaa");
System.out.println("mkdir:"+file6.mkdir());
//其实还有更简单的方法
File file7 = new File("e:\\aaa\\bbb\\ccc\ddd");
System.out.println("mkdirs:"+file7.mkdirs());
(3)删除功能
public boolean delete():
A:如果你创建文件或者文件夹忘了写盘符路径,那么,默认在项目路径下
B:Java中的删除不走回收站
C:要删除一个文件夹,请注意该文件夹不能包含文件或文件夹
File file = new File("e:\\aaa\\bbb");
System.out.println("mkdirs:"+file.mkdirs());
File file2 = new File("e:\\aaa");
System.out.println("delete:"+file2.delete());
//删除失败 因为 aaa文件夹中有东西,必须全部删除后,才能删除aaa
File file3 = new File("e:\\aaa\\bbb");
System.out.println("delete:"+file3.delete());
File file4 = new File("e:\\aaa");
System.out.println("delete:"+file4.delete());
(4)重命名功能
路径以盘符开始:绝对路径 c:\\a.txt
路径不以盘符开始:相对路径 a.txt
public boolean renameTo(File dest)
//创建一个文件对象
File file = new File("林青霞.jpg");
//改名
File newFile = new File("东方不败.jpg");
file.renameTo(newFile);
(5)判断功能
public boolean isDirectory() :判断是否是目录
public boolean isFile() :判断是否是文件
public boolean exists() :判断是否存在
public boolean canRead() :判断是否可读
public boolean canWrite() :判断是否可写
public boolean isHidden() :判断是否隐藏
(6)获取功能
public String getAbsolutePath() :获取绝对路径
public String getPath() :获取相对路径
public String getName() :获取名称
public long length() : 获取长度,字节数
public long lastModified() :获取最后一次的修改时间,毫秒值
(7)高级获取功能
public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
public File[] listFiles() :获取指定目录下的所有文件或者文件夹的File数组
//指定一个目录
File file = new File("e:\\");
//public String[] list()
String strArray = file.list();
for(String s : strArray){
Sytstem.out.println(s);
}
//public File[] listFiles()
File[] fileArray = file.listFiles();
for(File f : fileArray){
Sytem.out.println(f.getName());
}
(8)输出指定目录下指定后缀名的文件名
//指定一个目录
File file = new File("e:\\");
//获取该目录下所有文件或者文件夹的file数组
File[] fileArray = file.listFiles();
//遍历该File数组,得到每一个File对象,然后判断
for(File f : fileArray){
//是否是文件
if(f.isFile()){
//继续判断是否以.jpg结尾
if(f.getName().endsWith(".jpg"))
//输出该文件名称
System.out.println(f.getName());
}
}
(9) 改进输出指定目录下的指定后缀名的文件名
A:先获取所有的,然后遍历的时候,一次判断,如果满足条件就输出
B:获取的时候就已经是满足条件了的,然后输出即可
想要实现这个效果,就必须学习一个接口:文件名称过滤器
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)
//指定一个目录
File file = new File("e:\\");
//获取该目录下所有文件或者文件夹的String数组
//public String[] list(FilenameFilter filter)
String[] strArray = file.list(new FilenameFilter(){
@Override
public boolean accpet(File dir,String name){
//return false
//return true
//通过这个测试,我们知道了,到底把这个文件或者文件夹的名称加不加到数组中,取决于这里的返回值是true还是false
//所以,这个的true或者false应该是通过某种判断得到的
File file = new File(dir,name);
//System.out.println(file)
boolean flag = file.isFile();
boolean flag2 = name.endsWith(".jpg");
return flag && flag2;
for(String s : strArray){
System.out.println(s);
}
集合
Collection(单列集合)
(1)List(有序,可重复)
A: ArrayList
底层数据结构是数组,查询快,增删慢
线程不安全,效率高
B: Vector
底层数据结构是数组,查询快,增删慢
线程安全,效率低
C: LinkedList
底层数据结构是链表,查询慢,增删快
线程不安全,效率高
(2)Set(无序,唯一)
A: HashSet
底层数据结构是哈希表
哈希表依赖两个方法:hashCode()和equals()
执行顺序:
首先判断hashCode()值是否相同
相同:继续执行equals()方法
返回true:元素重复了,不添加
返回false:直接把元素添加到集合
不同:就直接把元素添加到集合
最终:
自动生成hashCode()和equals()即可
a: LinkedHashSet
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
B: TreeSet
底层数据结构是红黑树(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象
Map(双列集合)
A:Map集合的数据结构仅仅针对键有效,与值无关。
B:存储的是键值对形式的元素,键唯一,值可重复
(1)HashMap
底层数据结构是哈希表。线程不安全,效率高。
哈希表依赖两个方法:hashCode()和equals()
执行顺序:
首先判断hashCode()值是否相同
相同:继续执行equals()方法
返回true:元素重复了,不添加
返回false:直接把元素添加到集合
不同:就直接把元素添加到集合
最终:
自动生成hashCode()和equals()即可
A: LinkedHashMap
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
(2)Hashtable
底层数据结构是哈希表。线程安全,效率低。
哈希表依赖两个方法:hashCode()和equals()
执行顺序:
首先判断hashCode()值是否相同
相同:继续执行equals()方法
返回true:元素重复了,不添加
返回false:直接把元素添加到集合
不同:就直接把元素添加到集合
最终:
自动生成hashCode()和equals()即可
A: LinkedHashMap
底层数据结构由链表和哈希表组成。
由链表保证元素有序。
由哈希表保证元素唯一。
(3)TreeMap
底层数据结构是红黑树(是一种自平衡的二叉树)
如何保证元素唯一性呢?
根据比较的返回值是否是0来决定
如何保证元素的排序呢?
两种方式
自然排序(元素具备比较性)
让元素所属的类实现Comparable接口
比较器排序(集合具备比较性)
让集合接收一个Comparator的实现类对象
2 异常
(1)程序出现了不正常的情况
举例:今天天气很好,班长出去旅行,骑着自行车,去山里面呼吸新鲜空气
问题1:山路坍塌了,班长及时停住了,但是过不去了。严重的问题。
问题2:班长出门推自行车,发现气没了,把气吹起来。出发前就应该检查的问题。
问题3:班长骑着车在山路上惬意的行驶着,山路两边是有小石子的,中间是光滑的水泥路。
一直在平坦的水泥路上行驶,是没有任何问题的,但是,他偏偏要骑到小石子上,结果爆胎了。旅道的过程中出现的问题、
(2)
程序的异常:Throwable
严重问题:Error 我们不处理,这种问题一般都是很严重的,比如说内存溢出。
问题:Exception
编译期问题:不是RuntimeException的异常 必须进行处理的,因为你不处理,编译就不能通过。
运行期问题:RuntimeException 这种问题我们也不处理,因为是你的问题,而且这个问题出现肯定是我们的代码不够严谨,需要修改代码。
(3)JVM默认处理异常:
如果程序出现了问题,我们没有做任何处理,最终jvm会做出默认的处理。
把异常的名称,原因以及出现的问题等信息输出在控制台。
同时会结束程序。
(4)我们自己如何进行处理异常呢?
A:try...catch...finally
B:throws 抛出
try...catch...finally的处理格式:
try{
可能出现问题的代码:
}catch(异常名 变量){
针对问题的处理:
}finally {
释放资源;
}
变形格式:
try{
可能出现问题的代码;
}catch(异常名 变量){
针对问题的处理;
}
***注意事项:
1:能明确的尽量明确,不要用大的来处理。
2:平级关系的异常谁前谁后无关系,如果出现了子父关系,父必须在后面
***注意:
A:try里面的代码越少越好。
B:catch里面必须有内容,哪怕是给出一个简单的提示
C:一旦try里面出了问题,就会在这里把问题给抛出去,然后和catch里面的问题进行匹配。一旦有匹配的,就执行了catch里面的处理,然后结束了try...catch。继续执行后面的语句。
------------------------------------------------
A:一个异常
B:二个异常
a:每一个写一个try...catch
b:写一个try,多个catch
------------------------------------------------
//一个异常的处理
int a = 10;
//int b =2;
int b =0;
try{
System.out.println(a/b);
}catch(ArithmeticException ae){
System.out.println("除数不能为0");
}
System.out.println("over");
//输出: 除数不能为0
over
------------------------------------------------
//两个异常的处理
int a = 10;
int b = 0;
int[] arr = {1,2,3};
try{
System.out.println(arr[3]);
System.out.println(a/b);
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("你访问了不该访问的索引");
}
System.out.println("over");
//输出: 你访问了不该访问的索引
over
-------------------------------------------------
//如果无法明确异常
int a = 10;
int b = 0;
int[] arr = {1,2,3};
try{
System.out.println(arr[3]);
System.out.println(a/b);
System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
}catch(Exception e){
System.out.println("出问题了");
}
System.out.println("over");
//输出: 出问题了
over
---------------------------------------------------
//正常情况
try{
System.out.println(arr[3]);
System.out.println(a/b);
System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
}catch(ArithmeticException e){
System.out.println("除数不能为0");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("你访问了不该访问的索引");
}catch(Exception e){
System.out.println("出问题了");
}
---------------------------------------------------
(5) JDK7针对多个异常的处理方案
try{
}catch(异常名1 | 异常名2 | ... 变量) {
}
注意:这个方法虽然简洁,但是也不够好。
A:处理方式是一致的(实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理)
B:多个异常间必须是平级关系。(Exception会出错)
//jdk7的处理方案
try{
System.out.println(arr[3]);
System.out.println(a/b);
}catch(ArithmeticException | ArrayIndexOutOfBoundsException e){
System.out.println("出问题了");
}
3 编译期异常和运行期异常
区别
编译期异常:Java程序必须显示处理,否则程序就会发生错误,无法通过编译
运行期异常:无需显示处理,也可以和编译时异常一样处理
在try里面发现问题后,jvm会帮我们生成一个异常对象,然后把这个对象抛出,和catch里面的类进行匹配。
如果该对象是某个类型的,就会执行该catch里面的处理信息。
4 Throwable的几个常见方法
异常中要了解的几个方法:
public String getMessage():异常的消息字符串
public String toString():返回异常的简单信息描述
此对象的类name(全路径名)
":"(冒号和一个空格)
调用此对象getLocalizedMessage()方法的结果(默认返回的是getMessage()内容)
printStackTrace() 获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void,把信息输出在控制台。
String s = "2014-11-20";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try{
Date d = sdf.parse(s);
System.out.println(d);
}catch(ParseException e){ //ParseException e = new ParseException();
//getMessage()
//System.out.println(e.getMessage());
//Unparseable date:"2014-11-20"
//toString()
//System.out.println(e.toString());
//java.text.parseException:Unparseable date:"2014-11-20"
e.printStackTrace();
//跳转到某个指定的页面(index.html)
}
System.out.println("over");
5 throws的方式处理异常
有些时候,我们是可以对异常进行处理的,但是又有些时候,我们根本就没有权限去处理某个异常。
或者说,我处理不了,就不处理了。
为了结局出错问题,java针对这种情况,就提供了另一种处理方案:抛出。
格式:
throws 异常类名
注意:这个格式必须跟在方法的括号后面
注意:尽量不要在main方法上抛出异常
但是讲课为了方便就这样做了。。。
小结:
编译期异常抛出,将来调用者必须处理。
运行期异常抛出,将来调用可以不用处理。
-------------------------------------------------------------
System.out.println("今天天气真好!");
//编译时异常处理
try{
method();
}catch(ParseException e){
e.printStackTrace();
}
System.out.println("但是就是不该有雾霾");
method2();
//运行期异常的抛出 不需要异常处理
public static void method2() throws ParseException(){
int a = 10;
int b =0;
System.out.println(a/b);
}
//编译时异常的抛出
public static void method() throws ParseException(){
String s = "2014-11-20";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse(s);
System.out.println(d);
}
//输出: 今天天气真好!
一段java错误提示...
但是就是不该有雾霾
一段java错误提示...
---------------------------------------------------------------
6 throw的概述以及和throws的区别
throw:如果出现了异常情况,我们可以把异常抛出,这个时候抛出的应该是异常的对象
(在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时,就用throw把异常对象抛出)
***
throws
用在方法声明后面,跟的是异常类名
可以跟多个异常类名,用逗号隔开
表示抛出异常,由该方法的调用者来处理
throws表示出现异常的一种可能性,并不一定会发生这些异常
throw
用在方法体内,跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常,由方法体内的语句处理
throw则是抛出了异常,执行throw则一定抛出了某种异常
public static void method(){
int a = 10;
int b = 0;
if(b ==0){
throw new ArithmeticException();
}else{
System.out.println(a/b);
}
}
7 异常处理使用情况
原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws。
区别:
后续程序需要继续运行就try
后续程序不需要继续运行就throws
***8 finally
(1)finally:异常处理,一般都会执行
格式
try...catch...finally
----------------------------
(2)面试题 final finally finalize 三者的区别
final:最终的意思,可以修饰类,成员变量,成员方法
修饰类,类不能被继承
修饰变量,变量是常量
修饰方法,方法不能被重写
finally:是异常处理的一部分,用于释放资源
一般来说,代码肯定会执行。特殊情况:在执行到finally之前,jvm退出,例如System.exit();
finalize:是Object类的一个方法,用于垃圾回收。
(3)面试题 如果catch里面有return语句,请问finally里面的代码还有执行吗
如果会,请问在return前,还是return后。
会,因为除非jvm退出,否则finally能执行。
前。
更准确的说,是在return 的中间。
int a = 10;
try{
System.out.println(a/0);
a = 20;
}catch (ArithmeticException e){
a = 30;
return a;
// return a 在程序执行到这一步的首,这里不是return a,而是return 30 ,这个返回路径就完成了。
// 但是,它发现后面还有finally ,所以继续执行finally的内容, a =40
//再次回到以前的返回路径,继续走return 30
}finally{
a = 40;
//return a; 如果这里有return a 则返回的是 40
}
return a;
}
9 异常注意事项
A:子类重写父类方法时,子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
10 File类的概述和构造方法
我们要想实现IO的操作,就必须知道硬盘上文件的表现形式
而java提供了一个类File供我们使用
File:文件和目录(文件夹)路径名的抽象表示形式
(1)构造方法:
File(String pathname):根据一个路径得到File对象
File(String parent,String child):根据一个目录和一个子文件/目录得到File对象
File(File parent,String child):根据一个父File对象和一个子文件/目录得到File对象
----------------------------------
//File(String pathname):根据一个路径得到File对象
//把e:\\demo\\a.txt封装成一个File对象
File file = new File("E:\\demo\\a.txt");
//File(String parent,String child):根据一个目录和一个子文件/目录得到File对象
File file2 = new File("E:\\demo","a.txt");
//File(File parent,String child):根据一个父File对象和一个子文件/目录得到File对象
File file3 = new File("e:\\demo");
File file4 = new File(file3,"a.txt");
//以上三种方式其实一样
(2)创建功能
public boolean createNewFile():创建文件
public boolean mkdir():创建文件夹,如果存在这样的文件夹,就不创建了
public Boolean mkdirs():创建文件夹,如果目录不存在,则创建该目录
//需求,在e盘目录下创建一个文件夹demo
File file = new File("e:\\demo");
System.out.println("mkdir:"+file.mkdir());
//需求:在e盘目录demo下创建一个文件a.txt
File file2 = new File("e:\\demo\\a.txt");
System.out.println("createNewFile:"+file2.createNewFile());
//需求:在e盘目录test下创建一个文件b.txt
File file3 = new File("e:\\test\\a.txt");
System.out.println("createNewFile:"+file3.createNewFile());
//会报错! 注意:想要在某个目录下创建内容,该目录必须存在
//需求,在e盘目录test下创建目录aaa
File file4 = new File("e:\\test\\aaa");
System.out.println("mkdir:"+file4.mkdir());
//会报错,需要一步一步来
File file5 = new File("e:\\test");
System.out.println("mkdir:"+file5.mkdir());
File file6 = new File("e:\\test\\aaa");
System.out.println("mkdir:"+file6.mkdir());
//其实还有更简单的方法
File file7 = new File("e:\\aaa\\bbb\\ccc\ddd");
System.out.println("mkdirs:"+file7.mkdirs());
(3)删除功能
public boolean delete():
A:如果你创建文件或者文件夹忘了写盘符路径,那么,默认在项目路径下
B:Java中的删除不走回收站
C:要删除一个文件夹,请注意该文件夹不能包含文件或文件夹
File file = new File("e:\\aaa\\bbb");
System.out.println("mkdirs:"+file.mkdirs());
File file2 = new File("e:\\aaa");
System.out.println("delete:"+file2.delete());
//删除失败 因为 aaa文件夹中有东西,必须全部删除后,才能删除aaa
File file3 = new File("e:\\aaa\\bbb");
System.out.println("delete:"+file3.delete());
File file4 = new File("e:\\aaa");
System.out.println("delete:"+file4.delete());
(4)重命名功能
路径以盘符开始:绝对路径 c:\\a.txt
路径不以盘符开始:相对路径 a.txt
public boolean renameTo(File dest)
//创建一个文件对象
File file = new File("林青霞.jpg");
//改名
File newFile = new File("东方不败.jpg");
file.renameTo(newFile);
(5)判断功能
public boolean isDirectory() :判断是否是目录
public boolean isFile() :判断是否是文件
public boolean exists() :判断是否存在
public boolean canRead() :判断是否可读
public boolean canWrite() :判断是否可写
public boolean isHidden() :判断是否隐藏
(6)获取功能
public String getAbsolutePath() :获取绝对路径
public String getPath() :获取相对路径
public String getName() :获取名称
public long length() : 获取长度,字节数
public long lastModified() :获取最后一次的修改时间,毫秒值
(7)高级获取功能
public String[] list():获取指定目录下的所有文件或者文件夹的名称数组
public File[] listFiles() :获取指定目录下的所有文件或者文件夹的File数组
//指定一个目录
File file = new File("e:\\");
//public String[] list()
String strArray = file.list();
for(String s : strArray){
Sytstem.out.println(s);
}
//public File[] listFiles()
File[] fileArray = file.listFiles();
for(File f : fileArray){
Sytem.out.println(f.getName());
}
(8)输出指定目录下指定后缀名的文件名
//指定一个目录
File file = new File("e:\\");
//获取该目录下所有文件或者文件夹的file数组
File[] fileArray = file.listFiles();
//遍历该File数组,得到每一个File对象,然后判断
for(File f : fileArray){
//是否是文件
if(f.isFile()){
//继续判断是否以.jpg结尾
if(f.getName().endsWith(".jpg"))
//输出该文件名称
System.out.println(f.getName());
}
}
(9) 改进输出指定目录下的指定后缀名的文件名
A:先获取所有的,然后遍历的时候,一次判断,如果满足条件就输出
B:获取的时候就已经是满足条件了的,然后输出即可
想要实现这个效果,就必须学习一个接口:文件名称过滤器
public String[] list(FilenameFilter filter)
public File[] listFiles(FilenameFilter filter)
//指定一个目录
File file = new File("e:\\");
//获取该目录下所有文件或者文件夹的String数组
//public String[] list(FilenameFilter filter)
String[] strArray = file.list(new FilenameFilter(){
@Override
public boolean accpet(File dir,String name){
//return false
//return true
//通过这个测试,我们知道了,到底把这个文件或者文件夹的名称加不加到数组中,取决于这里的返回值是true还是false
//所以,这个的true或者false应该是通过某种判断得到的
File file = new File(dir,name);
//System.out.println(file)
boolean flag = file.isFile();
boolean flag2 = name.endsWith(".jpg");
return flag && flag2;
for(String s : strArray){
System.out.println(s);
}
//return new File(dir,name).isFile() &&name.endsWith(".jpg");
}