面向对象部分还有接口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的变量不会被垃圾回收。同时s tatic变量有违面向对象编程的思想。

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

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预定义的异常类：