Java小白StudyDay09---代码块、final、多态、异常

一、代码块

1.静态代码块
位置：类里方法外，格式：static{ }
执行时机：随着类的加载而加载，优先与对象加载，并且只加载一次
作用：用于加载一些需要第一时间就加载并且只加载一次的资源
2.构造代码块
位置：类里方法外，格式：{ }
执行时机：创建对象时触发，优先于构造方法执行
作用：用于提取所有构造方法的共性功能
3.局部代码块
位置：方法里，格式：{ }
执行时机：调用当前所处方法时才触发
作用：用来控制变量的作用范围，变量的作用范围越小越好
4.执行顺序：
静态代码块->构造代码块->构造方法【创建好对象】->调用局部代码块所处的普通方法
5.为什么是这样的顺序呢？
静态代码块它也是静态资源，静态资源随着类的加载而加载，优先于对象的创建
静态资源只加载一次，并且一直存在，直到类消失，它才会消失
代码如下：

package cn.tedu.block;
/*本类用于测试代码块之间的关系*/
public class TestBlock {
    public static void main(String[] args) {
        //7.创建对象进行测试
        /*1.在创建对象之前，会先自动执行静态代码块，而且此静态代码块只执行一次*/
        /*2.每一次创建对象时，都会调用构造代码块与构造方法，构造代码块先执行*/
        Person p = new Person();
        Person p2 = new Person();//再次创建对象，静态代码块也不会执行了，只执行一次
        /*3.当对象调用方法时，如果方法里有局部代码块，局部代码块才会被触发*/
        p.sleep();
    }
}
//1.抽象封装形成一个Person类
class Person{
    //2.创建静态代码块
    /*静态代码块：
      位置：类里方法外
      触发时机：静态代码块也是静态资源，随着类的加载而加载，优先于对象加载，并且只加载一次
      作用：用于加载一些需要第一时间就加载，并且只加载一次的资源
    * */
    static{
        System.out.println("我是静态代码块~");
    }
    //3.创建构造代码块
    /*构造代码块：
      位置：类里方法外
      触发时机：创建对象时触发，而且要优先于构造方法执行
      作用：用于提取所有构造方法的共性功能
    * */
    {
        System.out.println("我是构造代码块~");
    }
    //4.创建构造方法
    /*构造方法是与类同名且没有返回值类型的方法，用于创建对象，在创建对象时触发*/
    public Person(){
        System.out.println("我是构造方法~");
    }
    //5.创建普通方法
    public void sleep(){
        System.out.println("我是普通方法，睡啥子睡");
        //6.创建局部代码块
        /*局部代码块
          位置：方法里
          执行时机：调用本方法时触发
          作用：用来控制变量的作用范围，变量的作用范围越小越好
        * */
        {
            System.out.println("我是局部代码块~");
        }
    }
}

二、final

final是一个关键字，表示最终
1.被final修饰的类是最终类，不可以被继承
2.被final修饰的方法是方法的最终实现，不可以被重写
3.被final修饰的变量其实是一个常量，值不可以被修改
TIPS:声明常量时必须给常量赋值，不赋值会报错

/*本类用作final的入门案例*/
public class TestFinal {
    public static void main(String[] args) {
        //6.创建子类对象进行测试
        Son s = new Son();
        s.work();
        //s.workOld();
        //s.name = "干饭人";
        System.out.println(s.name);
    }
}
//1.创建父类
/*1.final表示最终，可以用来修饰类
* 但是被final修饰的类无法被继承
* 也就是没有子类，它自己就是最终类
* */
//7.1使用final修饰类
//final class Father{//报错：Son类不能继承被final修饰的Father类
class Father{
    //3.创建成员变量
    /*3.final可以用来修饰成员变量，被final修饰的变量值不可以被修改--常量*/
    /*注意：常量在定义的时候就需要赋值，否则报错*/
    final String name = "打工人";
    //4.创建普通方法
    //7.2 使用final修饰方法
    //final public void work(){//报错：子类不可以重写父类中被final修饰的方法
    /*2.final可以用来修饰方法，被final修饰的方法是方法的最终实现，不能被重写*/
    public void work(){
        System.out.println("Father...打工人，打工魂");
    }
}
//2.创建子类,并与父类建立继承关系
class Son extends Father{
    //5.创建子类重写父类的work方法
//    public void workOld(){
//        super.work();
//    }
    public void work(){
        System.out.println("Son...现在的打工人要用计算机打工~");
    }
}

