接口、内部类、异常机制

最新推荐文章于 2022-01-20 17:08:03 发布
最新推荐文章于 2022-01-20 17:08:03 发布
阅读量562 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43647393/article/details/98233442
版权

接口、内部类、异常机制

1. 接口

1.1 地位

接口的地位

1.2 作用

让不同实现了接口的类的对象可以提供相同的功能，比如：
接口的作用

1.3 实现方式

  1. 创建一个接口
//Flyable接口
public interface Flyable {
    //提供fly方法
    //public与abstract修饰符默认提供，可以不写
    //不能提供方法体
    public abstract void fly();
}
  1. 让需要的类实现接口（通过implement关键字来实现）
//鸟类
class Birds implements Flyable {
    //实现fly方法
    public void fly(){
        System.out.println("鸟儿在天空飞翔");
    }
}
//超人类
class Supermans implements Flyable{
    //实现fly方法
    public void fly(){
        System.out.println("超人在天空飞行");
    }
}
  1. 调用即可
public class Test{
    public static void main(String[] args) {
        (new Birds()).fly();//输出结果：鸟儿在天空飞翔
        (new Supermans()).fly();//输出结果：超人在天空飞行
    }
}

1.4 接口的组成部分

JDK版本全局静态常量全局抽象方法全局静态方法全局默认方法
JDK1.8之前yesyesnono
JDK1.8yesyesyesyes

1.4.1 全局静态常量

接口中的变量默认修饰符为public static final，无法修改，但可以不写

//显式
public static final int AGE=18;
//隐式
int AGE=18;

1.4.2 全局抽象方法

在JDK1.8之前，接口中方法的修饰符默认是public abstract，无法修改，但可以不写

//显式
public abstract void test();
//隐式
void test();

1.4.3 全局静态方法及全局默认方法

在JDK1.8，为了方便修改接口，减少实现接口的类的实现方法代码量，提供了全局静态方法与全局默认方法

1.4.3.1 全局静态方法

实现类调用全局静态方法只能通过接口名调用

public Interface Test1{
	//全局静态方法
	public static void test(){
        	System.out.println("实现类调用test方法只能通过接口名调用");
    }
}

