Java接口与异常

已于 2024-02-03 22:18:48 修改
阅读量54 收藏
点赞数
分类专栏： java 文章标签： java 开发语言
于 2023-11-14 14:00:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79866936/article/details/134381181
版权

 01接口

1.接口（JDK1.8前）

类和接口：

1.类是类，接口是接口,它们是同一层次的概念。

2.接口中没有构造器

3.接口如何声明: interface

4.在JDK1.8之前，接口中只有两部分内容:

(1）常量:固定修饰符: public static final

(2）抽象方法:固定修饰符: public abstract

5.类和接口的关系是什么？ 实现关系 类实现接口

6.一旦实现一个接口，那么实现类要重写接口中的全部的抽象方法

7.如果没有全部重写抽象方法，那么这个类可以变成一个抽象类

8.Java只有单继承，Java还有多实现

一个类继承其他类，只能直接继承一个父类

但是实现类实现接口的话，可以实现多个接口

9.写法：先继承 再实现

interface TestInterface02{
    void e();
    void f();
}
public interface TestInterface01 {
    //常量
    public static final  int NUM = 10;
    //public static final在idea是灰色的，因为系统会默认加上这个修饰词

    //抽象方法
    public abstract void a();
    //public abstract 也可以省略
    /*public abstract*/void b(int num);
    /*public abstract*/int c(String name);
    //注意：修饰符可以省略不写，但idea会自动帮你补全
}
//继承与实现的顺序不能颠倒 extends 类 implements 接口1,接口2...
class Student extends Test implements TestInterface01,TestInterface02{

    @Override
    public void a() {
        System.out.println("a方法");
    }

    @Override
    public void b(int num) {
        System.out.println("b方法");
    }

    @Override
    public int c(String name) {
        return 0;
    }

    @Override
    public void e() {
        System.out.println("e方法");
    }

    @Override
    public void f() {
        System.out.println("f方法");
    }
}
abstract class Student1 implements TestInterface01{
    @Override
    public void a() {
        //这个类里面可以一个方法都不重写 因为它是个抽象类
        System.out.println("a方法");
    }
}
class Test1{
    public static void main(String[] args) {
        //接口不能创建对象
        //TestInterface01 t = new TestInterface02();
        TestInterface02 t = new Student();//接口指向实现类->多态

        //接口如何访问？
        System.out.println(TestInterface01.NUM); //静态static方法可以直接.
        System.out.println(Student.NUM);
        Student s = new Student();
        System.out.println(s.NUM);
        TestInterface01 t1 = new Student();
        System.out.println(t1.NUM);

    }
}

接口的作用是什么?

定义规则，只是跟抽象类不同地方在哪?它是接口不是类。

接口定义好规则之后，实现类负责实现即可。

继承实现的区别

继承:子类对父类的继承

实现:实现类对接口的实现

手机是不是照相机

继承:手机  extends 照相机        “is-a”的关系，手机是一个照相机

上面的写法不好

实现:手机 implements 拍照功能  “has-a”的关系，手机具备照相的能力

案例：飞机，小鸟，风筝

定义一个接口：Flyable

多态的应用场合:

(1)父类当做方法的形参，传入具体的子类的对象

(2)父类当做方法的返回值，返回的是具体的子类的对象

(3)接口当做方法的形参，传入具体的实现类的对象

(4)接口当做方法的返回值，返回的是具体的实现类的对象

接口和抽象类的区别:

抽象类:

1、抽象类使用abstract修饰;

2、抽象类不能实例化，即不能使用new关键字来实例化对象;

3、含有抽象方法（使用abstract关键字修饰的方法)的类是抽象类，必须使用abstract关键字修饰;

4、抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法;

5、如果一个子类实现了父类(抽象类)的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类;

6、抽象类中的抽象方法只有方法体，没有具体实现;

接口:

1、接口使用interface修饰;

2、接口不能被实例化;

3、一个类只能继承一个类，但是可以实现多个接口;

4、接口中方法均为抽象方法;

5、接口中不能包含实例域或静态方法（静态方法必须实现，接口中方法是抽象方法，不能实现)

2.接口（JDK1.8之后）

