从零开始学Java-Day09

静态代码块

执行顺序：

​ 静态代码块 —> 构造代码块 —>构造方法代码块

随着类的调用而执行

加载一些需要第一时间需要加载并且只能加载一次的资源

package cn.tedu.block;
//本类用来测试代码块之间的关系
public class TestBlock {
    public static void main(String[] args) {
        Person person = new Person();
        person.run();
        System.out.println("==============");
        /*在创建对象之间会先自动调用静态代码块而且此静态代码块只执行一次
        * 每一次创建对象构造代码块都会优先执行*/
        Person person1 = new Person();
        Girl girl = new Girl();
        System.out.println(girl.AGE);
    }
}

class Person{
    final String AGE = "永远的18岁";
    /*
    静态代码块
        位置：类里方法外
        触发时机：静态代码块也是静态资源随着类的加载而加载，优先于对象加载
        作用：用于加载一些需要第一时间加载的资源
     */
    static {
        System.out.println("我是静态代码块");
    }
    {
        System.out.println("我是构造代码块");
    }
    public Person(){
        System.out.println("我是一个无参构造方法");
    }
    public void run(){
        {
            System.out.println("我是局部代码块");
        }
        System.out.println("我是普通方法");
    }
}

class Girl extends Person{

}

final

1. 被final修饰的类，不能被继承
2. 被final修饰的方法，不能被重写
3. 被final修饰的变量是个常量，值不能被改变
4. 常量的定义形式：final 数据类型 常量名 = 值;

package cn.tedu.oppfinal;
//本类用作final的入门案例
public class TestFinal {
    public static void main(String[] args) {
        RiceHouse rh = new RiceHouse();
        //rh.oldFood();
//        rh.name = "specialWeek";
//        System.out.println(rh.name);
        rh.food();
    }
}
/*final表示最终，可以用来修饰类，被final修饰的类无法被继承*/
class House{
    final String name = "riceShower";//被final修饰的变量无法被再次修改，定义的时候必须赋值
    public void food(){
        System.out.println("青草");
    }
}

final class RiceHouse extends House{
    @Override
    public void food(){
        System.out.println("胡萝卜");
    }
//    public void oldFood(){
//        super.food();
//    }
}

多态

多态最经典的用法之一：

​ try - catch 异常处理：

package cn.tedu.oop;
//本类用于多态的入门案例
public class TestDemo {
    public static void main(String[] args) {
        Books books = new Books();
        LoveBooks loveBooks = new LoveBooks();
        FantasticBooks fantasticBooks = new FantasticBooks();
        books.read();
        loveBooks.read();
        fantasticBooks.read();
        Books yellowBooks = new YellowBooks();
        /*
        * 多态的前提：
        *   1.继承
        *   2.重写
        * 无法调用没被重写的子类功能
        * 多态的出现是为了统一标准，向父类看齐
        * 只能使用父类声明的功能（功能的表达形式如果在子类被重写用子类的，如果没有，用父类的），子类特有的功能无法使用*/
        yellowBooks.read();
        Books fb = new FantasticBooks();

    }
}

class Books{
    public void read(){
        System.out.println("读书使我快乐");
    }
}

class LoveBooks extends Books{
//    public void read(){
//        System.out.println("读爱情类的书使我想睡觉");
//    }
}

class FantasticBooks extends Books{
    public void read(){
        System.out.println("exciting!!");
    }
    public void value(){
        System.out.println("有价值");
    }
}

class YellowBooks extends Books{
    public void read(){
        System.out.println("Oh~~~~");
    }
}

package cn.tedu.oop;
//本类用于多态元素的测试
public class TestDemo2 {
    public static void main(String[] args) {
        LOL g1 = new LOL();
        System.out.println(g1.sum);//100
        g1.play();//重写的方法
        g1.dead();//特有的方法
        System.out.println("=====================");
        Game game = new LOL();
        /*
        多态中成员变量的使用都是父类的
         */
        System.out.println(game.sum);//10
        /*
        多态中方法的声明，看的是父类的，实现使用的时子类
         */
        game.play();
        /*
        创建父类中的静态方法
        如果有同名的静态方法使用的时父类的
         */
    }
}

class Game{
    int sum = 10;
    public static void play(){
        System.out.println("sa!开始我们的游戏吧");
    }
    public static void start(){
        System.out.println("game要开始吗");
    }
}

class LOL extends Game{
    int sum = 100;
    //@Override
    public static void play(){
        System.out.println("猎杀时刻到了！");
    }
    public void dead(){
        System.out.println("你已经阵亡！");
    }
}

class QQT extends Game{

}

异常

Throwable: 顶级父类

• Error:系统错误，无法修复
• Exception:可以修复的错误
  • RunTimeException
    • ClassCastException
    • ClassNotFoundException

​

package cn.tedu.exception;

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

public class ExceptionDemo {
    public static void main(String[] args) {
        //method1();
        //method2();
        //System.out.println(method3());
        //method4();
        f();//在main调用前处理异常
    }

    private static void f() throws InputMismatchException, ArithmeticException {
        try {
            method4();
        }catch (Exception e){
            System.out.println("请输入正确的数据");
        }
    }

    /*
    异常抛出的格式：在小括号与大括号之间写：throws异常类型
    若果有多个异常，使用逗号隔开
     */
    private static void method4() {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入第一个整数");
        int num1 = scan.nextInt();
        System.out.println("输入第二个个整数");
        int num2 = scan.nextInt();
        System.out.println(num1 + "/" + num2 + "=" +  num1 / num2);
        scan.close();
    }
    /*
    如果一个方法抛出异常，谁调用这个方法，谁处理这个异常
    两种方案：捕获解决和继续向上抛出
    会在main()调用之前解决异常
     */
    private static int method3() {
        Scanner scan = new Scanner(System.in);
        System.out.println("输入第一个整数");
        int num1 = scan.nextInt();
        System.out.println("输入第二个个整数");
        int num2 = scan.nextInt();
        if (num2 == 0){
            ArithmeticException e = new ArithmeticException("除数不能为0");
            throw e;
        }
        scan.close();
        return num1 / num2;
    }

    private static void method2() {
        Scanner scan = new Scanner(System.in);
        try {
            System.out.println("输入第一个整数");
            int num1 = scan.nextInt();
            System.out.println("输入第二个个整数");
            int num2 = scan.nextInt();
            System.out.println(num1 + "/" + num2 + "=" +  num1 / num2);
        }catch (InputMismatchException e){
            System.out.println("只能输入整数");
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }catch (Exception e){
            System.out.println("出错了，请找管理员");
        }
        scan.close();
    }

    private static void method1() {
        Scanner scan = new Scanner(System.in);
        /*
        try中放着可能会出现错误的代码
        如果发生了异常会被catch捕获，执行catch大括号中的解决方案
         */
        try {
            System.out.println("输入第一个整数");
            int num1 = scan.nextInt();
            System.out.println("输入第二个个整数");
            int num2 = scan.nextInt();
            try {
                System.out.println(num1 + "/" + num2 + "=" +  num1 / num2);
            }catch (Exception e){
                System.out.println("除数不能为0");
            }
        }catch (Exception e){
            System.out.println("请输入整数");
        }
        scan.close();
    }
}