Java学习笔记_ day09
1:异常和错误
概述:在程序的编译或者运行过程中发生的不正常的情况
分类:
Throwable 类是 Java 语言中所有错误或异常的超类,父类:
两个子类:
Error:错误
服务器宕机
数据库崩溃
栈内存溢出错误


Exception:就是我们平时所说的异常
运行时异常:RuntimeException及其子类
编译时异常:非RuntimeException及其子类


异常的处理方式:
1.try...catch:自己能处理,自己处理,后续代码继续执行//(出现异常时,只有进行catch处理后续代码才会继续执行)
  try...finally:finally是try里面不可分割的一部分,不能单独使用,最终的意思,里面的代码永远都会执行,
一般用来释放资源,比如关闭io流,
                除非你在在它之前退出了Java虚拟机即调用了这行代码System.exit(0);程序立马停止,后面的代码不再执行
  
  try...catch...finally:
  代码:
try {//try检测,你有可能出现异常代码,当出现异常的时候里面跑到下面catch块里面,try块{}异常代码后面的代码不再执行
FileOutputStream fos = new FileOutputStream("");
System.out.println(666);
} catch (FileNotFoundException e) {//catch,捕获异常,处理异常,注意,如果有多个异常catch块可以写多个!!!
// TODO 自动生成的 catch 块
//e.printStackTrace();//异常的名字,异常发生原因,异常发生代码位置
System.out.println("异常发生了");
}

System.out.println("后续代码");


try{
System.out.println(10/0);//
}finally {//最终的意思,里面的代码永远都会执行,除非你在退出了Java虚拟机调用System.exit(0);程序立马停止,后面的代码不再执行
//System.exit(0);//加上这么一行代码,没有红色的东西出现,异常名字异常原因异常代码位置,因为程序在这里就立马停止,
           //默认Java虚拟机在finally之后处理,不是catch处理,后续代码不再执行
System.out.println("看看我执行了么?");
}

System.out.println("后续代码");//后续代码不再执行,因为没有进行catch处理,默认交给Java虚拟机处理
   //,告诉异常名字异常原因异常代码的位置


try {
System.out.println(10 /0);
System.out.println(666);
} catch (Exception e) {
System.out.println("catch");
}finally{
System.out.println("finally");
}


2.throws抛出一个异常,自己不能处理,交给异常代码调用的(使用)者处理,通常是main方法(又被Java虚拟机调用),默认处理:
  告诉你异常的名字,异常发生的原因,异常代码的位置,后续代码不再执行
  代码:
  public static void main(String[] args) throws Exception{
System.out.println(10/0);
System.out.println("后续代码");//后续代码不再执行
  }


常见问题:
1.两种异常的区别:
运行时(期)异常:在运行的时候发生,可以处理,也可以不处理,都可以运行,常见的是算术异常 ArithmeticException,比如除数为0
编译时(期)异常:在编译的时候发生,你一定要处理,否则运行得到的不是你想要的结果,常见的是文件找不到异常 FileNotFoundException


2.两种处理方式的区别:
1.try...catch:自己能处理,自己处理,后续代码继续执行
2.throws抛出一个异常,自己不能处理,交给异常代码的调用者处理,通常是main方法(又被Java虚拟机调用),默认处理:
      告诉你异常的名字,异常发生的原因,异常代码的位置,后续代码不再执行


3.关于异常和返回值的面试题
代码:
public static int method() {
int num = 0;
try {
System.out.println(10 /0);
num = 10;
return num;
} catch (Exception e) {
// System.exit(0);//退出Java虚拟机程序立马停止,后面的代码不再执行!!!
num = 20;
return num;//return记录的是方法的返回值,你最终调用哪个块里面的return,结果就是哪个块里面return后面的值,return之前会看看有没有finally,有就执行
}finally {//最终的意思,里面的代码永远都会执行,除非你在退出了Java虚拟机调用System.exit(0);程序立马停止,后面的代码不再执行
num = 30;
//return num;
}

}

4.try...catch...finally,catch里面有return,finally里面没有,问你finally里面的代码会不会执行?是在return之前还是在return之后执行?
  finally是try里面不可分割的一部分,不能单独使用,最终的意思,里面的代码永远都会执行,一般用来释放资源,比如关闭io流,
  除非你在退出了Java虚拟机调用System.exit(0);程序立马停止,后面的代码不再执行,
  return之前执行


