java04

包装类：
Java中的基本数据类型不是面向对象的（不是对象），所以有时候需要将基本数据类型转换成对象，包装类都位于java.lang包中，包装类和基本数据类型的关系(8种基本类型)：
byte--Byte
boolean--Boolean
short--Short
char--Character
int--Integer
long--Long
float--Float
double--Double
-------------------------------------------------------
Integer  i = new Integer(1000);
Object o = new Object();
System.out.println(Integer.MAX_VALUE);//2147483647
System.out.println(Integer.toHexString(i));//转成16进制
Integer i2 = Integer.parseInt("234");
Integer i3 = new Integer("333");
System.out.println(i2.intValue());//234
String str = 234+"";



(拆箱和装箱只用于基本类型和包装类进行转换)
自动装箱：基本类型自动封装到与它相同类型的包装中，
Integer i = 100;本质上编译器编译时为我们添加了Integer i = new Integer(100);
自动拆箱：包装类自动转换成基本类型数据，
int a = new Integer(100);本质上编译器编译时为我们添加了int a = new Integer(100).intValue();
Integer a = 1000;  //jdk5.0之后 .  自动装箱，编译器帮我们改进代码：Integer a = new Integer(1000);

Integer b = null;
int c = b;  //自动拆箱，编译器改进：b.intValue();由于b是null所以报空指针异常。

System.out.println(c); 

Integer  d = 1234;
Integer  d2 = 1234;

System.out.println(d==d2);//false
System.out.println(d.equals(d2));//true

System.out.println("###################"); 
Integer d3 = -100;    //[-128,127]之间的数，仍然当做基本数据类型来处理。
Integer d4 = -100;
System.out.println(d3==d4);//true
System.out.println(d3.equals(d4));//true        

时间类：
java中的时间精确到毫秒，java中的时间也是数字。是从1970.1.1点开始到某个时刻的毫秒数，类型是long(2的63次方，很大有几亿年).

Date d = new Date();///at Jul 12 10:44:51 CST 2014
long t = System.currentTimeMillis();///1405133115506
System.out.println(t);//1405133115506
Date d2 = new Date(1000);

System.out.println(d2.toGMTString());//不建议使用1 Jan 1970 00:00:01 GMT
System.out.println(d2);//Thu Jan 01 08:00:01 CST 1970
d2.setTime(24324324);
System.out.println(d2.getTime());
System.out.println(d.getTime()<d2.getTime());



Calendar类:
Calendar  c = new GregorianCalendar();
c.set(2001, Calendar.FEBRUARY, 10, 12, 23, 34);//给日期设置值

c.set(Calendar.YEAR, 2001);
c.set(Calendar.MONTH, 1);   //二月
c.set(Calendar.DATE, 10);
c.setTime(new Date());

Date d = c.getTime();
System.out.println(d);//Sat Jul 12 14:13:22 CST 2014
System.out.println(c.get(Calendar.YEAR)); //获得年份，2014

//测试日期计算
c.add(Calendar.MONTH, -30);//减30个月
System.out.println(c);



可视化日历：
package cn.bjsxt.test;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Scanner;

/**
 * 可视化日历程序
 * @author dell
 *
 */