public class Test2 implements Test1{
	//实现类调用接口中的全局静态方法
    Test1.test();
}
1.4.3.2 全局默认方法
public Interface Test1{
	//全局默认方法
	public default void test(){
		System.out.println("test方法可以实现类被重写，也可以不被重写")
}

全局默认方法可以被实现类重写，也可以不重写。如果重写必须去掉default关键字，如果不重写，调用只能用接口名.super调用

public class Test2 implements Test1{
	//重写
	public void test(){
		System.out.println("重写接口的全局默认方法");
	}

	//不重写，调用
	Test1.super.test();
}

1.5 特征

  1. 接口没有构造方法，不能使用new关键字创建对象
  2. 实现类可以实现多个接口
  3. 实现类如果需要继承，那么继承必须写在实现接口之前
public class Child extends Father implements Test1, Test2...{
}
  1. 实现类也可以向上转型为接口，所以接口可以作为形参，而实参可以是该接口的任意实现类
//创建一个测试接口
public interface Test1{};

//创建一个测试类
public class Test2 implements Test1{
	//实现类向上转型为接口对象
	Test1 t1=new Test2();
	//接口作为形参
	public void test(Test1 t2){
	}
	public void test2(){
		test(new Test2());//实参可以是该接口的实现类
	}
}

2. 内部类

2.1 作用

  1. 实现多重继承
  2. 提高隐藏性
  3. 避免修改接口而实现同一类中两种同名方法调用

2.2 类型

局部内部类成员内部类静态内部类匿名内部类

2.3 实现方式

2.3.1 局部内部类

不能有访问修饰符

public class OuterClass {
	//定义一个构造代码块
    {
        //在代码块定义一个局部内部类
        class InnerClass1{
            
        }
    }
    
    //定义一个成员方法
    public void test(){
        //在方法中定义一个局部内部类
        class InnerClass2{
            
        }
    }
}

2.3.2 成员内部类

public class OuterClass {
    //定义一个成员内部类
    class InnerClass{
        
    }
}

2.3.3 静态内部类

public class OuterClass {
    //定义一个静态内部类
    static class InnerClass{
        
    }
}

2.3.4 匿名内部类

可通过接口和继承（必须重写或实现其至少一种方法）两种方式创建

public class OuterClass extends Father implements Test {
    //通过接口定义匿名内部类及其对象
    Test t=new Test() {
        int a=16;
    };
    
    //实现父类的抽象方法
    public void test(){
        
    }
    
    //通过创建匿名内部类及其对象
    Father f=new Father() {
        @Override
        public void test() {
            
        }
    };
}

//创建一个接口
interface Test{

}

//创建一个父类
abstract class Father{
    public abstract void test();
}

2.4 特征

  1. 内部类可以直接调用外部类的成员（静态内部类调用外部类的非静态成员需使用类名或外部类对象名调用）
  2. 内部类的权限修饰符可以是（按权限等级）：private—>default—>protected—>public
  3. 外部类访问内部类需要先创建内部类的对象（局部内部类只能在局部内部类所在的方法或代码块内部访问）
  4. 局部内部类不能使用任何访问修饰符

2.5 创建内部类对象的方式

2.5.1 创建局部内部类的对象

只能在局部内部类所在的方法或代码块内部创建

public class OuterClass{
    //构造代码块
    {
        //通过代码块创建局部内部类
        class InnerClass1{
            public void test1(){
                
            }
        }
        //创建局部内部类的对象
        InnerClass1 t1=new InnerClass1();
        //调用局部内部类的方法
        t1.test1();
    }
    
    //成员方法
    public void test2(){

        //通过成员方法创建局部内部类
        class InnerClass2{
            public void test3(){
                
            }
        }
        //创建局部内部类的对象
        InnerClass2 t2=new InnerClass2();
        //调用局部内部类的方法
        t2.test3();
    }
}

2.5.2 创建成员内部类的对象

public class OuterClass {
    //定义成员内部类
    class InnerClass{

    }
    
    //创建成员内部类对象
    OuterClass.InnerClass obj=new OuterClass().new InnerClass();
}

2.5.3 创建静态内部类的对象

public class OuterClass {
    //定义静态内部类
    static class InnerClass{

    }

    //创建成员内部类对象
    OuterClass.InnerClass obj=new OuterClass.InnerClass();
}

2.5.4 创建匿名内部类的对象

见2.3.4示例代码

3. 垃圾回收机制

3.1 优缺点

  1. 优点：提高安全性、提高效率
  2. 缺点：更多的性能开销

3.2 特征

  1. 只回收JVM堆区的对象空间
  2. 回收时间不可预知
  3. 回收前系统会主动调用finalize方法（如果覆盖该方法，让一个新的引用变量重新引用该对象，则会重新激活对象）
  4. 可将对象的引用变量设置为null，以此暗示垃圾回收机制回收该对象
  5. 可以通过System.gc()或Runtime.getRuntime().gc()来通知系统进行垃圾回收，但何时回收不确定

3.3 实现代码

public class Test {
    public static void main(String[] args) {
        //创建没有引用变量的对象
        new Test();
        new Test();
        new Test();
        new Test();

        //设置对象的引用变量为null，暗示垃圾回收机制
        Test t=new Test();
        t=null;

        //提醒回收
        System.gc();
        Runtime.getRuntime().gc();
    }

    //重写finalize方法
    //如果垃圾回收成功，打印语句
    @Override
    protected void finalize() throws Throwable {
        System.out.println("垃圾回收成功");
    }
}

4. 异常机制

4.1 作用

发生异常后，给出异常类型、异常提示信息及异常位置

4.2 异常的类型

4.2.1 Exception类

Exception类是所有异常类的父类

4.2.2 RuntimeException类

RuntimeException类是Exception类的子类，可以不作处理，系统会自动检测并处理

4.2.3 CheckedException类

必须处理CheckedException类异常，否则编译错误

4.3 捕获异常方式

4.3.1 try{}

将可能出现异常的语句放入try的代码块中

/**
 * 功能：输入班级总分及人数，计算平均分
 */
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try{
            //获取班级总分
            System.out.print("请输入班级总分：");
            int sum=sc.nextInt();
            //获取班级总人数
            System.out.print("请输入班级人数：");
            int number=sc.nextInt();
            //计算平均分并输出结果
            System.out.println("班级平均分为："+sum/number);
        }
    }
}

4.3.2 catch{}

4.3.2.1 单层catch{}

将异常处理语句放入catch的代码块中，catch处理异常信息有三种：

  1. 自定义输出异常信息