(1）被public default修饰的非抽象方法:

注意1: default修饰符必须要加上，否则出错

注意2:实现类中要是想重写接口中的非抽象方法，那么default修饰符必须不能加，否则出错。


public interface TestInterface {
    //常量
    public static final  int NUM = 10;
    //抽象方法
    public abstract void a();
    //public default 修饰的非抽象方法
    public default void b(){
        System.out.println("-----TestInterface-----b()----");
    }
}
class Test1 implements TestInterface{
    public void c(){
        //用一下接口中b的方法
        b();//可以
        //super.b();//不可以
        TestInterface.super.b();//可以
    }
    @Override
    public void a() {
        System.out.println("重写了a方法");
    }

    @Override
    public void b() {

    }
}

(2)静态方法:


public interface TestInterface2 {
    //常量
    public static final  int NUM = 10;
    //抽象方法
    public abstract void a();
    //public default 修饰的非抽象方法
    public default void b(){
        System.out.println("-----TestInterface2-----b()----");
    }
    //静态方法：
    public static void c(){
        System.out.println("TestInterface2中的静态方法");
    }
}
class Test1 implements TestInterface2{

    @Override
    public void a() {
        System.out.println("重写了a方法");
    }

    public static void c() {
        System.out.println("Test1中的静态方法");
    }
}
class A{
    public static void main(String[] args) {
        Test1 t = new Test1();
        t.c();
        Test1.c();
        TestInterface2.c();
        //static修饰的方法并没有被重写
    }
}

疑问:为什么要在接口中加入非抽象方法

如果接口中只能定义抽象方法的话，那么我要是修玫接口中的内容，那么对实现类的影响太大了

现在在接口中加入非抽象方法，对实现类没有影响，想调用就去调用即可。

3.内部类

成员内部类

/*
1.类的组成：属性，方法，构造器，代码块（普通块，静态块，构造块，同步块），内部类
2.一个类TestOuter的内部的类SubTest叫内部类 内部类:SubTest 外部类：TestOuter
3.内部类：成员内部类(静态与非静态) 和局部内部类（位置:方法内，块内，构造器内）
4.成员内部类：
        里面可以有属性，方法，构造器等
         修饰符：private,default,protect,public,final,abstract
 */
public class TestOuter {
    //成员内部类
    class D{
        int age = 20;
        String name;
        public void method(){
            //5.内部类可以访问外部类的内容
//            System.out.println(age);
//            a();
            int age = 30;

            //8.内部类和外部类属性重名的时候，该如何调用
            System.out.println(age);//30
            System.out.println(this.age);
            System.out.println(TestOuter.this.age);
        }

    }
    //静态成员内部类
    static class E{
        public void method(){
            //6.静态内部类只能访问外部类被static修饰的内容
            //System.out.println(age);//该属性需要被static才能访问
            //a();//该方法需要被static才能访问
        }
    }
    //属性
    int age = 10;
    //方法
    public void a(){
        System.out.println("这是a方法");
        {
            System.out.println("这是一个普通块");
            class B{

            }
        }
        class A{

        }
        //7.外部类想要访问内部类的东西，需要创建内部类的对象然后进行调用
        D d = new D();
        System.out.println(d.name);
        d.method();
    }

    static {
        System.out.println("这是静态块");
    }
    {
        System.out.println("这是构造块");
    }
    //构造器
    public TestOuter(){
        //成员内部类
        class C{

        }
    }
    public TestOuter(int age){
        this.age = age;
    }
}
class Demo{
    public static void main(String[] args) {
        //创建外部类的对象
        TestOuter to = new TestOuter();
        to.a();
        //创建内部类对象
        //静态的成员内部类创建对象
        TestOuter.E e = new TestOuter.E();
        //非静态的成员内部类创建对象
       //错误： TestOuter.D d = new TestOuter.D();
        TestOuter t = new TestOuter();
        TestOuter.D d = t.new D();
    }
}

局部内部类


public class TestOuter {
    //1.在局部内部类中访问到的变量必须是被final修饰的
    public void method(){
        final int num = 10;
        class A{
            public  void  a(){
                //num = 20;
                System.out.println(num);
            }
        }
    }
    //2.如果类B在整个项目中只使用一次，那么就没有必要单独创建一个B类，使用内部类就可以了
    public Comparable method2(){
        class B implements Comparable {
            @Override
            public int compareTo(Object o) {
                return 100;
            }
        }
        return new B();
    }
    public Comparable method3(){
        //3.匿名内部类
        return new Comparable(){
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
    }
    public void test(){
        Comparable com = new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 200;
            }
        };
        System.out.println(com.compareTo("abc"));
    }
}

