随堂笔记8

多态

多态就是方法重写，详见笔记7方法重写
注意点
1. 属性没有多态
2. 父类和子类有联系（类型转换异常）ClassCastException
3. 存在条件：继承关系，方法需要重写，父类引用指向子类 #Father f1=new Son()；
4. 不能重写的方法
  1. static 方法，属于类，不属于实例
  2. final常量
  3. private 私有的

instanceof和类型转换

instanceof判断对象和类是否有父子关系

对象类型看new关键词后边的类型（区分与方法的调用）

import com.yyl.demo03.Person;
import com.yyl.demo03.Student;
import com.yyl.demo03.Teacher;

public class Application {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Student
        //Object>Person>Teacher
        Person person=new Student();
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Teacher);
        //System.out.println(person instanceof String);编译报错
    }
}

类型转换

类型可以自动从高转到低

强制转换

import com.yyl.demo03.Person;
import com.yyl.demo03.Student;

public class Application {
    public static void main(String[] args) {
         //低转高可以自动转换student->Person
        Person student=new Student();
        //无法调用student.go();能调用的方法看最左边的定义，对象的类看最右边的定义
        Student student1=(Student)student;//强制转换为student类型
        student1.go();
        //或者((Student) student).go();
    }
}

子类自动转化为父类，可能会丢失一些函数

static

static修饰符修饰的变量或者函数可以直接类调用：类名+函数名（变量名）
代码块
static最先缓冲，所以内部不能调用非static数据

抽象类

在一个类之前加abstract关键字就变为抽象类
在一个函数之前加abstract关键字变为抽象方法，抽象方法只有方法名字，没有方法实现
抽象类的子类都必须有重写该函数的方法
java类单继承，但接口可以多继承
注意
1. 抽象类不能实例化，不能new一个对象 ~约束
2. 抽象方法只能在抽象类中
3. 抽象类中可以有普通方法
4. 抽象方法只是一种约束

接口

关键词：interface #public interface 类名{ }
接口中全部为抽象方法
接口中的定义都是抽象的public（默认为public abstract,可以省略该部分）
实现接口的类关键词implements+接口名多个接口用逗号隔开
实现接口的类，就必须重写接口的方法
可以利用接口实现多继承

接口中可以定义常量，int a=99；默认省略public static final

//接口1
public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

//接口2
public interface TimeService {
    void timer();
}

//实现类
//类可以实现接口，通过 implements+接口
public class UserServiceImpl implements UserService,TimeService{//完整版
//快捷键alt+insert
    @Override
    public void timer() {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}

接口小节
1. 约束
2. 定义一些方法，让不同的人去实现
3. public abstract
4. public static final（可省略）（只能声明常量）
5. 接口不能被实例化，接口中没有构造方法
6. implements可以实现多个接口，类中必须实现（重写）接口中所有方法

n种内部类

public class Outer {
    private int a=1;
    public void out(){
        System.out.println("这是外部类方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类方法");
        }
        public void visit(){//获得外部类的私有属性
            System.out.println(a);
        }
    }
}

public class Application {
    public static void main(String[] args) {
      Outer s1=new Outer();
      s1.out();
      //通过外部类来实例化内部类
      Outer.Inner s2=s1.new Inner();
      s2.in();
      s2.visit();
    }
}

=======================================================================================

匿名类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化，不用将实例保存到变量中
        new Apple().eat();
        new UserService(){
            @Override
            public void hello() {//重写hello接口的函数

            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("1");
    }
}
interface UserService{
    void hello();
}

异常机制

异常的种类
异常的捕获

要捕获多个异常要从小到大捕获

public class demo01 {
    public static void main(String[] args) {
        int a=1;
        int b=0;

        try{//try监控区域
            System.out.println(a/b);
            //new demo01().a();
            if(b==0){//主动抛出异常 throw throws
               throw new ArithmeticException();//主动抛出异常
            }
        }catch(ArithmeticException e){//catch捕获异常括号内为捕获异常的类型，最高级为Throwable
            System.out.println("程序出现异常，变量b不能为0");
            e.printStackTrace();//打印错误栈信息(和原本错误提示相同)
            System.exit(0);
        }catch(Error e){
            System.out.println("Error");
        }
        catch(Throwable e) {
            System.out.println("Throwable");
        }finally {//处理善后工作
            System.out.println("Final");
        }//可以不要finally

    }
    public void a(){
        b();
    }
    public void b(){
        a();
    }
}

一般用在方法内抛出异常，方法处理不了异常可以进行异常上抛
所有异常都需要被捕获，否则程序停止

public class Test {
    public static void main(String[] args) {
        //可以让程序发生不停止，继续运行
        try {
            new Test().test(1,0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }
    }
    //假设方法无法处理这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{
        if(b==0){//throw
            throw new ArithmeticException();
        }
    }
}

自定义异常

//测试异常
public class Test {
    //可能会存在异常的方法
    static void test(int a) throws MyException{
        System.out.println("传入的数为"+a);
        if(a>10){
            throw new MyException(a);//抛出
        }
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {//可以增加一些处理异常的代码
            System.out.println("My Exception=>"+e);
        }
    }
}

//自定义异常
//首先继承异常类
public class MyException extends Exception{
    //传递数字
    private int detail;

    public MyException(int detail) {
        this.detail = detail;
    }
    //toString

    @Override
    public String toString() {//异常的打印信息
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}