Java学习_Day 09(学习内容：狂神说JAVA零基础3P73-4P80)

3P73 static关键字详解

package com.oop;

public class P73_person {
    {
        // 2.代码块(匿名代码块) 可用来赋初始值
        System.out.println("匿名代码块");
    }
    static {
        // 1.静态代码块--只执行一次
        System.out.println("静态代码块");
    }

    public P73_person() {
        // 3. 构造方法
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        P73_person person1 = new P73_person();
        System.out.println("===============");
        P73_person person2 = new P73_person();
    }
}

package com.oop;

public class P73_student {
    private static int age; // 静态变量
    private double score;   // 非静态变量

    public void run(){
        // 非静态方法可调用静态方法
        go();
    }
    public static void go(){

    }

    public static void main(String[] args) {
//        P73_student student = new P73_student();
//        System.out.println(P73_student.age); // 类变量
//        System.out.println(student.age);
//        System.out.println(student.score);
        new P73_student().run();
        P73_student.go(); // 静态方法是和类一起加载的
    }
}

package com.oop;
import java.lang.Math;

// 静态导包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class P73_test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

3P74 抽象类

package com.oop;
// 抽象类: 类  extend是单继承  接口可以多继承
public abstract class P74_action {
    // 约束，有人帮我们实现
    // 抽象方法只有方法名 没有具体实现
    public abstract void doSomething();
}
/*
抽象类特点：
    1. 不能new，只能靠子类去实现
    2. 抽象类可写普通方法
    3. 抽象方法必须在抽象类中
抽象的抽象
 */

package com.oop;
// 抽象类的所有方法都要有继承它的子类实现
public class P74_A extends P74_action{
    @Override
    public void doSomething() {

    }
}

3P75 接口的定义与实现

package com.oop;
// 一个类可以实现一个接口
// 实现了接口的类，就需要重写接口的方法
// 接口可以实现多继承，只有方法定义，没有方法具体实现
// 接口相当于一个约束
public class P75_UserServiceImpl implements P75_UserService,P75_TimeService{
    @Override
    public void run(String name) {

    }

    @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() {

    }
}
/*
接口的作用:
     1. 接口是一个约束，定义方法让不同人来实现
     2. 方法都是public abstract
     3. 属性都是public static final
     4. 接口不能被实例化，没有构造方法
     5. 可以实现多接口
     6. 实现接口必须重写接口的方法
 */

package com.oop;
// 接口都需要实现类
public interface P75_UserService {
    // 常量 public+static+final
    // 一般不用
    int age = 99;

    // 接口中的所有定义都是抽象的 默认public
    // public abstract void run();
    void run(String name);
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

package com.oop;

public interface P75_TimeService {
    void timer();
}

3P76 N种内部类

1. 成员内部类
2. 静态内部类
3. 局部内部类
4. 匿名内部类

package com.oop;

public class P76_Test {
    public static void main(String[] args) {
        Apple apple = new Apple();
        // 匿名内部类，没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        // 匿名内部类
        UserService userService = new UserService(){
            @Override
            public void hello() {

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

interface UserService{
    void hello();
}

package com.oop;

public class P76_Outer {

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

package com.oop;

public class P76_Outer {

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

4P77 Error和Exception

package com.exception;
// 检查性异常、运行时异常 和 错误
public class P77 {
    public static void main(String[] args) {
//        new P77().a();
//        System.out.println(11/0);
    }
//    public void a(){
//        b();
//    }
//    public void b(){
//        a();
//    }
}

4P78 捕获和抛出异常

package com.exception;

public class P78 {
    public static void main(String[] args) {
//        int a = 1;
//        int b = 0;
        new P78().test(1,0);
    }
//    public void a(){
//        b();
//    }
//    public void b(){
//        a();
//    }
    // 假设这方法中，处理不了这个异常。方法上可抛出异常
    public void test(int a, int b) throws ArithmeticException{
        if (b == 0){ //主动抛出异常
            throw new ArithmeticException(); //主动抛出异常，一般在方法中使用
        }

//        System.out.println(a/b);
    }
}

 假设要捕获多个异常：从小到大
 finally可以不写 IO资源需要关闭就需要finally
//        try { //try监控区域
//
            new P78().a();
//                }catch (Error e){ //处理异常(想要捕获的异常类型)
//                System.out.println("有异常，变量b不能为0");
//                }catch (Exception e){
//                System.out.println("Exception");
//                }catch (Throwable t){
//                System.out.println("Throwable");
//                }
//
//                finally { // 处理善后工作
//                System.out.println("finally");
//                }

package com.exception;

public class P78_1 {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        // Ctrl + alt + T
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            System.exit(1);
            e.printStackTrace(); //打印错误栈信息
        } finally {
        }
    }
}

4P79 自定义异常及经验小结

package com.exception;
// 自定义异常类
public class P79 extends Exception{
    // 传递数字>10
    private int detail;

    public P79(int a) {
        this.detail = a;
    }

    //toString 异常的打印信息

    @Override
    public String toString() {
        return "P79{" +
                "detail=" + detail +
                '}';
    }
}

package com.exception;

public class P79_1 {
    // 可能会存在异常的方法
    static void P79_1(int a) throws P79 {
        System.out.println("传递的参数为:"+a);
        if (a > 10){
            // 出现异常可以就地捕获或者向上捕获
            throw new P79(a);
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            P79_1(11);
        } catch (P79 e) {
            System.out.println("MyException"+e);
        }
    }
}

4P80 JavaSE总结