面向对象部分还有接口interface，放在一起记了。

接口Interface

抽象：抽象类和抽象方法的定义使用abstract修饰符

//抽象类

pubic abstract class Action{
	//抽象方法
?	public abstract void doSomething(){
?	}
}

• 抽象类的所有方法必须要子类实现，如果子类也是abstract，则由子子类实现这些方法。
• 抽象类 不能用new实例化对象，只能由子类继承并重写子类中的方法。
• 使用抽象类方便后期代码的扩展。

接口：

• 普通类-只有具体实现
• 抽象类：具体实现和规范（抽象方法）
• 接口：规范 ，约束和实现分离：面向接口编程

定义一个接口文件UserService，使用interface声明，这个关键字可以和class类比理解

//抽象的思维——Java   架构师
public interface UserService {
    //接口中的所有定义都是抽象的
    void add(String name);
    void delete(String name);
    void update(String name);
    void  query(String name);
}

接口都需要由实现类，它需要有类去继承接口并重写接口的方法；这样做的好处是，只需要定义好接口，就可以把工作下发，多人协作完成。

定义一个类实现接口：

//抽象类extends
//类 实现接口 implements
//实现了接口就必须重写所有方法 alt+insert 快捷键重写方法
public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {
        System.out.println("添加了"+name);
    }

    @Override
    public void delete(String name) {
        System.out.println("删除了"+name);

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

类型转换

类型转换：看个例子

//父类与子类的转换 Student类继承Person类

Person person = new Student();

//Student把这个对象转换成Student类型，就可以使用Student方法了

Student student = (Student)person;

Student.study();

• 子类转换成父类，向上转型，直接转换
• 父类转换成子类，向下转型，强制转换（高转低会损失精度）
• 方便方法的调用，减少重复的代码！

static关键字：

static声明的变量和方法生存在类中，类内可以直接调用，无需实例化对象调用。

但是不要觉得static更容易调用就全部使用static声明，在Java中，static的变量是和class绑定在一起的，也就是说在垃圾回收的过程中，除非class被回收掉，那么static的变量不会被垃圾回收。同时static变量有违面向对象编程的思想。

//观察区别--静态变量--非静态变量

private static int age;
private double score;

//static声明的变量和方法生存在类中，类内可以直接调用，无需实例化对象调用

public static void main(String[] args){

Student s1 = new Student();
//static变量可以直接调用，不用新建一个变量
System.out.println(Studnet.age);
//新建一个变量调用它也可以
System.out.println(s1.age);
//非static必须新建实例化变量调用
System.out.println(s1.score);

}

final关键字：final之后，断子绝孙，final修饰的类无法被继承

内部类

成员内部类

顾名思义，在类的内部再定义一个类作为它的成员，这是Java允许的

public class Outer {
    private int id;
    public void out(){
        System.out.println("这是外部的方法");
    }
    //成员内部类
    class Inner{
        public void in(){
            System.out.println("这是内部的方法");
        }
    }
}

调用:

public class Application {
    public static void main(String[] args){
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        //调用内部类的方法
        inner.in();
    }
}

静态内部类

就多了static关键字声明，和静态变量、静态方法的使用类似

匿名内部类

public class Test {
    public static void main(String[] args){
        //没有名字初始化类 匿名内部类，不需要把实例保存到变量中
        new Person().getName();
    }
}

• 一个class文件中可以有多个class，但是只能有一个public class

今天只看了下什么是内部类，内部类这一块后面再研究一下，为什么要使用内部类，使用内部类实现接口好像是一种很好的做法，并且内部类可以实现Java中没有的多继承的功能。

异常处理

什么是异常（Exception）：异常分为运行时异常(RuntimeException)检查性异常、错误ERROR。

• 检查性异常，比如代码编写语法错误，包引入出错等都属于检查异常
• 运行时异常 比如除数为0，这种代码检查不出来错误，但是运行会报错的异常情况。
• 错误通常是致命性的错误，是程序无法控制的，JVM虚拟机可能因此而终止。Exception通常是可以被程序处理的，并在程序中尽可能去处理这些异常。

public class Demo01 {
    public static void main(String[] args){
        System.out.println(11/0);
    }
}

异常捕获

异常处理关键字：try、catch、finally、throw、throws

看个例子：

try--监控代码段；catch--捕获异常并处理；finally--善后工作，必被执行

public class Test {
    public static void main(String[] args){
        int a = 1;
        int b = 0;
        int c = 0;
        try{//监控区域
            c = a / b;
        }catch (Error error){//捕获异常
            System.out.println("出现ERROR");
        }catch(ArithmeticException e){//捕获异常
            System.out.println("出现异常ArithmeticException");
        }finally {//无论出不出现异常，finally都会执行
            System.out.println("finally执行完毕");
        }
    }
}

throw&throws 抛出异常，主动抛出异常

//假设方法中处理不了这个异常，把它抛到更高级去处理--throws
public void test(int a,int b) throws ArithmeticException{
    
    if(b==0){
        throw new ArithmeticException(); //主动抛出异常，一般在方法中使用
    }
}

自定义异常：

自定义异常类，需要继承Exception类。一般用不到自定义，Java预定义了大多数情况的异常。

Java预定义的异常类：