public class VisualCalendar {
public static void main(String[] args) {
    System.out.println("请输入日期(按照格式：2030-3-10)："); 
    Scanner scanner = new Scanner(System.in);
    String temp = scanner.nextLine();//2033-3-4
    
    DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
    try {
        Date date = format.parse(temp);//Fri Mar 04 00:00:00 CST 2033
        Calendar calendar = new GregorianCalendar();
        
        calendar.setTime(date);
        int  day = calendar.get(Calendar.DATE);//4
        calendar.set(Calendar.DATE, 1);
        
        int maxDate = calendar.getActualMaximum(Calendar.DATE);//31
        System.out.println("日	一	二	三	四	五	六");
        
        for(int i=1;i<calendar.get(Calendar.DAY_OF_WEEK);i++){
            System.out.print('	');
        }
        
        for(int i=1;i<=maxDate;i++){
            if(i==day){
                System.out.print("*");
            }
            System.out.print(i+"	");
            int  w = calendar.get(Calendar.DAY_OF_WEEK);
            if(w==Calendar.SATURDAY){
                System.out.print('
');
            }
            calendar.add(Calendar.DATE, 1);
        }
        
    } catch (ParseException e) {
        e.printStackTrace();
    }
    
}
运行结果：
请输入日期(按照格式：2030-3-10)：
2013-3-4
日    一    二    三    四    五    六
                    1    2    
3    *4    5    6    7    8    9    

10    11    12    13    14    15    16    
17    18    19    20    21    22    23    
24    25    26    27    28    29    30    
31    

File:
文件和目录路径名的抽象表示形式。
File f = new File("d:/src3/TestObject.java");//构造函数，f代表了这个文件，要操作这个文件就可以通过f来操作。
File f2 = new File("d:/src3");//构造函数实例化f2,f2是一个目录
File f3 = new File(f2,"TestThis.java");//在f2中建一个文件TestThis.java，f3就代表了TestThis.java这个文件。
File f5 = new File("d:/src3/aa/bb/cc/ee/ddd");
f3.createNewFile();//创建文件，不是创建文件夹。
f3.delete();//删除文件
f5.mkdir();//f5没有创建出来,创建的时候如果前面的父目录存在则创建，不存在则创建失败。
f5.mkdirs();//前面的父目录不存在也创建。
if(f.isFile()){
    System.out.println("是一个文件");
}
if(f2.isDirectory()){
    System.out.println("是一个目录");
}



public class FileTree {
    public static void main(String[] args) {
        //找一个自己硬盘上有用的文件夹
        File f = new File("d:/aaa/bbb/ccc/ddd");
        printFile(f, 0);
    }
    
    static void printFile(File file,int level){
        for (int i = 0; i < level; i++) {
            System.out.print("-");
        }
        System.out.println(file.getName()); 
        
        if(file.isDirectory()){
            File[]  files = file.listFiles();
            for (File temp : files) {
                printFile(temp, level+1);
            }
        }
    }
}

异常：
error是错误，不需要程序员处理，遇到error就重启。

Exception是异常，要处理。
Exception分为checked Exceotion 和unchecked Exveption.

finally代码经常用来关闭资源，一个try可以有多个catch,catch异常的捕获是有先后顺序的，局部变量只是在代码快有效，出了代码快就不能用了。

（return 一是返回值，二是结束运行。）


方法重写中声明异常原则：子类声明的异常范围不能超过父类声明的范围。
1.父类没有声明异常（父类没有抛出异常），子类也不能。
2.不可抛出原有方法抛出的异常类的父类或上层类。

异常往往在高层处理，谁调用你谁处理。

关键字：try,catch,finally,throws,throw


File f = new File("c:/tt.txt");
if (!f.exists())  {
    try {
        throw new FileNotFoundException("File can't be found!");//抛出一个异常，是throw不是throws 
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }
}
        
        
    
public class TestReadFile {
    public static void main(String[]  args) throws FileNotFoundException, IOException {//把异常抛给了JRE,
        String str;
        str = new TestReadFile().openFile();
        System.out.println(str);
    }
    
    String openFile() throws FileNotFoundException,IOException {//throws把异常向外抛，谁调用谁处理。
        FileReader reader = new FileReader("d:/a.txt");//FileReade,这个对象资源要关。
        char c = (char)reader.read();//读取一个字符
        char c1 = (char)reader.read();//读取一个字符
        char c2 = (char)reader.read();//读取一个字符
        char c3 = (char)reader.read();//读取一个字符
        System.out.println(""+c+c1+c2+c3);
        return ""+c;
    }
}    
        
        
        



//自定义异常
public class MyException extends Exception {
    
    public MyException(){
        
    }
    
    public MyException(String message){
        super(message);
    }
    
}

class TestMyException{
    void test()throws MyException{
        ///
    }
    
    public static void main(String[] args) {
        try {
            new TestMyException().test();
        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}




class A {    
    public void method() throws IOException {    }
}
//方法重写的时候不要超了父类声明的异常的范围（编译通不过）
class B extends A {        public void method() throws FileNotFoundException {    }
}

class C extends A {        public void method() {    }
}

class D extends A {        public void method() throws Exception {    }     //超过父类异常的范围，会报错！
}

class E extends A {        public void method() throws IOException, FileNotFoundException {    }//没超过范围
}
class F extends A {        public void method() throws IOException, ArithmeticException {      }
}
class G extends A {        public void method() throws IOException, ParseException {    }//超范围
}