javaOOP（抽象类和接口，异常......）

抽象类和接口：

抽象类针对的是类，接口针对的是行为。

抽象类使用abstract修饰。抽象类中可以没有抽象方法，但是如果有抽象方法，类也必须是抽象的。

抽象类不能实例化。

子类继承抽象类必须实现抽象类的方法，抽非子类也是抽象类。

抽象类：人类。有普通方法和抽象方法。

public abstract class People {
    private String name;
    private String sex;
    private String profession;

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getProfession() {
        return profession;
    }

    public void setProfession(String profession) {
        this.profession = profession;
    }

    //介绍信息
    public abstract void introduction();
    //吃
    public abstract void eat();
    //跑
    public abstract void run();

}

子类：学生，教师。实现了父类的抽象方法。

public class Student extends People{

    public Student() {
    }

    public Student(String name, String sex, String profession) {
        setName(name);
        setSex(sex);
        setProfession(profession);
    }

    @Override
    public void introduction() {
        System.out.println("我是"+getName()+"，性别："+getSex());
    }

    @Override
    public void eat() {
        System.out.println("我是"+getProfession()+"，我吃食堂");
    }

    @Override
    public void run() {
        System.out.println("我是"+getProfession()+"，我跑步为了中考");
    }
    
}

public class Teacher extends People{

    public Teacher() {
    }

    public Teacher(String name, String sex, String profession) {
        setName(name);
        setSex(sex);
        setProfession(profession);
    }

    @Override
    public void introduction() {
        System.out.println("我是"+getName()+"，性别："+getSex());
    }

    @Override
    public void eat() {
        System.out.println("我是"+getProfession()+"，我可以回家吃，也可以在是食堂吃");
    }

    @Override
    public void run() {
        System.out.println("我是"+getProfession()+"，我跑步为了身体健康");
    }

}

测试：

public class Test {
    public static void main(String[] args) {
        Student student=new Student("张三","女","学生");
        student.introduction();
        student.eat();
        student.run();
        Teacher teacher=new Teacher("里斯","男","老师");
        teacher.introduction();
        teacher.eat();
        teacher.run();
    }
}

输出结果：

我是张三，性别：女
我是学生，我吃食堂
我是学生，我跑步为了中考
我是里斯，性别：男
我是老师，我可以回家吃，也可以在是食堂吃
我是老师，我跑步为了身体健康

接口是标准和规范。 

接口里不能包含普通方法，在接口中，所有的方法都必须是抽象的。

定义接口需要使用interface关键字修饰。

接口中只能包含抽象方法及常量，常量必须在接口中定义时就初始化。接口和抽象类一样不能创建自己的对象。

接口继承其他接口时，是可以看多继承的。

public interface 接口名{
    类型 常量字段名=值；
    返回类型 方法名（参数列表）；
}

接口A：定义常量PI，底面积方法。接口B：定义颜色方法。接口C：定义体积方法，并继承A和B。

public interface A {
    double PI=3.14;
    double area();
}
interface B{
    void setColor(String c);
}
interface C extends A,B{
    void volume();
}
class Cylinder implements C{
    double radius;
    double height;
    String color;

    public Cylinder(double radius, double height) {
        this.radius = radius;
        this.height = height;
    }

    @Override
    public double area() {
        double bottomArea=PI*radius*radius;
        return bottomArea;
    }

    @Override
    public void setColor(String c) {
        color=c;
        System.out.println("颜色："+c);
    }

    @Override
    public void volume() {
        double columnVolume=area()*height;
        System.out.println("圆柱体体积："+columnVolume);
    }
}

测试：

class CylinderTest{
    public static void main(String[] args) {
        Cylinder cylinder=new Cylinder(4,5);
        cylinder.setColor("绿色");
        cylinder.area();
        cylinder.volume();
    }
}

结果：

颜色：绿色
圆柱体体积：251.20000000000002

工厂模式：

墨盒和纸张：

//墨盒
public interface InkBox {
    void multicolor();
    void black();
}
//纸
public interface Paper {
    void a4();
    void B5();
}

 分别由工厂生产：

//墨盒工厂
public class InkBoxMaker implements InkBox{
    @Override
    public void multicolor() {
        System.out.print("使用彩色墨盒");
    }

    @Override
    public void black() {
        System.out.print("使用黑色墨盒");
    }
}
//纸工厂
public class PaperMaker implements Paper{
    @Override
    public void a4() {
        System.out.println("在A4纸上打印");
    }

    @Override
    public void B5() {
        System.out.println("在B5纸上打印");
    }
}

打印机打印：
 

public class Printer {

    public void printe(InkBoxMaker inkBoxMaker,PaperMaker paperMaker){
        inkBoxMaker.black();
        paperMaker.a4();
        inkBoxMaker.multicolor();
        paperMaker.B5();
    }

}

调用打印机：

public class Test{
    public static void main(String[] args) {
        Printer printer=new Printer();
        printer.printe(new InkBoxMaker(),new PaperMaker());
    }
}

输出：

使用黑色墨盒在A4纸上打印
使用彩色墨盒在B5纸上打印

异常：

try{
    需要捕获异常的代码
}catch(Exception e){
    对异常进行处理
}finally{
    有无异常都会执行的代码；
    //通常用来关闭资源
}

程序发生异常时进入catch。

多重try...catch：
当try内的try...catch捕获不到异常时，由外面的cath进行捕获。

throw:引发异常。

throws:跟在方法之后，说明该方法抛出某些异常，由调用者来处理。