三、多态

多态是面向对象程序设计（OOP）的一个重要特征，指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。
多态–OOP三大特征之一
多态的前提：继承+重写
口诀1：父类引用指向子类对象
口诀2：编译看左边，运行看右边
解释：如果想要使用多态的效果，方法的声明看的是父类，而具体实现使用的是子类
代码如下：

package cn.tedu.oop;
/*本类用作多态的入门案例*/
public class TestDemo {
    public static void main(String[] args) {
        //5.创建对象进行测试
        Animal a = new Animal();
        Cat c = new Cat();
        a.eat();//小动物Animal吃啥都行~
        c.eat();//重写后！小猫Cat爱吃小鱼干！！！
        //a.jump();//父类无法使用子类的特有方法
        c.jump();//小猫Cat跳的老高啦~
        /*8.创建多态对象进行测试*/
        /*口诀1：父类引用 指向子类对象*/
        /*口诀2：编译(保存)看左边，运行(测试)看右边*/
        /*多态的两个前提：继承+重写，缺一不可!!!*/
        /*多态使用的是父类的声明，子类的具体实现*/
        Animal a2 = new Cat();
        a2.eat();//小猫Cat爱吃小鱼干！！！
        /*多态不可以调用子类特有的功能，只能调用重写的父类的功能*/
        //a2.jump();
        Animal a3 = new Dog();
        a3.eat();//小动物Animal吃啥都行~
        /*多态的出现是为了统一调用标准，向父类看齐
          父类声明的功能才能用，子类特有的功能用不了
          如果想用子类的特有功能，就创建纯纯的子类对象
        **/
    }
}
//1.创建父类
class Animal{
    //4.创建父类的普通方法
    public void eat(){
        System.out.println("小动物Animal吃啥都行~");
    }
}
//2.创建小猫类Cat，作为Animal类的子类
class Cat extends Animal{
    //6.重写父类中的eat()
    public void eat(){
        System.out.println("小猫Cat爱吃小鱼干！！！");
    }
    //7.定义子类中的特有方法jump()
    public void jump(){
        System.out.println("小猫Cat跳的老高啦~");
    }
}
//3.创建小狗类Dog，作为Animal类的子类
class Dog extends Animal{

}

我们目前学习的多态对象都是把自己当作是一个父类类型，所以：
1）多态对象不可以使用子类特有的功能
2）多态对象使用的成员变量是父类的
3）多态对象使用时，如果父子类中出现同名静态方法，使用的还是父类的
4）多态对象在使用方法时，如果子类重写了，使用的是子类的方法体
TIPS:静态资源属于优先加载的类资源，静态方法不存在重写的现象

package cn.tedu.oop;
/*本类用于多态中元素的测试*/
public class TestDemo2 {
    public static void main(String[] args) {
        //8.创建子类对象进行测试
        Cat2 c = new Cat2();
        System.out.println(c.sum);//100
        c.eat();//子类对象如果重写，调用的是重写过后的功能
        c.play();//子类对象调用自己特有的方法
        //9.创建多态对象进行测试
        /*口诀1：父类引用 指向子类对象*/
        /*口诀2：编译看左边 运行看右边*/
        Animal2 a = new Cat2();
        /*2.多态中，成员变量的使用都是父类的*/
        System.out.println(a.sum);//10
        /*3.多态中，方法的声明看的是父类的，实现使用的是子类的*/
        a.eat();
        /*4.多态中，如果父子类有同名的静态方法，使用的是父类的
        * 因为多态对象被看作是父类类型*/
        a.play();
    }
}
//1.创建父类Animal2
class Animal2{
    //3.创建成员变量
    int sum = 10;
    //4.创建普通方法
    public void eat(){
        System.out.println("吃啥都行~");
    }
    //10.创建父类中的静态方法
    public static void play(){
        System.out.println("玩啥都行~");
    }
}
//2.创建子类Cat2
/*多态的前提是：继承+重写*/
class Cat2 extends Animal2{
    //5.定义成员变量
    int sum = 100;
    //6.重写父类的eat()
    @Override/*@Override是一个注解，加在方法上，表示这是一个重写的方法*/
    public void eat(){
        System.out.println("小猫爱吃小鱼干~");
    }
    //7.定义子类独有的方法
    //public void play(){
    /*注意：静态资源属于类，不存在重写的现象
    * 只是两个类中恰好有两个同名的静态方法而已*/
    //11.定义子类中静态方法play
    //@Override--不能加此注解，不是重写
    public static void play(){
        System.out.println("小猫爱玩逗猫棒~");
    }
}

