06 面向对象编程 （续）

Static关键字

静态代码块：只执行一次。

Person.java
package com.mysoft.oop.demo08;

public class Person {
    //2：赋初值
    {
        System.out.println("匿名代码块");
    }

    //1:只执行一次
    static {
        System.out.println("静态代码块");
    }

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

    public static void main(String[] args) {
        new Person();

        System.out.println("==============");
        new Person();

    }
}

出力结果：

静态代码块
匿名代码块
构造方法
==============
匿名代码块
构造方法

静态导入包：
import static java.lang.Math.random;

Test.java
package com.mysoft.oop.demo08;

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

package com.mysoft.oop.demo08;

//静态导入包
import static java.lang.Math.random;
public class Test {
    public static void main(String[] args) {
        //System.out.println(Math.random());
        System.out.println(random());
    }
}

一个类如果被final修饰了，这个类就不能再被继承了。

抽象类

abstract修饰的类，就是抽象类；修饰的方法就是抽象方法。

抽象类不是重点！ 接口才是重点

//多继承~ 利用接口实现多继承~
//实现了接口的类，都需要重写接口中的方法~

约束

Action.java
package com.mysoft.oop.demo09;

//abstract 抽象类:类  extends 单继承~   (接口可以多继承 )
public abstract class Action {


    //约束~有人帮我们实现
    //abstract，抽象方法，只有方法名字，没有方法的实现！
    public abstract void dosomething();

    //1.不能new这个抽象类，只能靠子类去实现它; 约束!
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    // 抽象的抽象：约束!
    public void hello() {
        System.out.println("hello");
    }

    //思考题？ new，存在构造器么？ (经过查看抽象类的class文件，抽象类也有构造方法）
    //存在的意义？ 抽象出来  提高开发效率，节省代码。

}

A.java
package com.mysoft.oop.demo09;

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法！除非~
public class A extends Action {
    @Override
    public void dosomething() {
        System.out.println("A=>dosomething");
    }
}

package com.mysoft.oop.demo09;

public class Application {
    public static void main(String[] args) {
        //new Action();  //error 抽象类不能被new
        A a = new A();
        a.dosomething();
        a.hello();
    }
}

接口

接口可以多继承

UserService.java
package com.mysoft.oop.demo10;

//抽象的思维 Java
//interface 定义的关键字，接口都需要有实现类
public interface UserService {

    //常量 public static final（一般都是定义方法，定义常量的少）
    int AGE = 99;

    //接口中所有的定义其实都是抽象的 public abstract
    //public abstract void add() ;
    void add();
    void delete();
    void update();
    void query();

}

TimeService.java
package com.mysoft.oop.demo10;

public interface TimeService {
    void timer();
}

package com.mysoft.oop.demo10;

//抽象类： extends~
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法~

//多继承~ 利用接口实现多继承~
public class UserServiceImpl implements UserService, TimeService {

    @Override
    public void add() {

    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }

    @Override
    public void timer() {

    }
}

接口的作用：

作用：
  1.约束
  2.定义一些方法，让不同的人实现~  10 --> 1
  3.public abstract
  4.public static final
  5.接口不能被实例化~，接口中没有构造方法~
  6.implements可以实现多个接口
  7.必须要重写接口中的方法

内部类

了解就行

1.成员内部类

package com.mysoft.oop.demo11.sub01;

public class 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.mysoft.oop.demo11.sub01;

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();

    }
}

2.静态内部类 内部类定义时 使用了static

package com.mysoft.oop.demo11.sub01;

public class Outer2 {

    private static int id = 10;

    public void out() {
        System.out.println("这是外部类的方法");
    }

    public static class Inner{
        public void in() {
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性~
        public void getID() {
            System.out.println(id);
        }
    }
}

3.局部内部类 在方法内部定义的类，属于局部

package com.mysoft.oop.demo11.sub04;

public class Outer {
    //局部内部类
    public void method() {

        class Inner() {
            public void in() {

            }
        }
    }
}

4.匿名内部类

package com.mysoft.oop.demo11.sub03;

import com.mysoft.oop.demo09.A;

public class Test {