02异常

异常的体系:

Java中异常继承的根类是:Throwable。

Error :错误的意思，严重错误Error，无法通过处理的错误，一旦出现，只能重启系统，优化项目。

比如内存奔溃，JVM本身的奔溃。这个程序员无需理会。

Exception:才是异常类，它才是开发中代码在编译或者执行的过程中可能出现的错误

它是需要提前处理的。以便程序更健壮!

异常的语法注意：（了解）

①运行时异常被抛出可以不处理。可以自动抛出,编译时异常必须处理.按照规范都应该处理!

②重写方法申明抛出的异常，应该与父类被重写方法申明抛出的异常一样或者范围更小

③方法默认都可以自动抛出运行时异常，throws RuntimeException可以省略不写!!

④当多异常处理时，捕获处理，前边的异常类不能是后边异常类的父类。

⑤在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收操作

自定义异常

自定义编译时异常．

        a.定义一个异常类继承Exception

        b.重写构造器

        c.在出现异常的地方用throw new自定义对象抛出!

编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理!

自定义运行时异常．

        a.定义一个异常类继承RuntimeException

        b.重写构造器

        c.在出现异常的地方用throw new自定义对象抛出!

提醒不强烈，编译阶段不报错!!

引入:Java已经为开发中可能出现的异常都设计了一个类来代表．

但是实际开发中,异常可能有无数种情况,Java无法为这个世界上所有的异常都定义一个代表类。

假如一个企业如果想为自己认为的某种业务问题定义成一个异常，就需要自己来自定义异常类.

需求:认为年龄小于o岁，大于200岁就是一个异常。

运行时定义

public class AgeIllegalException extends Exception {
    /*
    自定义运行时异常类
        1.继承RuntimeException
        2.重写构造器
    */

    public AgeIllegalException(String message) {
        super(message);
    }

    public AgeIllegalException(String message, Throwable cause) {
        super(message, cause);
    }

    public AgeIllegalException(Throwable cause) {
        super(cause);
    }

    public AgeIllegalException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }

}

public class ExceptionDemo {
    public static void main(String[] args)  {
        checkAge(201);
    }

    public static void checkAge(int age) throws AgeIllegalException {
        if (age < 0 || age > 200) {
            //出现异常了
            throw new AgeIllegalRuntimeException("/age is illegal");
        } else {
            System.out.println("年龄是：" + age);
        }
    }
}

 

 解决编译时异常代码


public class ExceptionDemo {
    public static void main(String[] args)  {
        try {
            checkAge(201);
        }catch (AgeIllegalException e){
            e.printStackTrace();
        }

    }

    public static void checkAge(int age) throws AgeIllegalException {
        if (age < 0 || age > 200) {
            //出现异常了
            throw new AgeIllegalRuntimeException("/age is illegal");
        } else {
            System.out.println("年龄是：" + age);
        }
    }
}
//另一种方式
public class ExceptionDemo  {
    public static void main(String[] args)  throws AgeIllegalException{

        checkAge(201);

    }

    public static void checkAge(int age) throws AgeIllegalException {
        if (age < 0 || age > 200) {
            //出现异常了
            throw new AgeIllegalRuntimeException("/age is illegal");
        } else {
            System.out.println("年龄是：" + age);
        }
    }
}

非运行时异常(受检异常)：编译器会检查此类异常，如果程序中出现此类异常，必须对该异常进行处理，要么使用try-catch捕获，要么使用throws语句抛出，否则编译不通过。 

运行时异常

public class AgeIllegalRuntimeException extends RuntimeException {
    public AgeIllegalRuntimeException() {
    }

    public AgeIllegalRuntimeException(String message) {
        super(message);
    }

    public AgeIllegalRuntimeException(String message, Throwable cause) {
        super(message, cause);
    }

    public AgeIllegalRuntimeException(Throwable cause) {
        super(cause);
    }

    public AgeIllegalRuntimeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}


public class ExceptionDemo {
    public static void main(String[] args) throws AgeIllegalRuntimeException {
        checkAge(201);
    }

    public static void checkAge(int age) throws AgeIllegalRuntimeException {
        if (age < 0 || age > 200) {
            //出现异常了
            throw new AgeIllegalRuntimeException("/age is illegal");
        } else {
            System.out.println("年龄是：" + age);
        }
    }
}