在这之后我们可以运用我们已经掌握的知识，来完成一个OOP汽车设计综合案例，将所学的知识进行运用才是我们真正应该做的。

package cn.tedu.design;
/*本类用于完成OOP汽车设计综合案例*/
public class DesignCar {
    //创建程序的入口函数
    public static void main(String[] args) {
        //8.创建一个纯纯的父类对象进行测试
        Car c = new Car();
        System.out.println(c.getColor());//null,需要使用get()/默认值
        c.start();//父类自己的功能
        c.stop();//父类自己的功能
        //c.fly();//父类不能使用子类的特有功能
        //9.创建一个纯纯的子类宝马类对象
        BMW b = new BMW();
        System.out.println(b.color);//五彩斑斓的黑,子类新定义的同名属性
        b.start();//没重写，使用的是父类的功能
        b.stop();//重写了，使用的是自己重写以后的功能
        //10.创建一个纯纯的子类保时捷类对象
        BSJ b2 = new BSJ();
        System.out.println(b2.getColor());//null
        System.out.println(b2.color);//黑不溜秋的白
        b2.start();//使用的是继承过来的父类中的功能
        b2.fly();//使用的是子类特有的功能
    }
}

//1.通过归纳总结，使用关键字class抽象封装形成一个"类"组件来描述一类事物
class Car{
    //2.属性--通过成员变量来描述
    //2.1 属性的封装--通过关键字private对属性进行封装
    private String brand;//品牌
    private String color;//颜色
    private double price;//价格
    private double size;//尺寸

    //3.行为--通过方法来描述
    public void start(){
        System.out.println("我的车车启动啦~");
    }
    public void stop(){
        System.out.println("哎呀妈，我的车车熄火了~");
    }

    //2.2 给被封装的属性提供公共的属性值设置和访问方式--GetXxx()、SetXxx()
    //快捷方式：右键->Generate->Getter and Setter->Shift全选->ok
    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;
    }
}

//4.创建一个宝马类并且继承汽车类--通过关键字extends建立继承关系
class BMW extends Car{
    String color = "五彩斑斓的黑";
    //6.子类对父类方法不满意时可以重写父类中的方法
    //重写遵循两同两小一大原则，重写后，子类对象使用重写后的方法
    @Override
    public void stop(){
        System.out.println("宝马当然要帅气的停的稳当些啦~");
    }
}
//5.创建一个保时捷类并且继承汽车类--通过关键字extends建立继承关系
class BSJ extends Car{
    String color = "黑不溜秋的白";
    //7.新增子类特有功能--父类不可使用，只有子类对象可使用此功能
    public void fly(){
        System.out.println("启动加速度，我要起飞啦UP~UP~");
    }
}

四、异常

异常
异常类型 提示信息 报错的行号提示
异常的继承结构
Throwable–异常的顶级父类
Error–系统异常，不可解决
Exception–可编程解决的异常
编译时异常–括号写错了，压根就通不过编译
运行时异常–RunTimeException–InputMismatchException
异常的处理方案：
1.捕获处理
try{
可能会出现异常的代码
}catch(异常的类型 异常的名字){
捕获到异常的处理方案
}
TIPS:Catch可以嵌套，一般写一个Exception做通用解决方案就可以
2.向上抛出
格式：在方法定义的两个括号之间加一个throws 异常类型
如果有多个异常，可以使用都好隔开
注意：如果方法抛出异常，谁调用这个方法，谁就得处理【捕获/抛出】
不能把异常抛给main()，需要在main()调用之前解决掉