5.final,finally,finalize这三个有什么区别?
  final最终的意思,修饰的变量是最终变量,常量,只能被赋值一次;修饰的方法是最终方法,不能被重写;修饰的类是最终类,不能被继承


  finally是try里面不可分割的一部分,不能单独使用,最终的意思,里面的代码永远都会执行,一般用来释放资源,比如关闭io流
  除非你在退出了Java虚拟机调用System.exit(0);程序立马停止,后面的代码不再执行


  finalize这是一个方法的名字,Object类里面,垃圾回收的时候会调用,Java有个自动垃圾回收机制
  代码:
  public class 垃圾回收 {
public static void main(String[] args) {
// finalize这是一个方法的名字,Object类里面,垃圾回收的时候会调用,Java有个自动垃圾回收机制
// Demo d = new Demo();//d是对象名,对象是new Demo();//new 新建的意思,对象名就是引用:引用数类型的变量,存的是地址值,对象的地址值,通过它找到对象,使用对象里面变量和方法
// new Demo();//没有名字的对象,匿名对象,new Demo();就是对象,匿名对象每创建一次使用完毕就会成立垃圾,用于一次性逻辑,不是立马回收,等待回收,垃圾回收机制
for (int i = 1; i <1000000; i++) {
new Demo();
}

}
  }


  class Demo extends Object{//一切类都是直接或者间接的继承Object类,不写也是写,系统给你写,只要你继承了其他类,系统就不再给你写
@Override
protected void finalize() throws Throwable {
// TODO 自动生成的方法存根
System.out.println("垃圾回收了");
}
  }


2:File类和文件(文件夹)处理
概述:表示文件或者文件夹的路径,(你甚至可以错误的认为它就是文件或者文件夹),用来操作文件或者文件夹
路径:就是文件或者文件夹的地址
路径分类:
绝对路径:具体以某个盘符开头的路径,比如F:\liulanqi\翻墙浏览器\readme.txt
相对路径:相对某个东西而已,在eclipse里面就是相对当前项目,就是在当前项目下面直接写的文件或者文件夹的路径


构造方法://知道类名File通过类名来创建对象,其实通过new关键字调用File类的构造方法来创建对象,拿到对象名.来调用对象变量和方法
    File f = new File("D:\\a.png");//直接传入一个文件或者文件夹的路径把他封装成File类对象表示的路径,
//这样就可以更加方便的操作我们的文件或者文件夹,对象名f
boolean b = f.exists();
System.out.println(b);//true


File f = new File("D:\\", "a.png");//传入一个父目录(文件夹)和一个子文件或者文件夹的名字封装成File类型的对象
boolean b = f.exists();
System.out.println(b);


File parent = new File("D:\\");
File f = new File(parent, "a.png");//把父目录封装成File对象,然后传入,还有传入文件或者文件夹的名字,又封装成一个新的File对象
boolean b = f.exists();
System.out.println(b);


//其实三个构造方法表示的路径都是一样的:D:\\a.png;这样是为了更加灵活多变,具体看需求


成员方法:
File类的创建功能,删除功能://用来创建文件或者文件夹,删除文件或者文件夹


//我想在当前项目下创建一个b.txt文件
File f = new File("b.txt");//创建一个File类对象,得到对象名f
boolean b = f.createNewFile();//创建文件,创建成功返回true,当文件已经存在那就不创建,失败返回false
System.out.println(b);//true


//我想在当前项目下创建一个b文件夹
File f = new File("b");//创建一个File类对象,得到对象名f
boolean b = f.mkdir();//mk,make,dir,目录就是文件夹,创建单级(个)文件夹,创建成功返回true,当文件夹已经存在那就不创建返回false
System.out.println(b);


//我想在当前项目下创建一个c文件夹,c文件夹里面有个b文件夹,b文件夹里面有个a文件夹
File f = new File("c\\b\\a");//创建一个File类对象,得到对象名f
boolean b = f.mkdirs();//mk,make,dir,目录就是文件夹,创建多级(多个)文件夹,创建成功返回true,当文件夹已经存在那就不创建返回false
System.out.println(b);


//单级文件夹,看你最终是不是创建一个文件夹,是就是单级的,不管你的路径有多复杂:
File f = new File("b\\d\\s");//创建一个File类对象,得到对象名f
boolean b = f.mkdir();//mk,make,dir,目录就是文件夹,创建文件夹,创建成功返回true,当文件夹已经存在那就不创建返回false
System.out.println(b);//如果b文件夹存在并且b文件夹有个d文件夹,那么我最终创建的只是一个s文件夹,这时候就是创建单级(单个)


