Java接口与异常

VifrificationZ

已于 2024-02-03 22:18:48 修改

阅读量32

点赞数

分类专栏： java 文章标签： java 开发语言

于 2023-11-14 14:00:29 首次发布

本文链接：https://blog.csdn.net/2301_79866936/article/details/134381181

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

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);
        }
    }
}