内部类、常用类、正则表达式、File类(2015/8/01)

发布时间：2020-12-14 01:10:14 所属栏目：百科来源：网络整理

导读：内部类局部类范例抽象类不一定有抽象方法接口定义了一种接口Interfaceimplements实施匿名内部类常用类日期类Date 类 Calendar的使用Calendar的量许多为静态常量 format将时间按指定格式输出 parse将指定的字符串转化为时间常用类datecalendar格式化输

- 内部类局部类范例
抽象类不一定有抽象方法
接口定义了一种接口Interfaceimplements实施
- 匿名内部类
常用类
- 日期类Date
- 类 Calendar的使用Calendar的量许多为静态常量
  - format将时间按指定格式输出
  - parse将指定的字符串转化为时间
- 常用类datecalendar格式化输出正则表达式Pattern 的范例
正则表达式
try-catch
- throw异常
File类
IO流
- 创建文件以及判断文件时否存在
- FileOutStream向文件中写入字符串
  - Writer类是字符输出流的抽象类所有字符输出类都是它的子类BufferOutStream文件输出缓存流
- FileInputStream是对字节的操作从文件中读出文件
  - Reader类是字符输入流的抽象类BufferdInputStream文件输入缓冲流
- DateInputStream和DateOutputStream提供了三种文件写入方式
- ZIP压缩输入输出流

内部类、局部类范例

public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void study() { 
        class Book{//局部内部类，写在方法里面的类
            String bookName;
            public void read(){
                System.out.println("背单词");
            }
        }
        Book book=new Book();
        book.read();
        System.out.println("我在看英语");
    }

    class Pen { // 内部类
        String color;

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        String name;

        public void write() {
            System.out.println(Student.this.name+"用钢笔写字");
        }//Student.this.name调用的是Student类里面的名字,this.name调用的是内部类里面的名字

    }

抽象类（不一定有抽象方法）

1. 含有抽象方法的类为抽象类，不能创建对象。
       2.具体实现在子类中，若在子类中不实现，则子类也必须是抽象的.

接口（定义了一种接口）Interface，implements（实施）

接口例子：
public interface Fly{ }
接口中全部为抽象方法，省略了abstract,
//多态 —- 父类的引用指向子类的对象
//面向接口编程 —-接口的引用指向实现此接口的对象

匿名内部类

用途：当只是用一次这个类的对象时。主要在观察者模式里用到，主要用于事件的监听。
1. 另一种用法：类名 —引用=new—-类名（）{ 匿名内部类，可重写类的方法}

Student xiaoMing =new Student(){
            @Override
            public void study() {
                System.out.println("对类");
            }
        };

用接口实现匿名内部类，接口 — 引用==new – 接口（）{ 匿名内部类 }；

IPaper paper1=new IPaper() {
            @Override
            public String getPaper() {
                // TODO Auto-generated method stub
                return "123";
            }
        };

常用类

Date与Calendar转换

//将date转化成calendar
        rightNow.setTimeInMillis(date.getTime());
//将calendar转化成date
    Date date=rightNow.getTime();

日期类Date

//主要用到getTime()方法。得到的是自1970年到目前的秒数。
    Date date=new Date();
        System.out.println(date.getTime());

类 Calendar的使用：Calendar的量许多为静态常量

Calendar rightNow = Calendar.getInstance();
System.out.println(rightNow.get(Calendar.MONTH));
    // 对象.get(Calendar.静态量)
System.out.println(rightNow.get(Calendar.DAY_OF_MONTH));

rightNow.set(Calendar.DAY_OF_YEAR,rightNow.get(Calendar.DAY_OF_YEAR)+50);//更改日期，输出更改后的日期
    System.out.println(rightNow.get(Calendar.DAY_OF_MONTH));
    //

format将时间按指定格式输出

parse将指定的字符串转化为时间