//要删除当前项目下的b.txt文件
File f = new File("b.txt");//创建一个File类对象,得到对象名f
boolean b = f.delete();//删除文件或者文件夹,删除成功返回true,当文件或者文件夹不存在删除失败返回false,
//删除文件或者文件夹不走回收站,删了就没了!!!
System.out.println(b);


//要删除当前项目下的b文件夹,要求文件夹是空文件夹,这个文件夹里面不能有任何东西,有东西,先删里面,再删外面!!!
File f = new File("b");//创建一个File类对象,得到对象名f
boolean b = f.delete();//删除文件或者文件夹,删除成功返回true,当文件或者文件夹不存在删除失败返回false,
//删除文件或者文件夹不走回收站,删了就没了
System.out.println(b);


File类的判断功能://File类代表文件或者文件夹的路径,判断这个路径是否存在,是否是文件,是否是文件夹


File f = new File("G:\\a");//对象名f
boolean b = f.exists();//判断对象名f关联的路径是否存在,存在返回true,否则返回false;
System.out.println(b);


//判断是否是文件
File f = new File("G:\\a.png");
boolean b = f.isFile();//判断对象名f关联的路径是否是文件,是返回true,不是返回false;
System.out.println(b);


//判断是否是文件夹
File f = new File("G:\\a");
boolean b = f.isDirectory();//判断对象名f关联的路径是否是文件夹,是返回true,不是返回false;Directory目录就是文件夹!!!
System.out.println(b);


File类的获取功能://获取文件的大小,获取文件或者文件夹的名字,获取文件或者文件夹的绝对路径,获取File类构造方法的传入的路径


//获取文件的大小,单位是字节,不能用来获取文件夹的大小!!!
File f = new File("G:\\a.png");
long len = f.length();//用来获取文件的大小,单位是字节
System.out.println(len);//231,395

//获取文件或者文件夹的名字
File f = new File("G:\\a.png");
String name = f.getName();
System.out.println(name);


//获取文件或者文件夹的绝对路径
File f = new File("a.txt");
String path = f.getAbsolutePath();
System.out.println(path);//G:\java基础班\softs\workspace1.8\day09_异常666\a.txt


//获取File类构造方法的传入的路径
File f = new File("hhh.txt");//即使这个时候hhh.txt不存在
String path = f.getPath();//获取File类构造方法的传入的路径,不管路径是否存在,一般用来获取相对路径
System.out.println(path);//hhh.txt


File类的高级获取功能://高级,针对的是文件夹,要调用高级功能,要求是文件夹路径封装成File对象,打开文件夹
//File类的高级获取功能://高级,针对是文件夹,要调用高级功能,要求是文件夹路径封装成File对象,打开文件夹

File f = new File("C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期");//要求是文件夹路径封装成File对象,不能是文件路径
String[] arr = f.list();//列出,打开调用方法的对象f关联的路径的的文件夹,得到文件或者文件夹,得到这些文件或者文件夹名字,存到数组里面去
for (String string : arr) {
System.out.println(string);
}


File f = new File("C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期");//要求是文件夹路径封装成File对象,不能是文件路径
File[] arr = f.listFiles();//列出,打开调用方法的对象f关联的路径的的文件夹,得到文件或者文件夹,得到这些文件或者文件夹字符串类型路径封装成File类型的路径,存到数组里面去
for (File file : arr) {
System.out.println(file);
//C:\Users\Administrator\Desktop\深圳黑马Java基础48期\新建文本文档.txt
}


=============================================================================================================================
public class File类的高级获取功能针对的是文件夹 {
public static void main(String[] args) {
//File类的高级获取功能://高级,针对是文件夹,要调用高级功能,要求是文件夹路径封装成File对象,打开文件夹
File dir = new File("C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期");//要求是文件夹路径封装成File对象,不能是文件路径
String[] arr = dir.list(new A());//FilenameFilter接口  东西filter
for (String string : arr) {
System.out.println(string);
}
}
}


class A implements FilenameFilter {//A就是接口FilenameFilter的实现类,干儿子类,子类


@Override
public boolean accept(File dir, String name) {
// System.out.println(dir);//dir表示要打开的文件夹的路径,
// System.out.println(name);//name,表示要打开文件夹下面的东西的名字
// return true;//只有这个重写的accept方法返回true的时候对应的数组arr才有元素,值
// 只要文件的名字以.txt结尾才存到到对应的数组中,达到过滤的效果

File f = new File(dir, name);//C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期\\新建文本文档.txt;
return f.isFile()&&f.getName().endsWith(".txt");//只有这个路径是文件并且文件的名字以.txt结尾才返回true,把满足条件的东西存到对应的数组arr里面
}

}


