JAVA面向对象04---static关键字，抽象类，接口，内部类，异常

JAVA面向对象04

static关键字解析

//static:
public class Student {

    private static int age;//静态变量 多线程
    private double score;//非静态变量

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {
        new Student().run();
        Student.go();
        go();
        //加了static可以不创建对象使用类名.属性名或者方法名 直接调用，
        //只是在本类里可以省去类名，不是说在别的类里用不了
        //static所修饰的方法或属性是专属于这个类的，而不是属于由这个类所派生出来的对象
        //这里只要明白类加载的机制就懂为啥了，被static修饰的方法或变量都是随着类加载的时候就加载了，所以可以不用new对象直接用
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.score);
        System.out.println(s1.age);
    }

}

public class Person {

    //2 赋予初始值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }

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

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

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


}

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

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

}

---

抽象类

• abstract修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那么方法就是抽象方法，如果修饰类，那么该类就是抽象类
• 抽象类中可以没有抽象方法，但是由抽象方法的类一定要声明为抽象类
• 抽象类不能使用new关键字来创建对象，它是用来让子类继承的
• 抽象方法只有方法的声明，没有方法的实现，它是用来让子类实现的
• 子类继承抽象类，那么久必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

//abstract 抽象类 类 extends：单继承， 接口可以多继承（自身是个插座
public abstract class Action {

    //约束，有人帮我们实现
    //abstract，抽象方法，只有方法名字。没有方法的实现
    public abstract void doSomething();
    //作为父类来规范子类必需的实现，例如将狗吃东西抽象为父类方法，因为不同种类的狗在吃的方面有所不同，
    //所以父类没有办法完成具体实现，就用抽象方法来约束子类去实现自己的方法，抽象方法只能写在抽象类里

    //不能new 抽象类 ，只能靠子类去实现它，约束
    //抽象类中可以写普通方法
    //抽象方法一定要写在抽象类
    //抽象的抽象：约束
    //抽象类就是来实现封装，多态的增强代码的可扩展性
    //抽象类是为了不让你去直接new它的实例，比如animal类，犬科动物类，是没有具体实物的
}

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

接口

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有（不能new，靠子类实现
• 接口：只有规范，自己无法写方法，专业的约束，约束和实现分离，面向接口编程
• 接口就是规范，定义的是一组数据，体现了现实世界中“如果你是...则必须是...”的思想，如果你是汽车，则必须能跑
• 接口的本质是契约，像法律一样，制定好后大家都遵守
• oo的精髓，是对对象的抽象，最能体现这点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++，java，c#等）就是因为设计模式所研究的，实际上就是如何合理的去抽象

作用

• 约束
• 定义一些方法，让不同的人实现
• 默认方法public abstract
• 默认常量属性public static final
• 接口不能被实例化，接口中没有构造方法
• 可以通过implements实现多个接口
• 必须要重写接口中的方法

//interface 定义接口的关键字，接口都需要有实现类
public interface UseService {
    //接口种的所有定义其实都是抽象的，public abstract,所以可以省略

    //在接口定义的属性都是常量
    int AGE = 99;//前缀是默认public static final，但一般不会在接口定义常量

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void time();
}

//抽象类：通过extends，但只能单继承
//类可以实现接口 implements 接口，多继承
//事先了接口的类，就需要重写接口中的方法
public class UseServiceImpl implements UseService,TimeService{//利用接口来实现多继承
    @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 time() {

    }
}

---

内部类

• 内部类就是在一个类的内部再定义一个类，比如A类中定义一个B类，B类就是A类的内部类，A则是B的外部类
• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

public class Outer {

    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public void method(){
        //局部内部类
        class Inneer{
            public void in(){
            }
        }
    }

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

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

    }
//一个java类中可以有多个class类，但是只能有一个public class

}

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();

        UserService userService = new UserService() {

            @Override
            public void Hello() {

            }
        };


    }
}

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

interface UserService{
    void Hello();
}

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();

        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

