处理昨天的笔记
-
数组的操作
数组的拷贝
System.arraycopy(object src, int srcpos, object dest, int destpos, int length);- src是复制的原数组
- srcpos是原数组要开始复制的下标索引
- dest复制的目标数组
- destpos 目标数组插入的索引值
- length复制的长度
clone()方法也可用于拷贝操作
-
DateFormat和SimpleDateFormat
- 作用是完成字符传和时间对象的转换！
DateFormat是抽象类不能直接实例化
测试代码
//测试时间对象转换字符串
DateFormat df=new SimpleDateFormat("yyyy年MM月dd日");
Date d=new Date(1231232412334L);
String string=df.format(d);
System.out.println(string);
输出结果如下:
2009年01月06日
//测试字符串转换时间对象
String str="1997年7月1日";
try {
Date d2=df.parse(str);
System.out.println(d2);
} catch (ParseException e) {
e.printStackTrace();
}
//注：需要catch异常
输出结果如下
Tue Jul 01 00:00:00 CST 1997
格式化字符串除了上面的还有
hh-时
mm-分
ss-秒
-
Calendar和GregorianCalendar类
- 注意：
月份：一月是0，二月是1，以此类推
星期：周日是1，周一是2，周六是7
- 注意：
常用方法
Calendar calendar=new GregorianCalendar();
/*设置时间*/
calendar.set(int year, int month, int date, int hourOfDay, int minute, int second);
/*也可以单独设置*/
calendar.set(Calendar.DATE, 1);
//设置为当月第一天，
//即为api中的set(int field, int value)方法
//如果不设置时间的话，会默认设置为当前时间
可视化日历程序
public class CalendarTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner scanner=new Scanner(System.in);
System.out.println("请按格式输入日期，例：2001-01-01");
String str=scanner.nextLine();
DateFormat df=new SimpleDateFormat("yyyy-MM-dd");
try {
Date date=df.parse(str);
Calendar calendar=new GregorianCalendar();
calendar.setTime(date);
int today=calendar.get(Calendar.DATE);//保存当前天数
calendar.set(Calendar.DATE, 1);//转到当月第一天准备打印
int toDayOfWeek=calendar.get(Calendar.DAY_OF_WEEK);//获取当月一日的星期号
int maxDate=calendar.getActualMaximum(Calendar.DATE);//获取当前月份最大日期
System.out.println("日\t一\t二\t三\t四\t五\t六\t");
for(int i=1;i<toDayOfWeek;i++)
System.out.print("\t");
for(int i=1;i<=maxDate;i++){
if(i==today)
System.out.print(i+"*\t");
else System.out.print(i+"\t");
int w=calendar.get(Calendar.DAY_OF_WEEK);
if(w==calendar.SATURDAY)
System.out.println();
calendar.add(Calendar.DATE, 1);
}
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
运行结果
-
File类
- java.io.File类：文件和目录路径命的抽象表示形式
通过File类可以访问文件的属性
- 构造器
文件 ： File f = new File("d:/src3/TestObject.java");
目录 ： File f2 = new File("d:/src3");
目录下文件 ： Flie f3 = new File(f2, "TestObject.java");
- 方法
isFile();//判断是不是构造器
isDirectory();//判断是不是目录
//以下是一些常用方法
canRead();
canwrite();
exists();
isHidden();
long lastModified();
long length();
String getName();
String getPath();
- 通过File对象创建空白文件或目录
Public boolean createNewFile() throws IOException
不存在的文件对象f.createNewFile();//但所创建的文件所在的目录必须存在
- 创建目录
mkdir(); //只能创建一层
mkdirs(); //可以创建很多层
-
异常机制
Exception 在编写代码的过程中要学会去使用异常
异常是java提供的用于处理程序中错误的一种方式
- java中采用面向对象的一种方式处理异常，处理过程如下
抛出异常：若发生异常，则该方法生成代表该异常的一个对象，停止当前执行的路径。并将异常对象传给JRE。
捕获异常：JRE得到异常后，寻找相应的代码来处理该异常。JRE在方法的调用栈中查找。从生成异常的方法开始回溯，直到找到相应的异常处理代码为止。
-
异常继承图
异常
Error类描述了Java运行时系统内部错误和资源耗尽错误，无法控制且罕见。
Error表明JVM已处于不可恢复的崩溃状态，我们不需要去管理他！
- Exception（所有异常的父类）
- RuntimeException
一类特殊的异常，因为产生频繁且处理麻烦，系统会自动检测并交给默认的异常处理程序
常见的RuntimeException - 1.NullPointException （空指针异常）
通常是由对象是NULL导致的，一般加个if else 语句处理
- RuntimeException
Car c = null;
if(c != null)
c.run();
else{
}
2.ClassCastException（类型转换异常）
利用instanceof
if(obj instanceof Man){
Man man = (Man) obj;
}
3.ArrayIndexOutOfBoundsException（数组下标越界异常）
先判断下标是否超过数组的（length-1）
4.NumberFormatException（数字格式异常）
String str = "1243dgds";
Integer i = new Integer(str);
CheckedException
所有不是RuntimeException的异常统称为CheckedExcption，又被称为已检查异常。这类异常的产生不是程序本身的问题提，通常由外界因素造成的。-
try,catch,finally
try 至少要带一个catch或finally
finally总会执行
当异常处理的代码结束执行后，是不会回到try语句里去执行尚未执行的代码的
- catch
每个try语句块可以有多个catch语句
catch语句中常用方法
toString(); //显示异常的类名和产生的原因
getMessage();//只显示原因不显示类名
PirintStackTrace();//用来跟踪异常发生时堆栈中的内容
这些方法均继承自Throwable类
调用举例
public class TestException {
public static void main(String[] args) {
FileReader fileReader;//声明
try {
fileReader = new FileReader("e:/downloads/test.txt");
char c=(char)fileReader.read();//强制转型
System.out.println(c);//输出
} catch (FileNotFoundException e) {
e.printStackTrace();
}catch (IOException e){
e.printStackTrace();
}
}
}
Catch捕获异常的顺序： 如果异常之间有继承关系，越是顶层的类，越要放在下面。这是因为子类类型也属于父类，如果放在后面就永远不会被处理了！
- Throws
当CheckedExcption产生时，不一定立刻处理它，可以再把异常抛出去
自己不处理，谁调用我这个方法谁去处理
一般使用就一直往上抛，最高的那个再去处理
不推荐抛给main方法，即抛给JRE
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
String str=new TestException().openfile();//这里我需要去处理openflie()的抛出的异常
System.out.println(str);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//抛给调用的去处理了
static String openfile() throws FileNotFoundException,IOException{
FileReader fileReader=new FileReader("e:/downloads/test.txt");
char c=(char)fileReader.read();
return ""+c;
}
}
- 方法重写中声明异常原则
子类声明的异常范围不能超过父类声明的范围
- 父类没有声明异常，子类也不能。
- 不可抛出原方法抛出异常的父类或上层类
class A{
void getName()throws IOException{}
}
class B extends A{
void getName()throws FileNotFoundException{}//他的子类
}
class C extends A{
void getName(){}//可以不抛出
}
class D extends A{
void getName()throws Exception{}//这是IOException的父类
}
class E extends A{
void getName()throws IOException,FileNotFoundException{}//子类
}
class F extends A{
void getName()throws IOException,ArithmeticException{}//别的RuntimeException
}
class G extends A{
void getName()throws IOException,ParseException{}//IO是RuntimeException 而Parse不是
}
- finally
通常在finally中关闭程序块已打开的资源（服务器中不关会导致占用过大）
return的执行顺序
- 执行try，catch， 给返回值
- 执行finally
- return
public class RetrunTest {
public static void main(String[] args) {
String str=new RetrunTest().openFlie();
System.out.println(str);
}
String openFlie(){
try {
System.out.println("aaa");
FileInputStream fis=new FileInputStream("E:/downloads/test1.txt");
int a=fis.read();
System.out.println("bbb");
return "step1";
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
System.out.println("catching!!!");
e.printStackTrace();
return "step2"; //先确定返回的值，并不会直接结束运行。
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return"step3";
}finally{
System.out.println("finally!!!!!");
//return "fff"; //不要在finally里面使用return!
}
}
}
- 自定义异常
- 遇到标准异常无法处理的情况
- 从Exception类或他的子类派生出一个类
- 习惯上定义的类包含有2个构造器，一个默认的，一个带有详细信息的
public class MyException extends Exception{ //定义了我的Exception
public MyException(){ //默认构造器
super();
}
public MyException(String message){ //带信息的
super(message);
}
}
class TestMyException{
void text() throws MyException{ //示例方法
}
public static void main(String[] args) {
try {
new TestMyException().text();//调用需处理
} catch (MyException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
总结
- 一个图
- 五个关键字（try,catch,finally,throws,throw）
- 先逮小的，再逮大的
- 重写时异常
- 自定义异常