用匿名内部类,在eclipse里面简单写,new alt /,表示接口实现类对象,简写形式
代码:
File dir = new File("C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期");//要求是文件夹路径封装成File对象,不能是文件路径
String[] arr = dir.list(new FilenameFilter() {

@Override
public boolean accept(File dir, String name) {

File f = new File(dir, name);//C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期\\新建文本文档.txt;
return f.isFile()&&f.getName().endsWith(".txt");//只有这
}
});

for (String string : arr) {
System.out.println(string);
}


======================================================================================================================


File dir = new File("C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期");//要求是文件夹路径封装成File对象,不能是文件路径
File[] arr = dir.listFiles(new FilenameFilter() {

@Override
public boolean accept(File dir, String name) {
//dir://C:\Users\Administrator\Desktop\深圳黑马Java基础48期
//name:新建文本文档.txt或者day01....
File f = new File(dir, name);//C:\Users\Administrator\Desktop\深圳黑马Java基础48期\新建文本文档.txt

// return true;
return f.isFile()&&f.getName().endsWith(".txt");
}
});

for (File file : arr) {
System.out.println(file);//路径:C:\Users\Administrator\Desktop\深圳黑马Java基础48期\新建文本文档.txt,得到file对象就可以调用各种方法
System.out.println(file.getName());//名字:新建文本文档.txt
}


//最方便的,套路跟上面一样:
File dir = new File("C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期");//要求是文件夹路径封装成File对象,不能是文件路径
File[] arr = dir.listFiles(new FileFilter() {

@Override
public boolean accept(File pathname) {
// System.out.println(pathname);//要打开的文件夹的路径和要打开的文件夹下面的东西的名字组成成新的路径
//比如C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期\\新建文本文档.txt;  新建文本文档.txt;有可能是day01...
return pathname.isFile()&&pathname.getName().endsWith(".txt");
}
});

for (File file : arr) {
System.out.println(file);//C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础48期\\新建文本文档.txt; 
}


3:递归//以后开发少用到,一般在面试,理解下面的案例,最好能够写出
概述:定义一个方法(写一个方法),方法自己调用自己,前提条件是你写的这个方法要被调用起来
注意事项:
1.递归不能调用过多,否则出现栈内存溢出错误: StackOverflowError
2.递归一定要有一个出口,否则出现栈内存溢出错误: StackOverflowError
3.构造方法不能递归调用,否则出现栈内存溢出错误: StackOverflowError


解决递归问题:找到出口,找到规律
递归案例:
1.求5的阶乘,5! = 5*4*3*2*1;
代码:
/**
 * @author Administrator,递归,理解中文,递过去,归来(传回来)
 * 解决递归问题:找到出口,找到规律
递归案例:
1.求5的阶乘,5! = 5*4! =  5*4*3! =  5*4*3*2! = 5*4*3*2*1! = 5*4*3*2*1;
出口:1!=1;
规律:n!=n*(n-1)!
 */
public class 五的阶乘 {
public static void main(String[] args) {
int i = method(5);
System.out.println(i);//120
}

//定义一个方法,写一个方法用来求n的阶乘,调用我的方法method(n);method(1);
public static int method(int n){//n = 5;
//出口:1!=1;调用method(1)求1阶乘方法得到的结果是1,就是方法的返回值是1
if (n==1) {
return 1;
}

//规律:n!=n*(n-1)!;//method(n) = n* method(n-1);
return n* method(n-1);


}

}


2.已知数列:
  1 1 2 3 5 8 13 21,求第12项的结果是什么?
代码:
/**
 * @author Administrator
 * 解决递归问题:找到出口,找到规律
 * 1 1 2 3 5 8 13 21,求第12项的结果是什么?
 * 出口:第一项是1,第二项也是1
 * 规律:任意第三项等于前面两项之和
 */
public class 斐波那契数列不死神兔 {
public static void main(String[] args) {
int i = f(12);
System.out.println(i);//
}

//定义一个方法,写一个方法用来求第n项的结果是什么?f(n);f(1)=1;f(2)=1;
public static int f(int n){//n = 12;
//出口:第一项是1,第二项也是1
if (n==1||n==2) {
return 1;
}

//规律:任意第三项等于前面两项之和:f(n) = f(n-1)+f(n-2);
return f(n-1)+f(n-2);
}

}