    public static void main(String[] args) {
        Apple apple = new Apple();
        apple.eat();

        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

        UserService userService = new UserService() {
            @Override
            public void hello() {

            }
        };

    }
}

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

不是内部类，一个java文件里可以定义多个类，但只能有一个是public的

package com.mysoft.oop.demo11.sub02;

public class Outer {

}

//一个java文件中可以有多个class，但只能有一个是public的
class A {
    public static void main(String[] args) {

    }
}

经常用A这个类来写测试Outer类的测试类。

异常机制

什么是异常？ Exception
实际工作中遇到的情况不可能是非常完美的。
比如：你写的某个模块，用户输入不符合要求，你的程序要打开某个文件，这个文件不存在或者文件格式不对，
你要读取数据库的数据，数据可能为空等等。
跑程序时内存或硬盘满了，等等。

例如：StackOverflowError

Demo01.java
package com.exception.demo01;

public class Demo01 {
    public static void main(String[] args) {
        new Demo01().a();
    }

    public void a() {
        b();
    }

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

ArithmeticException异常

package com.exception.demo01;

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

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

异常体系结构：
超类：java.lang.Thowable 作为所有异常类的超类
异常分为两类：错误Error 和 异常Exception

Error和Exception的区别：

异常处理机制

• 抛出异常

• 捕获异常

• 异常处理的五个关键字：try，catch，finally，throw， throws

package com.exception.demo01;

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

        //假设要捕获多个异常：从小到大！
        try {//try监控区域
            //System.out.println(a / b);

            new Test().a();

        } catch (ArithmeticException e) {//catch(想要捕获的异常类型！) 捕获异常
            System.out.println("程序出现异常，变量b不能为零");
        } catch (Throwable t) {
            System.out.println("throwable");

        } finally {//处理善后工作
            System.out.println("finally");
        }

        //finally 可以不要finally  假设IO，资源，关闭！
    }

    public void a() {
        b();
    }

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

一个快捷键：
选中代码，然后 ctrl + alt + T

主动的抛出异常：
throw

Test2.java
package com.exception.demo01;

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

            if (b == 0) {//throw   throws
                throw new ArithmeticException();//主动的抛出异常
            }

            System.out.println(a / b);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
        }
    }
}

更完全一点儿的例子，方法里抛出异常，然后在调用方法的地方可以捕获，进行处理。

Test3.java
package com.exception.demo01;

public class Test3 {
    public static void main(String[] args) {
        try {
            new Test3().test(1, 0 );
        } catch (ArithmeticException e) {
            throw new RuntimeException(e);
        }


    }

    //假设这个方法中，处理不了这个异常。方法上抛出异常
    public void test(int a, int b) throws ArithmeticException {
        if (b == 0) {
            throw new ArithmeticException(); //主动的抛出异常，一般在方法中使用
        }
        System.out.println(a / b);
    }
}

自定义异常

使用java内置的异常类可以描述编程时出现的大部分异常情况。
还可以自定义异常类，只需要继承Exception类即可。

自定义异常，大体一下几个步骤：
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象。
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch捕获并处理；
否则要在方法的声明处通过关键字throws指明要抛出给方法的调用者。
4.在出现异常方法的调用者中捕获并处理异常。

MyException.java
package com.exception.demo02;

//自定义的异常类
public class MyException extends Exception {

    //传递数字 > 10
    private int detail;

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

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

Test.java
package com.exception.demo02;

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

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            //throw new RuntimeException(e);
            //e.printStackTrace();
            System.out.println("MyException=>"+e );
        }

    }
}

输出结果为：
传递的参数为：11
MyException=>MyException{detail=11}

自定义异常，用的并没有那么多。
只需要了解一下就行，出现的时候能看懂就可以。

代码里有红色的波浪线，可以按住 Alt + Enter键，自动给你提示一些该怎么处理。
非常好用的万能键。