javaday14：instanceof、Static、抽象类、接口、内部类、异常 - 《Java 笔记 - 反射动态代理》

instanceof关键字可以检测类与对象是否有父子关系。
例子代码如下：

package com.codeday14.demo01;
public class Person {
    public void run(){
        System.out.println("可以跑");
    }
}

package com.codeday14.demo01;
import org.w3c.dom.ls.LSOutput;
public class Student extends Person{
}

package com.codeday14.demo01;
public class Teacher extends Person{
}

package com.codeday14.demo01;
public class Application {
    public static void main(String[] args) {
        Object object = new Student();
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
    }
}

在application中，如果输入

        Person person = new Student();
        System.out.println(person instanceof String);

会直接编译报错，因为这两个类是两个分支，没关系。
这里其实是new了一个Student对象。
父类不能调用子类的方法，但是可以强制把父类转换成子类。
例如：

        Person obj = new Student();
        Student student = (Student) obj;
        student.run();

上面的代码和((Student) obj).run();效果一致。
Java就是抽象！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！

static：
类的静态属性

package com.codeday14.demo02;
public class Student {
    private static int age;
    private double score;
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);
        System.out.println(Student.score);//非静态的变量不能直接通过类调用
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

static属性在内存中只有一个，类中可以公用，但是非static属性不行。
还有静态方法，不想听，后面学。

静态代码块：
调用构造器后自动执行一次，后面再new就不执行，匿名代码块每次都执行。

package com.codeday14.demo02;
public class Person {
    {
        System.out.println("匿名代码块");//匿名代码块
    }
    static {
        System.out.println("静态代码快");
    }
    public Person(){
        System.out.println("构造器");
    }
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("=================");
        Person person1 = new Person();
    }
}

还可以通过static关键字静态导入包

package com.codeday14.demo02;
//静态导入包
import static java.lang.Math.random;
public class test {
    public static void main(String[] args) {
        System.out.println(Math.random());
    }
}

final：
final修饰的类不能被继承，断子绝孙喽。

abstract（抽象类）：
抽象类用abstrct修饰，可以被单继承，不能new。
抽象类中可以有普通方法。
抽象方法也用abstract修饰，该类方法只有约束，没有实现。
抽象方法所在的类必须为抽象类。
抽象类有构造器。
继承了抽象类的子类，必须实现抽象类的方法，除非它也是抽象类（套娃）。
为啥要搞一个抽象类，没搞懂，后面实际操作留意一下。

接口：
接口只有规范，自己无法写方法 —> 约束和实现分离。
接口用interface定义。
接口中的所有定义都是抽象的（public abstract）。
接口都有实现类，类通过Implements来实现接口，实现类必须实现所有方法才可以。
接口中定义的属性是常量（public static）。
在实现类中，按alt+insert快捷键可以一键重写。
例：

package com.codeday14.demo03;
// 接口
public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.codeday14.demo03;
public interface TimeService {
    void timer();
}

package com.codeday14.demo03;
//类 可以实现接口，通过implements，可以多继承
public class UserServiceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void update(String name) {
    }
    @Override
    public void query(String name) {
    }
    @Override
    public void timer() {
    }
}

内部类：
内部类可以调用外部类的private属性。
内部类可以分为内部类，静态内部类，局部内部类。
太操蛋了，不想听。

异常：
Error：虚拟机崩了，JVM会中止运行。
Exception：一般是由程序逻辑错误引起的。

异常处理的五个关键字：
try\catch\finally\throw\throws

package com.codeday14.demo05;
public class ErrorTest {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        try {
            System.out.println(a/b);
        }catch(ArithmeticException e) { //捕获异常，括号里是想要捕获的异常类型
            System.out.println("程序出现异常，变量b不能为零");
        }catch (Throwable t){ //catch可以写多个
            System.out.println("Throwable");
        }finally { //处理善后工作
            System.out.println("finally");
        }
        // finally可以不用，catch是必要的
    }
}

ctrl+Alt+T可以快捷生成语句。

主动抛出异常：throw和throws，一般用在方法中。

        if (b == 0){
            throw  new ArithmeticException(); // 主动抛出异常
        }

ended at No.79
to be continued…