/**
 * 功能：输入班级总分及人数，计算平均分
 */
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try{
            //获取班级总分
            System.out.print("请输入班级总分：");
            int sum=sc.nextInt();
            //获取班级总人数
            System.out.print("请输入班级人数：");
            int number=sc.nextInt();
            //计算平均分并输出结果
            System.out.println("班级平均分为："+sum/number);
        }catch (Exception e){
            //自定义输出异常信息
            System.out.println("欧，我死了");
        }
    }
}
  1. 调用异常对象的方法输出异常
/**
 * 功能：输入班级总分及人数，计算平均分
 */
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try{
            //获取班级总分
            System.out.print("请输入班级总分：");
            int sum=sc.nextInt();
            //获取班级总人数
            System.out.print("请输入班级人数：");
            int number=sc.nextInt();
            //计算平均分并输出结果
            System.out.println("班级平均分为："+sum/number);
        }catch (Exception e){
            //调用异常对象e的方法输出异常信息
            e.printStackTrace();//输出异常的堆栈信息
            System.out.println(e.getMessage());//输出异常信息描述
            System.out.println(e.toString());//输出异常信息类名及异常原因
        }
    }
}
  1. 通过throw关键字向上抛出异常信息
/**
 * 功能：输入班级总分及人数，计算平均分
 */
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try{
            //获取班级总分
            System.out.print("请输入班级总分：");
            int sum=sc.nextInt();
            //获取班级总人数
            System.out.print("请输入班级人数：");
            int number=sc.nextInt();
            //计算平均分并输出结果
            System.out.println("班级平均分为："+sum/number);
        }catch (Exception e){
            //通过throw关键字向上抛出异常信息
            throw e;
        }
    }
}
4.3.2.2 多重catch{}
public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try{
            //获取班级总分
            System.out.print("请输入班级总分：");
            int sum=sc.nextInt();
            //获取班级总人数
            System.out.print("请输入班级人数：");
            int number=sc.nextInt();
            //计算平均分并输出结果
            System.out.println("班级平均分为："+sum/number);
        }catch (ArithmeticException e){ //如果是算数异常
            e.printStackTrace();//先输出异常的堆栈信息
        }catch (InputMismatchException e){//如果是输入不匹配异常
            e.printStackTrace();//先输出异常的堆栈信息
            throw e;//再向上抛出异常信息
        }
        catch (Exception e){//如果是除算术异常的其他异常
            //通过throw关键字向上抛出异常信息
            throw e;
        }
    }
}

在多重catch中，父类异常必须排在子类异常的后面，因为如果是父类异常在前，那么后面的子类异常根本无法执行

4.3.2.3 catch代码块执行顺序
  1. try中代码无异常，catch代码块不执行
  2. try中代码异常，且与catch中异常类型匹配（相同或父类），try中出现异常的代码的后面的代码将不再执行，执行catch对应的异常语句及catch代码块之后的语句（但catch中执行了throw关键字或return语句，那么catch代码块之后的语句也将不再执行）
  3. try中代码异常，但与catch中异常类型不匹配，程序直接中断，不再向后执行。

4.3.3 finally{}

无论有没有异常，无论catch语句中有没有执行throw或return，程序最后都会执行finally代码的内容

public class Test {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        try{
            //获取班级总分
            System.out.print("请输入班级总分：");
            int sum=sc.nextInt();
            //获取班级总人数
            System.out.print("请输入班级人数：");
            int number=sc.nextInt();
            //计算平均分并输出结果
            System.out.println("班级平均分为："+sum/number);
        }catch (ArithmeticException e){ //如果是算数异常
            e.printStackTrace();//先输出异常的堆栈信息
            return;//再结束程序
        }catch (Exception e){//如果是除算术异常的其他异常
            //通过throw关键字向上抛出异常信息
            throw e;
        }finally {
            System.out.println("无论如何都要输出");
        }
        System.out.println("catch内不执行throw及return将执行本语句");
    }
}

4.4 throw与throws的区别

差异throwthrows
使用位置方法体中方法声明中
后面内容差异后面最多接一个对象后面最少接一个类
作用向上抛出异常信息声明该方法中有异常被throw，告诉调用者必须处理

如果在try中throw，该方法必须throws才能通过编译

4.5 自定义异常

自定义异常用于更准确、个性、交互的异常信息传递

5.4.1 实现方式

  1. 新建一个继承Exception类的子类
  2. 至少提供无参构造方法及String参数的有参构造方法
public class InputNagativeException extends Exception {
    //无参构造方法
    public InputNagativeException(){
        
    }
    //String参数构造方法
    public InputNagativeException(String massage){
        System.out.println(massage);
    }
}

