Day6.10 final ，静态代码块，多态，异常

代码块
1.静态代码块
  位置：类里方法外，格式：static{ }
  执行时机：随着类的加载而加载，优先与对象加载，并且只加载一次
  作用：用于加载一些需要第一时间就加载并且只加载一次的资源
2.构造代码块
  位置：类里方法外，格式：{ }
  执行时机：创建对象时触发，优先于构造方法执行
  作用：用于提取所有构造方法的共性功能
3.局部代码块
  位置：方法里，格式：{ }
  执行时机：调用当前所处方法时才触发
  作用：用来控制变量的作用范围，变量的作用范围越小越好
4.执行顺序：
静态代码块->构造代码块->构造方法【创建好对象】->调用局部代码块所处的普通方法
5.为什么是这样的顺序呢？
静态代码块它也是静态资源，静态资源随着类的加载而加载，优先于对象的创建
静态资源只加载一次，并且一直存在，直到类消失，它才会消失
================================================
final
final是一个关键字，表示最终
1.被final修饰的类是最终类，不可以被继承
2.被final修饰的方法是方法的最终实现，不可以被重写
3.被final修饰的变量其实是一个常量，值不可以被修改
TIPS:声明常量时必须给常量赋值，不赋值会报错
================================================
多态--OOP三大特征之一
多态的前提：继承+重写
口诀1：父类引用指向子类对象
口诀2：编译看左边，运行看右边
解释：如果想要使用多态的效果，方法的声明看的是父类，而具体实现使用的是子类
我们目前学习的多态对象都是把自己当作是一个父类类型，所以：
1）多态对象不可以使用子类特有的功能
2）多态对象使用的成员变量是父类的
3）多态对象使用时，如果父子类中出现同名静态方法，使用的还是父类的
4）多态对象在使用方法时，如果子类重写了，使用的是子类的方法体
TIPS:静态资源属于优先加载的类资源，静态方法不存在重写的现象
==============================================
异常
异常类型 提示信息 报错的行号提示
异常的继承结构
Throwable--异常的顶级父类
    Error--系统异常，不可解决
    Exception--可编程解决的异常
         编译时异常--括号写错了，压根就通不过编译
         运行时异常--RunTimeException--InputMismatchException
异常的处理方案：
1.捕获处理
try{
       可能会出现异常的代码
}catch(异常的类型 异常的名字){
       捕获到异常的处理方案
}
TIPS:Catch可以嵌套，一般写一个Exception做通用解决方案就可以
2.向上抛出
格式：在方法定义的两个括号之间加一个throws 异常类型
          如果有多个异常，可以使用都好隔开
注意：如果方法抛出异常，谁调用这个方法，谁就得处理【捕获/抛出】
          不能把异常抛给main()，需要在main()调用之前解决掉

package cn.tedu.block;

import org.junit.jupiter.api.Test;

/*本类用来测试代码块之间的消息*/
public class TestBlock {
    @Test
    public void test() {
        /*1在创建对象之前，会先自动执行静态代码块，而且此静态代码块只执行一次
         * 2.每一次创建对象时都会调用构造代码块与构造方法，构造代码块先执行*/
        Person p = new Person();
        Person p2 = new Person();
        /*当对象调用方法时，如果方法有局部代码块局部代码块才会触发*/
        p.sleep();
        p.eat();

    }
}

class Person {
    /*静态代码块
     * 位置  类里方法外
     * 触发时机：静态代码块也是静态资源，随着类的加载而加载，优先于对象加载
     * 作用 ：用于专门完成一些需要第一时间加载的资源*/
    static {
        System.out.println("我是静态代码块");

    }

    /*构造代码块
     * 位置           类里方法外
     * 触发时机    创建对象时触发，优先与构造方法执行
     * 作用            提取构造方法中的共性内容*/ {

    }
    /*构造方法与类同名。且没有返回值类型，用于创建对象，在创建对象时触发*/

    public Person() {
        System.out.println("我是构造方法");
    }

    public void eat() {
        System.out.println("哈雷路亚");
    }

    /*局部代码块
     * 调用本方法时触发
     * 用来控制变量的控制范围变量的范围越来越好*/ {
        System.out.println("我是局部代码块");
    }

    public void sleep() {
        System.out.println("acc");
    }
}

