Day04

面向对象

static

  • 匿名代码块：用于每次创建对象时初始化数据。

  • 静态代码块：类加载时就执行，且只执行一次。

 

 

  • 静态变量（类变量）：可以用类名来调用

  • 非静态变量

 

 

  • 非静态方法可以直接访问静态方法

 

抽象类

  • java的类是单继承，接口可以多继承。

  • 存在的意义：提高开发效率。

  1. 不能new这个抽象类，只能靠子类去实现它。

  2. 抽象类中可以写普通的方法。

  3. 抽象方法必须在抽象类中。

抽象类

public abstract class Action{}

抽象类

public abstract class A extends Action{}

抽象类的子类一定要实现抽象类的方法，除非这个子类也是抽象类。

抽象方法

只有方法名字，没有方法的实现。

public abstract void doSomething();

 

接口

  • 普通类：只有具体实现。

  • 抽象类：具体实现和规范（抽象方法）都有。

  • 接口（伪多继承）：只有规范，自己无法写方法(只能抽象方法)。专业的约束。约束和实现分离：面向接口编程。不能被实例化。接口中没有构造方法。定义一些方法，让不同的人实现。

接口的本质是契约。

声明类的关键字是class，声明接口的关键字是interface

public interface UserService{
    void add();//接口里面只能有抽象的方法
               //接口里面所有定义的方法其实都是抽象的 
               //              public abstract
               
}
public interface UserService{
    int age=99;//接口里面都是常量（不常用）
               // public static final
               
}

 

类可以实现接口（可以同时实现几个接口，用逗号分隔） implements 接口1(,接口2)

  • 实现了接口的类，需要重写接口中的方法。

public class UserServiceImpl implements UserService{}
//里面一定要重写方法
public class UserServiceImpl implements UserService,TimeService{}

 

内部类

  • 内部类就是在一个类的内部再定义一个类，例如，在A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是外部类。

  • 一个java中可以有多个class类，但是只能有一个public class类（这里指的是两个类是分开的，一个类不会在另一个类的内部）

成员内部类

 

 

作用

  1. 获得外部类的私有属性，私有方法

局部内部类

 

 

匿名内部类

没有名字的类

 

 

  1. 选中的部分是实现接口UserService的类，它是没有名字的。

  2. 调用Apple类中的方法时，初始化类的时候也是没有名字的。

 

错误和异常

  • 程序运行中出现的不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。

  • 异常发生在程序运行期间，它影响了正常的程序执行流程。

分类

  1. 检查性异常：如用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。

  2. 运行时异常：运行时异常是可能被程序员避免的异常。运行时异常可以在编译时被忽略（在编译时不会被发现，程序运行时才会被发现）。

  • 错误error：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，栈溢出时，一个错误就发生了，它们在编译时也检查不到。可以去避免。

异常处理框架

 

 

Error

 

 

Exception

  • 可分为运行时异常和非运行时异常（检查性异常）。

  • 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生。

区别

  • Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现时，Java虚拟机（JVM）一般会选择终止线程

  • Exception通常情况下是可以被程序处理的，程序中应该尽可能去处理这些异常。

异常处理机制

int a=1;
int b=0;
​
try{//监控区域
    System.out.println(a/b);
}catch(ArithmeticException e){//如果捕获这个异常（有这个异常），则执行语句。//catch（想要捕获的异常（包括Error和Exception））
    System.out.println("程序出现异常，变量b不能为0");
}finally{//无论异常出现与否，语句都会执行，用来处理善后工作
    System.out.println("finally");
}

  • try和catch一定要有，finally可以不要。finally用来关闭一些资源（IO流）。

try{
    System.out.println(a/b);
}catch(ArithmeticException e){
    System.out.println("ArithmeticException");
}catch(Exception t){
    System.out.println("Exception");
}catch(Throwable t){
    System.out.println("Throwable");
}
finally{
    System.out.println("finally");
}

  • 假设要捕获多个异常，从小到大。只会执行一条catch语句。

快捷键：选中需要的监控区域，ctrl+alt+t，快速生成try catch finally语句。

主动抛出异常

public class Test{
    public static void main(String[] args){
        
        new Test().test(1,0);//匿名内部类
        
public void test(int a,int b){
    if(b==0){
        throw new ArithmeticException();//主动抛出异常，一般在方法中使用
    }
    System.out.println(a/b);
}
}
}
//假设这方法中，处理不了这个异常，直接把这个异常往外抛出去。在方法上抛出异常
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{
    if(b==0){
        throw new ArithmeticException();//主动抛出异常，一般在方法中使用
    }
    System.out.println(a/b);
}
}
}
 

自定义异常

一般情况下我们自定义异常是继承 RuntimeException（运行时异常），好处是可以使用默认的处理机制。不用throws再丢出异常,比较方便。

步骤

  1. 定义类，自定义异常类名，继承Exception或RuntimeException。

  2. 继承前者属于编译异常。

  3. 继承后者属于运行异常（一般来说，继承RuntimeException）。

package hspstudy.customexception;
​
public class CustomException {
    public static void main(String[] args) /*throws AgeException*/ {
​
        int age=180;
        //要求年龄在18-120之间，否则抛出一个自定义异常。
        if(!(age>=18&&age<=120)){
            //通过构造器设置信息
            throw new AgeException("年龄有误，请重新输入");
        }
        System.out.println("年龄范围正确");
    }
}
class AgeException extends RuntimeException{
    public AgeException(String message) {
        super(message);
    }
}