VifrificationZ
关注
专栏目录
java 接口 抛出异常处理_JAVA中接口与抛出异常的相关知识
weixin_42525482的博客
02-13 3008
1、接口概念：接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。2、接口定义：和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。基本语法：[修饰符]interface 接口名 [extends 父接口1，...
java接口监听器
wxbbbbb的博客
07-15 2464
java之接口监听器 什么是监听器： 监听器就是一个实现特定接口的普通java程序，这个程序专门用于监听另一个java对象的方法调用或属性改变，当被监听对象发生上述事件后，监听器某个方法将立即被执行 什么是接口： 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。 除非
java 接口 异常_Java语言中接口和异常处理的总结
weixin_32752827的博客
02-12 1685
一、接口1、接口定义接口是一系列方法的声明，是一些抽象的集合；接口只有抽象方法没有方法的实现,且默认就是public权限；接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念；类描述对象的属性和方法，接口则包含类要实现的方法；接口就是特殊的抽象类，即所有方法都是抽象方法的抽象类就是Java中的接口(interface)；接口无法被实例化，但是可以被实现。2、接口的基本格式【修饰符】int...
java 接口 抛出异常_Java接口抛出异常，但接口实现不抛出异常？
weixin_35936869的博客
02-19 1938
我读到这段代码的接口抛出一个异常，但实现它不抛出一个或赶上一个类，这是为什么？在java中合法还是安全？Java接口抛出异常，但接口实现不抛出异常？import java.rmi.*;public interface MyRemote extends Remote {public String sayHello() throws RemoteException;}import java.rmi.*...
Java接口调用统一处理异常
杨鑫newlife的专栏
11-13 2137
我们在写调用接口时，代码有复杂的处理逻辑，就会有包含写入数据库、空值、参数异常等等问题。 那么我们为了可以清晰的返回给接口异常信息，无论调用逻辑嵌套多少层，可以尝试在最外面主逻辑加一层捕获异常用于处理和分解接口返回即可（下面代码中的 try1 ）。 但是嵌套的逻辑需要把异常抛出来给上层处理和解析，使用throw，这里可以获取信息e.getMessage()抛出给外层。 try1 { // 子类 try2 { } catch2 (Exception error) {
java接口报错500自定义异常信息返回
qq_24138151的博客
08-05 4220
import com.sun.java.browser.plugin2.liveconnect.v1.Result; import com.techno.util.ResponseData; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.web.bind.annotation.ControllerAdvice; import org.springframework.web.bind...
java接口异常重试机制实现（guava-retrying方式）
xieedeni的博客
04-26 4247
java重试机制实现guava-retrying
Java异常类详解
qq_50692350的博客
08-04 7459
Java
JAVA常见异常类汇总
Hello World
09-08 3781
JAVA中常见的异常类
Java接口回调
数据工匠记
01-03 8157
回调的含义和用途 什么是回调？ 一般来说，模块之间都存在一定的调用关系，从调用方式上看，可以分为三类：同步调用、异步调用和回调。同步调用是一种阻塞式调用，即在函数A的函数体里通过书写函数B的函数名来调用之，使内存中对应函数B的代码得以执行。异步调用是一种类似消息或事件的机制解决了同步阻塞的问题，例如 A通知 B后，他们各走各的路，互不影响，不用像同步调用那样， A通知 B后，非得等到 B走完后...
Java 面向对象（继承、多态、接口、异常）.ppt
08-21
掌握类的继承、方法重写、super关键字的使用、final关键字、抽象类和接口、多态的使用以及异常的处理方式 熟悉面向对象继承和多态的概念
Java8中级篇--接口-异常与集合
06-09
本篇文章将深入探讨Java8中的接口、异常处理以及集合框架的相关知识点，帮助你更好地理解和应用这些概念。 首先，我们来谈谈Java8中的接口。在Java 8之前，接口是完全抽象的，只能包含抽象方法。然而，自Java 8开始...
DELPHI 11调用JAVA 接口
07-03
使用`CreateJavaVM`函数初始化Java虚拟机（JVM），然后通过`FindClass`查找Java接口类，使用`GetMethodID`获取接口方法的ID，最后通过`CallObjectMethod`或`CallNonvirtualObjectMethod`来调用Java接口。 5. **传递...
Java实验3 接口与异常处理
Ryanax的博客
11-29 713
接口与异常处理
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 492
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 988
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 565
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 349
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 197
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值