异常

Error和Exception

• 软件程序在运行过程中，会遇到异常（Exception）比如文件找不到，网络连接失败，非法参数等等，异常发生在程序运行期间，它影响了正常的程序执行流程

• java自带有异常处理框架

  三种类型的异常

  • 检查性异常：最具代表性的异常，由用户错误和问题引起的异常，是程序员无法预见的，比如打开一个不存在的文件就出现异常，这些异常在编译时不能被简单地忽略
  • 运行时异常：运行时异常是可能被程序员避免的异常，这些异常可以在编译时被忽略
  • 错误ERROR：错误不是异常，是脱离程序员控制地问题，错误在代码中通常被忽略，例如，当栈溢出时，一个错误就发生了，在编译也检查不到

• 异常体系结构

  • 

ERROR

• Error类对象由Java虚拟机生成抛出，大多数错误与代码编写者所执行的操作无关
• Java虚拟机运行错误（Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError，这些异常发生时，Java虚拟机JVM一般会选择线程终止
• 还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError)，链接错误（LinkageError）这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况

Exception

---

捕获和抛出异常

异常处理机制

• 抛出异常
• 捕获异常
• 异常处理五个关键字
  • try,catch,finally,throw,throws

public static void main(String[] args) {

    int a = 1;
    int b = 0;

    //假设要捕获多个异常：从小到大来
    try {//try监控区域
        System.out.println(a/b);
    }catch(Error e){//捕获异常
        System.out.println("Error");
    }catch (Exception e){
        System.out.println("Exception");
    }catch (Throwable t){
        System.out.println("Throwable");
    } finally {//处理善后工作，无论出不出异常都会执行finally
        System.out.println("finally");
    }

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

}

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

    }

    //假设这个方法中，处理不掉这个异常，方法上抛出异常
    public void test(int a,int b) throws ArithmeticException{//throws可以同时声明多个异常类，但需用逗号隔开
        if(b==0){//主动抛出异常throw 和 throws不一样
            throw new ArithmeticException();//主动抛出的异常,一般在方法中使用
        }
    }
    //throws用于方法头部，声明该方法会抛出du什么类型的异常；
    //throw用于方法体中，只抛出某种类型的异常。
    //作用不同：throw用于在程序中抛出异常，throws用于声明在该方法内抛出了异常。
    //使用位置不同：throw位于方法体内部，可以作为单独语句是用，throws必须跟在方法参数列表后面，不能单独使用。
    //内容不同：throw抛出一个异常对象，而且只能是一个，throws后面跟异常类，可以有多个。
        /*public static void main(String[] args) {
        int a = 1;
        int b = 0;

        //选中代码 ctrl+alt+t快捷创建捕获异常
        try {
            System.out.println(a/b);
        } catch (Exception e) {
            e.printStackTrace();//打印出错误的栈信息
        } finally {
        }
    }/*
}

自定义异常

• 使用Java内置的异常类可以描述在编程时出现的大部分异常情况，除此之外，用户还可以自定义异常，用户自定义异常类，只需要继承Exception类即可
• 在程序种使用自定义异常类，大体可分为以下几个步骤
  • 创建自定义异常类
  • 在方法中通过throw关键字抛出异常对象
  • 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
  • 在出现异常方法的调用者中捕获并处理异常

实际应用中的经验总结

• 处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
• 在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
• 对于不确定的代码，也可以加一个try-catch来处理潜在的异常
• 尽量去处理异常，切忌只是简单地调用printStackTrace()去打印输出
• 具体如何处理异常，要根据不同的业务需求和异常类型去决定
• 尽量添加finally语句块去释放占用的资源

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

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

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

    //toString

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

public class Test3 {
    //可能会存在异常的方法

    static void test3(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 {
            test3(12);
        } catch (MyException e) {
            //这里也可以增加处理异常的代码块
            System.out.println("MyException==>"+e);//这里的e会调用toString方法
        }
    }
}