20150801

一、抽象类：

1.没有方法体：public abstract void eat();
2.特点：
1）只有方法名，没有方法体。
2）抽象类不能实例化（即不能创建对象）
3）抽象方法一定在抽象类中，即抽象类不一定包含抽象方法，但抽象方法一定在抽象类中。
4）抽象类中的方法要被使用，必须由子类复用其所有“抽象方法”。
如果子类只覆盖了部分方法，那么子类也是抽象类，需要加abstract修饰。
3.作用：
强迫子类去实现一些功能。
不让类建立对象。

public abstract class People {

    public void run(){

    }

    public abstract void eat(); //
    public abstract void drink();

}
子类：
public class Men extends People {

    public void eat(){
        System.out.println("run");
    }
    public void drink(){

二、接口：

接口：/注：无返回值一定写void，而无参数列表不写。/
1.声明格式：【修饰词列表】interface 接口名

2.特点：
1）接口中全部是“抽象方法”，省略abstract。
2）由于子类复写父类抽象方法，所以加标注：@Override
3）接口中不含构造方法。所以不可以直接通过接口来生成实例对象。

3.接口成员域：
默认成员域都有public,static和final属性。（不能包含protected和private属性）；
默认成员方法都有public,abstract属性。

//例如：
//Paper接口：
public interface Paper {  //接口Paper,仅一个paperSize的抽象方法
    public abstract void paperSize();

}
//Ink 接口：
public interface Ink {
    public abstract void inkColor();
}
//Print 接口：
public interface Print {
    public abstract void print(Paper paper,Ink ink);
}

//PaperQingdao 继承：
public class PaperQingdao implements Paper,Ink {
    @Override
    public void paperSize(){
        System.out.println("青岛纸张大小A4"); //必须实现接口中抽象方法

    }
    @Override
    public void inkColor(){
        System.out.println("青岛墨盒颜色：绿色");
    }


}
//测试：
public class Test03 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Paper paper = new PaperQingdao();  //多态性：接口指向子类对象。面向接口编程，这样方便以后扩展
        Ink ink = new PaperQingdao();

        Print priq = new PrintQingdao();
        priq.print(paper, ink);


    }

}
/*要面向接口编程，这里创建Print priq = new PrintQingdao();创建打印机时，可以利用一个类printFctory()来返回一个打印机对象。
即：
public class printFctory{
    public static Paper creatPaper(){
        return new Paper();
    }
}
//这样在用时：
Paper paper = printFctory.creatPaper(); //这样并不知道用的哪个纸
*/

4.接口和类的区别：
基本功能定义到类中；（隶属）
扩展功能定义到接口中。（象）

三、内部类

一）一般内部类
1.访问规则：
内部类：可以直接访问外部类的成员，包括私有。
外部类：要访问内部类，必须建立内部类对象。
2.实例化方法：
1）People peo = new People(); //第一种实例化方法
peo.name = “zhangsan”;
BeijPeople beijp = peo.new BeijPeople();
2） People.BeijPeople p = new People().new BeijPeople(); //第二种实例化方法
3.内部类若要使用外部类，可以用：外部类名称.this.
4.使用：
当描述事物时，其内部还有事物。
实例化演示：

内部类使用外部类

二）局部类：
局部类：（在方法中的类）
1.只能在本方法中创建对象。
2.注意：
1）不能用static修饰。

三）匿名内部类：
1.适用：仅适用对象一次
2.前提：匿名内部类必须是继承一个类或者实现接口。
3.格式：new 父类型名（）{父类型构造方法的调用参数列表}；、
4.注意：
1）匿名内部类里面的方法不要超过三个，否则就不要匿名了。
2）类不能具有abstract和static属性。
不能派生子类。
匿名内部类的成员域具有static时，则必须同时具有final属性。
不能含有static属性的成员方法。
3）//不能调用内部类中建的自己的方法，除非在自己内部类中使用。

四、正则表达式：

1.调用顺序：
Pattern p = Pattern.compile(“a*b”);//生成一个匹配的格式
Matcher m = p.matcher(“aaaaab”);
boolean b = m.matches();
或者直接： boolean b = Pattern.matches(“a*b”, “aaaaab”);

五、异常

附：

1.解决异常：

理解：
对捕获到的异常进行的常见的方法操作：
1）String getMessage(); //获取异常信息
2）String toString(); //异常名称：异常信息
3)void printStackTrace();//异常名称，信息，异常出现的位置。
注：当多个catch时，父类catch放在后面。
2.抛出异常：
格式：方法后接 throws 异常名称
3.自定义异常：
1>

/*
 * 自定义FailScores这样一个异常类，继承Exception类
 * */
public class FailScores extends Exception {
    public FailScores(){  //构造函数
        super("不及格！");

    }

    @Override
    public void printStackTrace(){   //复写printStackTrace方法：将此 throwable 及其追踪输出至标准错误流。
        System.err.println("成绩不理想！");
        super.printStackTrace();  //调用父类printStackTrace方法输出错误流

    }

}

/*在一个方法中使用这个异常*/
public class Student {
    private String name;
    private int score;

    public int getScore(){
        return score;
    }

    public void setScore(int score) throws FailScores{  //某个方法使用这个异常用throws
        if(score<60)
            throw new FailScores();  //如果发现这个错误就抛出这个异常（创建对象）
        this.score = score;

    }


}

/*测试这个方法*/
public class Test04 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student stu = new Student();
        try {
            stu.setScore(50);  //setScore()方法有异常，所以用try，catch
        } catch (FailScores e) {    //当捕捉到FailScores异常时，运行catch
            // TODO Auto-generated catch block
            e.printStackTrace();   //FailScores中的printStackTrace方法已被重写。
        }

    }

}

2>
自定义类继承RuntimeException时，用自定义类的方法可以不用throws,直接throw就行，且测试时不需要用try和catch。

六、输入输出流

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileInputOut {

    public static void main(String[] args) {

        /*写入文字，用输出流*/
        File file = new File("d://abc.txt"); //建文件对象
    /*  
        if(!file.exists()){    //判断文件是否存在，不存在就创建
            try {
                file.createNewFile();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }

        String word = "我写入了文字！";
        byte[] array = word.getBytes(); //将字符串变成字节输出

        try {
            FileOutputStream fos = new FileOutputStream(file); //产生FileNotFoundException异常
            fos.write(array);  //产生IOException异常
            fos.flush();
            fos.close();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        */

        /*读文件中字节*/
        byte[] array2 = new byte[1024];  //创好字节数组
        try {
            FileInputStream fis = new FileInputStream(file);  会有异常
            int num = fis.read(array2); //产生的是IOException异常，这里read（array2）返回的是读入缓冲区的字节总数
            while(num!=-1){  //当读完了就为-1，所以这里只要没读完就
                //System.out.println(num);
                System.out.println(new String(array2,0,num));
                num = fis.read(array2);         //继续读   

            }
            fis.close();
            } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } 





    }

}

小知识：

1.对象的常量：final int i = 10;
类的常量 ：static final int j = 10;