package cn.tedu.demo;

import org.junit.jupiter.api.Test;
//重写快捷键 ctrl+o
/*本类用于多态的入门案例
 * 口诀对象；父类引用，指向子类对象
 * 编译看左边运行看右边
 * 多态使用的是父类的声明，子类的具体实现
 * 子类不可以调用子类的特有的功能
 * 多态的出现为了统一调用标准，向父类看齐
 * 父类声明的功能才可以用，子类特有的功能用不了
 * 如果想用子类的功能就调用子类的对象*/
public class TestDemo {
    @Test
    public void test() {
        Animal animal = new Animal();
        Cat cat = new Cat();
        /*声明父类new子类对象*/
        Animal animal1 = new Cat();
        animal1.eat();
        System.out.println(animal1.name);
    /*声明子类new父类对象需要进行类型强转
    * java.lang.ClassCastException: cn.tedu.demo.Animal cannot be cast to cn.tedu.demo.Cat
     类型强制转换异常*/
 /*  Cat cat1= (Cat) new Animal();
   Cat cat2=cat1;
   cat2.sleep1();
    cat1.sleep1();
    System.out.println(cat1.name);*/


        /*向下转型*/
        Cat cat1 = (Cat) animal1;
        cat1.sleep1();
    }
}

class Animal {
    String name = "Animal";

    public void eat() {
        System.out.println("填鸭");
    }
}

class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog");
    }
}

class Cat extends Animal {
    String name = "cat";

    @Override
    public void eat() {
        System.out.println("Cat");
    }

    public void sleep1() {
        System.out.println("老子要睡觉");
    }
}

package cn.tedu.demo;

import org.junit.jupiter.api.Test;

/*本类用于多态中元素的测试*/
public class TestDemo2 {
    @Test
    public void test(){
        Cat2 cat2 = new Cat2();
        System.out.println(cat2.sum);
        cat2.eat();
        cat2.play();
        /*创建多态对象
        父类引用 指向子类对象
        编译看左边运行看右边
        多态中成员变量的引用都是父类的
        多态中方法的声明看的是父类的，实现的是子类的
        静态资源属于类不存在重写的现象，只是恰好两个类中有两个同名的静态方法
        如果多态中存在静态资源 调用的是父类资源
        */

        Anamal2 animal2 = new Cat2();
        System.out.println(animal2.sum);//父类的
        animal2.eat();
        animal2.play();           
    }
}

class Anamal2 {
    int sum=10;
    public void eat(){
        System.out.println("吃啥都行");
    }
    public static void play(){
        System.out.println("玩啥都行");
    }
}
/*多态的前提 继承+重写*/
class Cat2 extends Anamal2 {
    int sum=100;

    @Override/*重写注解@Override*/
    public void eat() {
        System.out.println("小猫爱吃小鱼干");
    }
    public static void play(){
        System.out.println("汤姆 And 杰瑞");
    }

}

package cn.tedu.design;

import org.junit.jupiter.api.Test;

/*
 * 本类用于OOP汽车设计综合案例*/
public class DisgnCar {
    @Test
    public void test() {
        Car car = new Car();
        car.start();
        car.stop();
        HongQi hongQi = new HongQi();
        System.out.println(hongQi.color);//奶糖白
        hongQi.start();
        hongQi.stop();
        BSJ bsj = new BSJ();
        System.out.println(bsj.color);
    }
}

//定义汽车类
class Car {
    private String brand;//品牌
    private String color;//颜色
    private double price;//价格
    private double size;//尺寸

    public void start() {
        System.out.println("Fly");
    }

    public void stop() {
        System.out.println("FBI Warning ,STOP!");
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getSize() {
        return size;
    }

    public void setSize(double size) {
        this.size = size;
    }
}

class HongQi extends Car {
    String color = "奶糖白";


    @Override
    public void stop() {
        System.out.println("红旗********Stop");
    }
}

class BSJ extends Car {
    String color = "雅虎黑";