public class Test {
    public static void main(String[] args) throws InputNagativeException {

        try{
            //获取班级总分
            Scanner sc=new Scanner(System.in);
            System.out.print("请输入班级总分：");
            int sum=sc.nextInt();
            
            //总分不能为负
            if(sum<0){
                throw new InputNagativeException("总分不能为负");
            }
            
            //获取班级总人数
            System.out.print("请输入班级人数：");
            int number=sc.nextInt();
            
            //班级人数不能为负
            if(number<0){
                throw new InputNagativeException("人数不能为负");
            }
            
            //计算平均分并输出结果
            System.out.println("班级平均分为："+sum/number);
        }catch(ArithmeticException e){ //如果是算数异常
            e.printStackTrace();//输出异常的堆栈信息
        }catch(InputMismatchException e){//如果是输入异常
            e.printStackTrace();//输出异常的堆栈信息
        }catch(Exception e){//如果是除算术异常的其他异常
            throw e;//向上抛出异常信息
        }
    }
}
赵大土
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
接口异常状态统一处理方案：优先业务端处理，再按需统一处理。
weixin_33695450的博客
09-14 4722
原文地址：monine.github.io/#/article/2… 最近工作贼忙，这篇文章按说应该两个月之前就产出，可是每天的精力基本都用在工作上，一写文章就犯迷糊，断断续续的每次要重新屡逻辑，以后再也不这样了。这篇文章是我司后台项目中遇到的一个基础需求，自己设计了一个实现方案，感觉还不错。 需求 后端接口响应，根据与后端约定的状态码（非 http 状态码）判定接口是否异常，我司的约定...
抽象类、接口、内部类、异常
05-17
课后作业中的问题涉及到抽象类、接口、内部类的特点和区别，异常处理机制以及关键字`this`、`super`、`final`的用法，包机制，访问权限修饰符，接口实现与类继承的区别等Java基础知识。实践题要求设计实现接口、ATM...
记录学习每一天-day17
chxlloli的博客
10-20 109
1，异常机制 异常是Java中提供的一种识别及响应错误情况的一致性机制。有效地异常处理能使程序更加健壮、易于调试。 异常发生的原因有很多，比如： 用户输入了非法数据 要打开的文件不存在 网络通信时连接中断 JVM内存溢出 这些异常有的是因为用户错误引起，有的是程序错误引起的，还有其它一些是因为物理错误引起的 2，常见异常 空指针 下标越界 栈内存溢出 类型转换异常 java中的继承关系 Error: 系统内部错误，这类错误由系统进行处理，程序本...
抽象类，接口，异常机制
矛盾完善着的博客
01-20 341
Abstract abstact ,抽象方法，只有方法名字，没有方法的实现！ 不能new抽象类，只能靠子类去实现它。这是一个约束~！ 定义方法 public abstract class 类名() package OOP; import OOP.demo08.A; import javax.swing.*; import javax.swing.text.Style; public class Application { public static void main(String[] args
异常处理
HEAT
05-19 97
异常处理     异常：编译时无法发现，执行时会出错，出错的状况就是  异常          error  表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况     exception  表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况   为什么？        用if ...
Day 4 2021.3.4方法回顾-对象-接口-异常机制
hc1235的博客
03-04 144
Day 4：2021.3.4 方法回顾 方法的定义 package com.hong.Day004; //Demo01 类 public class Demo01 { //main 方法 public static void main(String[] args) { } public static String sayHello(){ return "hello,world"; } public static int max(int a ,
Jersey框架的统一异常处理机制分析
09-01
1. 创建自定义的ExceptionMapper类：实现ExceptionMapper接口，为特定的异常类型提供处理逻辑。例如，我们可以创建一个处理所有 RuntimeException 的 mapper 类： ```java import javax.ws.rs.ext.ExceptionMapper;...
实验4接口和内部类.pdf
最新发布
07-29
实验四主要涵盖了Java编程中的接口、内部类以及异常处理等概念。下面将分别对这些知识点进行详细解释。 首先，接口（Interface）在Java中是一种定义行为的规范，它包含抽象方法和常量。在本实验中，接口Animal定义...
Spring MVC异常处理机制示例详解
08-25
HandlerExceptionResolver 接口是 Spring MVC 异常处理机制的核心接口，该接口只有一个处理方法，即 resolveException 方法，该方法将请求、响应、处理器和异常作为参数，并返回一个 ModelAndView 对象。对于返回值 ...
php错误、异常处理机制(补充)
12-19
如果在`catch`块内部又抛出了新的异常，那么当前的`catch`块将不再执行，新的异常会被传递到上一级的`catch`块，或者终止脚本。 总之，PHP的异常处理机制提供了一种强大的工具来管理程序的错误情况，使代码更加健壮...
swift抛出异常_swift之异常处理
weixin_34378815的博客
12-24 342
官网地址：https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/ErrorHandling.html#//apple_ref/doc/uid/TP40014097-CH42-ID5081、定义枚举异常值我们可以定义自己的异常枚举值，要遵循Error协...
关于接口，内部类，异常的一些介绍
kmlitheima的博客
05-28 674
/* 关于接口，内部类，异常的介绍 */ 接口： 什么是接口？这是我们必须要了解的一个概念。 接口就是各种抽象方法的集合体，使用interface来表明是一个接口。那么接口中常常包含哪些内容呢？变量，方法？既然是单独的名字内容，当然有它的特殊性。 接口中主要定义的是公开的常量，和公开的抽象方法。继承可以直接使用父类方法，而接口中虽然有方法，但是它不可以直接使用，因为那些方法是抽象的
php接口异常,API接口中的异常处理
weixin_36248959的博客
03-10 741
# API接口中的异常处理>[success]在API接口的开发过程中，使用TP自带的异常处理机制，可能并不能满足实际需求。>TP默认是直接抛出异常，而API接口通常返回的是json数据格式。所以需要对异常类进行重写。## 重写异常处理的`render`方法### 重写异常处理类~~~phpnamespace app\common\lib\exception;use think\ex...
匿名内部类与equals之学习要扎实
weixin_30337157的博客
07-13 115
匿名内部类是胡哥给我上的第一节课，他一直在不断强调着“逻辑与思维”的重要性， 遇到问题不能用“不知道和没学过”去逃避它，所有的不知道和没教过都源自于没见过,一定要学会去看源代码，不要人云亦云......胡哥讲了那么多，我就记得这么几句话了，今天他催我交博客，我满脑子都是这么几句话.....不过他的这些话还是很有作用的，至少我现在这个小菜鸟不再那么惧怕那些想不出来的编程思想了，因为可以百...
接口&内部类&异常&Lambda
Yearsuree的博客
03-29 467
接口 接口 一般说class类之间的调用方式是 extends 继承，而class调用interface 接口 implements 关键字实现 接口是一种特殊的抽象类，是功能的集合(一般指抽象方法)。 优点: 1.接口可以多实现,类只能单继承 2.提高代码的复用性 3.解耦 4.定义开发规范 定义: jdk1.7及之前版本: 1、静态常量: public static final 数据类型 =...
接口和异常
Super_Robot的博客
04-13 407
异常 变量名.hasNextInt(); 判断输入是否为整数。 System.exit(1); // 非0异常关闭 0正常关闭 结束JVM虚拟机。 System.err.println() // 红色输出，用于报错 异常处理机制 异常是指程序运行中发生不正常的事件，JVM会中断正在运行的程序。 Java异常处理的5个关键字：try，catch，finally，throw，throws 捕获异常...
Go 异常处理
weixin_40426261的博客
11-02 314
Error vs Exception Error Type Handling Error Go 1.13 errors Go 2 Error Inspection Error vs Exception Go 的处理异常逻辑是不引入 exception，支持多参数返回，所以你很容易的在函数签名中带上实现了 error interface 的对象，交由调用者来判定。 如果一个函数返回了 value, error，你不能对这个 value 做任何假设，必须先判定 error。唯一可以忽略 error 的是，如果你
go的异常处理机制
weixin_34238633的博客
07-16 138
在java或php等很多面向对象的语言中, 异常处理是依靠throw、catch来进行的。在go语言中，panic和recover函数在作用层面分别对等throw和catch语句，当然也存在不同之处。 从设计层面来看，panic和recover函数适用于那些真正的异常（例如整数除0），而throw catch finally机制常常被用来...
对于业务逻辑中发生的异常应该怎样显示到Web层？
zjumty
09-27 374
刚进公司，参加了两个项目一个是日本外包，一个是自己的产品。这个两个系统在设计上都有一个要求，就是业务逻辑要放到Service层来完成，Action中尽量少写东西。这一点可以理解，但是存在这样一个问题，在service中进行业务逻辑处理时免不了要发生问题，要把这些问题显示在页面上，但是service层不能直接接触到action，所以着这两个项目中的设计方法上使吧actionmessages对象给了s...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值