SimpleDateFormat date=new SimpleDateFormat("yyyy年MM月dd天 HH--mm--ss G");//按指定格式输出，参考api
        System.out.println(date.format(rightNow.getTime()));
        String time="2015年09月20天 16--03--59 公元";
        try {
            System.out.println(date.parse(time));
            System.out.println(date.parse(time).getTime());
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
//输出为：
SimpleDateFormat date=new SimpleDateFormat("yyyy年MM月dd天 HH--mm--ss G");//标志
        System.out.println(date.format(rightNow.getTime()));
        String time="2015年09月20天 16--03--59 公元";
        //传入的时间格式必须与标志的地方相同
        try {
            System.out.println(date.parse(time));
            System.out.println(date.parse(time).getTime());
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

常用类date、calendar，格式化输出，正则表达式（Pattern）的范例

程序

public static void main(String[] args) {
        // Date date = new Date();
        // System.out.println(date.toString());
        // System.out.println(date.getTime());//得到秒数从1970年计数
        System.out.println("********************************************");
        // getInstance()是使用默认时区和语言环境获得一个日历。
        // Calendar rightNow = Calendar.getInstance();
        // System.out.println(rightNow.get(Calendar.YEAR));
        // System.out.println(rightNow.get(Calendar.MONTH));
        // System.out.println(rightNow.get(Calendar.DAY_OF_MONTH)); System.out.println("*********************************************");
        // Date date1=rightNow.getTime();//将Calender转化为Date
        // rightNow.setTimeInMillis(date1.getTime());//将date转化为Calender
        // rightNow.set(Calendar.DAY_OF_YEAR,rightNow.get(Calendar.DAY_OF_YEAR)
        // + 50);
        // System.out.println(rightNow.get(Calendar.DAY_OF_MONTH));
       System.out.println("********************************************"
        // 格式化输出
        // SimpleDateFormat format=new SimpleDateFormat("yyyy年MM月dd日 HH：mm：ss");
        // String time=format.format(rightNow.getTime());
        // System.out.println(time);
        // String time1="2015年08月01日 16：03：43";
        // try{
        // Date date2=format.parse(time1);
        // System.out.println(date2.getTime());
        // }catch(ParseException e){
        // e.printStackTrace();
        // }
       System.out.println("********************************************");
        // 手机号 11位数字13 15 17 18 14后面必须跟九位纯数字
        // Pattern p=Pattern.compile("^1(3|5|7|8|4)d{9}$");
        // Matcher m=p.matcher("13210159741");
        // boolean b=m.matches();
        // System.out.println(b);
        // 身份证号18位
        // Pattern p=Pattern.compile("^d{17}(d|x|X{1})$");
        // Matcher m=p.matcher("5107221991072619612");
        // boolean b=m.matches();
        // System.out.println(b);
        // 邮箱123as@qq.com|.cn|.net
        // Pattern
        // p=Pattern.compile("^d{3,}p{Lower}+@(d|p{Lower})+(.com|.cn|.net)$");
        // Matcher m=p.matcher("34534gdfq@163.com");
        // boolean b=m.matches();
        // System.out.println(b);

    }
}

正则表达式

在api中搜索Patter
1. 先建立一个表达式
2. 传入一个值
3. 判断是否匹配表达式

Pattern p = Pattern.compile("^d{17}(d|x|X){1}$");
        Matcher m = p.matcher("12345678945321456x");
        boolean b = m.matches();
        System.out.println(b);

        Pattern p1 = Pattern.compile("^d{3,}+@(d|p{Lower})+(.com|.cn|.net){1}$");
        Matcher m1 = p1.matcher("14@123.com");
        boolean b1 = m1.matches();
        System.out.println(b1);

try-catch

File file=new File("d://11txt");
    try{
        FileInputStream fis=new FileInputStream(file);
        fis.read();
        }catch(FileNotFoundException e){
            System.out.println("这个文件找不到");
            e.printStackTrace();
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            //必须运行，不管是否捕获到异常
            System.out.println("处理完毕");
        }
    System.out.println("");
出现异常后，catch方法后的语句也会执行。
finally语句，finally也是肯定会执行的语句

throw异常

继承Exception必须要进行捕获
继承Runtime Exception运行时异常，可以不进行捕获

public class Student {
    private int score;
    private String name;
    private String number;
    public int getScore() {
        return score;
    }
    public void setScore(int score) throws FailScore {
        if(score<60){
            throw new FailScore();
        }
        this.score = score;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getNumber() {
        return number;
    }
    public void setNumber(String number) {
        this.number = number;
    }

}

public class FailScore extends Exception {

    public FailScore() {
        super("不及格。");

    }
    @Override
    public void printStackTrace() {
        System.err.println("考砸了");
        super.printStackTrace();
    }


}

public class Main {

    public static void main(String[] args) {
        Student xiaoMing=new Student();
        try {
            xiaoMing.setScore(18);
        } catch (FailScore e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

File类

可查api文档，查看构造方法以及各种方法的实现
File file =new File(路径名);

IO流

创建文件以及判断文件时否存在

File file =new File("d://2.txt");
        if(file.exists()){

        }else{
            try {
                //不存在则新建文件
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

FileOutStream向文件中写入字符串

Writer类是字符输出流的抽象类，所有字符输出类都是它的子类。BufferOutStream文件输出缓存流。

String str="向文本写入文件";
        try {
            byte array[]=str.getBytes();
            FileOutputStream fos=new FileOutputStream(file);
            fos.write(array);
            fos.flush();//强制刷新缓冲区
            fos.close();//关闭文件输出流
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

FileInputStream是对字节的操作从文件中读出文件

Reader类是字符输入流的抽象类,BufferdInputStream文件输入缓冲流

try {
            FileInputStream fis= new FileInputStream(file);
            byte array[]=new byte[1024];//先创建字符数组
            int num=fis.read(array);//判断数组中内容的个数，当个数为-1时，结束
            while(num!=-1){
                System.out.println(new String(array,0,num));
                num=fis.read(array);//判断是否读到结尾时时，值会变为-1.
            }
            fis.close();
        } catch (FileNotFoundException e) {

            e.printStackTrace();
        } catch (IOException e) {

        e.printStackTrace();
        }

DateInputStream和DateOutputStream提供了三种文件写入方式：

writeBytes(String s )
writeChars(String s )
writeUTF(String s）

ZIP压缩输入/输出流

使用时查看api文档

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!