package cn.tedu.exception;

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

/*本类用作测试异常的入门案例*/
public class ExceptionDemo {
    public static void main(String[] args) {
        //method1();//调用method1方法--人为暴露异常--看看异常长啥样
        //method2();//调用method2方法--异常解决方案1--捕获处理--自己解决
        //method3();//调用method3方法--异常解决方案2--向上抛出--交给调用者来解决
        f();//为了写一个标准的写法，在main()调用之前，处理掉异常
    }

    private static void f() {
        try{
            method3();
        }catch(Exception e){
            System.out.println("请输入正确的数据！");
        }
    }
    /*如果一个方法抛出了异常，那么谁调用这个方法，谁就需要处理这个异常
     * 这里的处理也有两种方案：捕获解决和继续向上抛出
     * 但是注意：我们一般会在main()调用之前解决掉异常
     * 而不是把问题抛给main(),因为没人解决了，详见本类f()调用method3()
     * */
    //6.创建method3(),异常解决方案2
    /*异常抛出的格式：在小括号与大括号之间写：throws 异常类型
     * 如果有多个异常，使用逗号分隔即可*/
//    private static void method3()
//            throws InputMismatchException,ArithmeticException,Exception{    private static void method3()
    private static void method3() throws Exception{
        //7.1复写刚刚的代码
        System.out.println("请输入您要计算的第一个整数：");
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入您要计算的第二个整数：");
        int b = new Scanner(System.in).nextInt();
        System.out.println(a/b);
    }

    /*异常捕获处理的格式：
     * try{
     *    可能会抛出异常的代码
     * }catch(异常类型 异常的名字){
     *    捕获到了异常，进行处理的解决方案
     * }
     * */
    //4.创建方法用来捕获处理异常--自己处理
    private static void method2() {
        //5.1按照捕获处理的语法提供异常解决方案一
        /*4.try中放着的是可能会出现异常的代码*/
        /*5.如果发生了异常，会被catch捕获，执行之前catch中提供的解决方案*/
        try{
            //5.2复写一下刚刚的代码
            System.out.println("请输入您要计算的第一个整数：");
            int a = new Scanner(System.in).nextInt();
            System.out.println("请输入您要计算的第二个整数：");
            int b = new Scanner(System.in).nextInt();
            System.out.println(a/b);
            //5.3捕获处理异常
        }catch(InputMismatchException e){//注意要导包
            System.out.println("请输入规定的整数类型！");
        }catch(ArithmeticException e){
            System.out.println("除数不能为0是~");
        }catch(Exception e){
            System.out.println("您输入的不对！请重新输入！");
        }
        /*6.try-catch可以嵌套，如果有多种异常类型需要特殊处理的话*/
        /*7.这就是多态最为经典的一种用法，我们并不关心子类具体的类型
         * 而是将所有子类统一当作父类类型来处理，提供通用的解决方案*/
    }

    private static void method1() {
        //1.提示并接收用户输入的第一个数
        System.out.println("请输入您要计算的第一个整数：");
        int a = new Scanner(System.in).nextInt();
        //2.提示并接收用户输入的第二个数
        System.out.println("请输入您要计算的第二个整数：");
        int b = new Scanner(System.in).nextInt();
        //3.直接打印这两个数除法的结果
        System.out.println(a/b);
        //输入3和3.5，报错：InputMismatchException--输入不匹配异常
        //输入17和0，报错：ArithmeticException--算术异常，除数不能为0是数学规定
        /*1.不要害怕BUG,真正的勇士敢于直面自己写的BUG*/
        /*2.学会看报错的信息提示，确定自己的错误方向*/
        /*3.学会看报错的行号信息，确定自己报错的位置，哪里不对点哪里
         * 注意：源码不会错，要看的是自己写的代码*/
    }
}