3.求一个目录(文件夹)下面所有的以.java结尾的文件//如果是文件就干嘛,如果是文件夹就递归
代码:
public class 输出一个文件夹下面所有的以点java结尾的文件的名字 {
public static void main(String[] args) {
//3.求一个文件夹下面所有的以.java结尾的文件//如果是文件就干嘛,如果是文件夹就递归
//文件夹的路径,把他封装成file类型的路径
File dir = new File("E:\\");
printJavaFiles(dir);
}

//写一个方法,用来求一个文件夹下面所有的以.java结尾的文件
public static void printJavaFiles(File dir){//dir = dir;//C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础38期
//来求一个文件夹下面所有的以.java结尾的文件,打开这个文件夹,要么是文件要么是文件夹,如果是文件并且以.java结尾打印文件的名字,如果是文件夹,继续打开
//打开这个文件夹
File[] arr = dir.listFiles();//打开这个dir对应路径的文件夹,把它下面的所有东西的路径封装成file类型的路径,存到数组里面,dir = file文件夹
//listFiles有可能 返回null,arr = null;如果用增强for循环变量数组名的值为null就会出现空指针异常,NullPointerException

if (arr!=null) {
//打开这个文件夹,要么是文件要么是文件夹,如果是文件并且以.java结尾打印文件的名字,如果是文件夹,继续打开
for (File file : arr) {//file代表被打开的文件夹下面的所有东西的路径
//如果是文件并且以.java结尾打印文件的名字,
if (file.isFile()&&file.getName().endsWith(".java")) {
System.out.println(file.getName());
}else if (file.isDirectory()) {//如果是文件夹,继续打开,上面已经做了,你就自己调用自己,递归
printJavaFiles(file);
}

}
}

}
}


4:补充内容
A.字节:是计算机存储文件的最小单位,计算机底层都是0和1,一个字节八位,位二进制位,每个位对应的是0或者1,一个字节对应计算机的底层表示
       八个0或1的组合


B.如果以后你调用别人写的方法,这个方法的形式参数需要一个接口类型的东西,因为接口不能直接创建对象,但是可以间接创建,
  用接口的实现类来创建对象,方法(接口类型 东西),需要接口的实现类对象(干儿子类对象),接口类型东西可以接收它的所有实现类对象,
  因为多态里面有个前提条件,父接口引用可以指向所有的实现类对象


C.匿名内部类:前提存在一个类或者接口,匿名内部类就代表这个类的子类对象或者这个接口的实现类对象,简写方式
  格式:
  new 类名或接口名(){
  //重写方法
  }//这个整体就代表这个类的子类对象,或者这个接口的实现类对象


D.为什么数组名为null的时候用增强for循环会出现空指针异常,编译器对于增强for循环遍历数组的时候她是这样做的
  我们写的代码:
  public static void printJavaFiles(File dir){//dir = dir;//C:\\Users\\Administrator\\Desktop\\深圳黑马Java基础38期
  //来求一个文件夹下面所有的以.java结尾的文件,打开这个文件夹,要么是文件要么是文件夹,如果是文件并且以.java结尾打印文件的名字,如果是文件夹,继续打开
  //打开这个文件夹
  File[] arr = dir.listFiles();//打开这个dir对应路径的文件夹,把它下面的所有东西的路径封装成file类型的路径,存到数组里面,dir = file文件夹
  //listFiles有可能 返回null,arr = null;如果用增强for循环变量数组名的值为null就会出现空指针异常,NullPointerException


  //打开这个文件夹,要么是文件要么是文件夹,如果是文件并且以.java结尾打印文件的名字,如果是文件夹,继续打开
  for (File file : arr) {//file代表被打开的文件夹下面的所有东西的路径
  //如果是文件并且以.java结尾打印文件的名字,
  if (file.isFile()&&file.getName().endsWith(".java")) {
  System.out.println(file.getName());
  }else if (file.isDirectory()) {//如果是文件夹,继续打开,上面已经做了,你就自己调用自己,递归
  printJavaFiles(file);
  }

  }

  }


 编译器修改的代码:
 public static void printJavaFiles(File dir)
  {
  File arr[] = dir.listFiles();//null给arr赋值

  {
  File afile[];
  int j = (afile = arr).length;//null.length;现在数组名为null,但是数组名存的的是数组的地址,为null没有地址就找不到数组
 //你还想去访问这个数组的属性length,就会出现空指针异常NullPointerException
  for (int i = 0; i < j; i++)
  {
  File file = afile[i];
  if (file.isFile() && file.getName().endsWith(".java"))
  System.out.println(file.getName());
  else
  if (file.isDirectory())
  printJavaFiles(file);
  }


  }
 }
阅读更多
个人分类: Java学习笔记
博主设置当前文章不允许评论。

没有更多推荐了,返回首页

不良信息举报

Java学习笔记_ day09

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