    public void fly() {
        System.out.println("速度是七十迈");
    }
}

package cn.tedu.exception;

import java.util.InputMismatchException;
import java.util.Scanner;

/*本类用来测试异常的入门案例*/
/*异常捕获处类的格式
 *
 *       try{
 *                   可能会出现异常的代码
 *    }catch(异常类型  异常的名字){
 *           捕获到了异常，进行处理的解决方案
 *   }
 *异常时典型的多态应用
 *
 * */
public class ExceptionDemo {
    public static void main(String[] args) {
        //  method1();  //人为暴露异常
       // method2();//异常解决方式一
        /*异常的抛出格式：再小括号与大括号之间写：throws 异常类型
        * 如果一个方法抛出了异常，那么谁调用这个方法，谁就需要处理这个异常
        * 两种解决方法  继续向上抛 或者解决掉
        * 一般在main方法调用之前解决而不是把问题抛给main方法，因为没人解决了*/
      f();//在main调用之前对异常进行解决
           // method3();//向上抛出--交给调用者来处理

    }

    private static void f() {
        try {
            method3();
        } catch (Exception e) {
            System.out.println("输入数据非法");
        }
    }

    private static void method3()throws Exception {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");//.InputMismatchException 输入的值与接收的类型不一样

        int i = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int j = scanner.nextInt();
        System.out.println(i / j);//ArithmeticException: / by zero 算术异常 除数不能为0

    }

    private static void method2() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");//.InputMismatchException 输入的值与接收的类型不一样
        /*try中存放着的时可能会出现异常的代码
        * 如果发生了异常，会被catch捕获，执行之前catch中提供的解决方案
        * try -catch可以嵌套，若果有多种异常类型需要特殊处理的话
        * 这就是多态最为经典的一种用法，我们并不关心子类的具体类型，而是将所有子类统一当做父类类型来处理，提供通用的解决方案*/
        try {

            int i = scanner.nextInt();
            System.out.println("请输入第二个整数");
            int j = scanner.nextInt();
            System.out.println(i / j);//ArithmeticException: / by zero 算术异常 除数不能为0
        } catch (InputMismatchException i) {
            System.out.println("输入数据非法");
        }catch (ArithmeticException a){
            System.out.println("0不能作为被除数");
        }catch (Exception e){
            System.out.println("您输入的数据不对");
        }finally {
            System.out.println("瞎巴巴");
        }


    }

    /*1.不要害怕bug，真正的勇士敢于直面自己写的bug
     * 2.学会看报错的信息提示，确定自己的错误方向
     * 3.学会看报错的行号信息确定自己的报错位置，哪里不对点哪里
     * 注意 源码不会错，要看自己写的代码*/
    private static void method1() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");//.InputMismatchException 输入的值与接收的类型不一样

        int i = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int j = scanner.nextInt();
        System.out.println(i / j);//ArithmeticException: / by zero 算术异常 除数不能为0


    }
}

package cn.tedu.oopfianl;

import org.junit.jupiter.api.Test;

/*本类用来final的入门案例*/

public class TestFinal {
    @Test
    public void test(){
        //6.创建子类对象进行测试
        Son son = new Son();
        son.eat();
        System.out.println(son.name);
    }
}
//1.创建Father类
/*使用final修饰父类，子类不能继承
* final表示最终不能用来修饰类
* 也就是没有子类，他自己就是最终类*/
class Father {
    //3.创建成员变量
    /*final可以用来修饰成员变量，被final修饰的变量值不可以被更改------------常量
    * 主语：常量在定义的时候就需要赋值，否则报错*/
    final String name="干饭人";
    //4.创建普通方法
    /*final修饰方法此方法不能被重写
    * final可以用来修饰方法，被final修饰的方法是最终实现，不能被重写*/
    public  void eat(){
        System.out.println("Father*********");
    }
}
//2.创建Son类 继承Father类
class Son extends Father{
    // name="打过人";
    //重写父类eat方法
    @Override
    public void eat() {
        System.out.println("Son**********");
    }
}

package cn.tedu.work;

import org.junit.jupiter.api.Test;

public class DemoTest {
@Test
    public void test(){
    Father father=new Son();
    father.eat("你是谁");
    System.out.println(father.name);
    System.out.println(father.age);

}

}

class Father {
    String name="我是爹";
    int age=99;
    public void test(){
        this.eat("");
    }
    protected  void  eat( String name){
        System.out.println("我是爹，我要吃饭");
    }
}

class Son extends Father {
    @Override
    public void eat(String name) {
        System.out.println("我是儿子我先吃饭");
    }
}