内部类与异常类、注解

最新推荐文章于 2024-04-12 16:14:56 发布

萨曼塔

最新推荐文章于 2024-04-12 16:14:56 发布

阅读量290

点赞数 1

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

本文链接：https://blog.csdn.net/weixin_63544745/article/details/129035369

版权

java 专栏收录该内容

7 篇文章 3 订阅

订阅专栏

内部类

概念：Java支持在一个类中定义另一个类，这样的类称为内部类，而包含内部类的类称为内部类的外嵌类。

内部类与外嵌类的关系：

1）内部类可以使用外嵌类的成员变量和方法
2）内部类的类体中不可以声明类变量和方法，外嵌类的类体中可以用内部类声明对象，作为外嵌类的成员；
3）内部类仅供它的外嵌类使用，其它类不可以使用某个类的内部类声明对象。（可以使用protected和private修饰【非内部类不可修饰】，但是无意义）

Java编译器生成的内部类的字节码文件的名字和通常的类不同，内部类对应的字节码文件的名字格式是“外嵌类名$内部类名”

内部类可以修饰为static内部类，static内部类是外嵌类的一种静态数据类型，程序可以在其它类中使用static内部类来创建对象。但是，static内部类不能操作外嵌类的实例成员变量。【注：非内部类不可以是static类】

public class test {
    public static void main(String[] args) {
        A a = new A();
        a.call();
        a.b.speak();
        A.B b = new A.B();
    }
}
class A{
    String name;
    B b;//内部类声明对象
    void call(){
        System.out.println("call B");
    }
    //内部类的声明
    static class B{
        void speak(){
            System.out.println("someone is speaking");
        }
    }
}

匿名类

和子类有关的匿名类

介绍：Java允许用户直接使用一个类的子类的类体来创建一个子类对象，也就是说，在创建类对象时，除了使用父类的构造方法外还有类体，此类体倍认为是一个子类去掉类声明后的类体，称作匿名类。（匿名类无法声明对象，但可以直接创建对象）

特点：

1）匿名类可以继承父类的方法，也可以重写父类的方法。
2）在使用匿名类时，必然是在某个类中直接用匿名类创建对象。匿名类一定是内部类。
3）匿名类可以访问外嵌类中的成员变量和方法，在匿名类的类体中不可以声明static成员变量和static方法。
4）由于匿名类是一个子类，且没有类名，所以在用匿名类创建对象时要直接使用父类的构造方法。

public class test {
    public static void main(String[] args) {
        //方式1
        A a = new A() {
            @Override
            public void output() {
                System.out.println("匿名类");
            }
        };
        a.output();
        //方式2
        B b = new B();
        b.show(new A() {//向参数传递A的匿名子类对象
            @Override
            public void output() {
                System.out.println("b show A");
            }
        });
    }
}

abstract class A{
    int aa;
    public A(){
        this.aa = 10;
    }
    public A(int aa){
        this.aa = aa;
    }
    public abstract void output();
}
class B{
    void show(A a){
        a.output();
    }
}

和接口有关的匿名类

介绍：java允许用一个接口名和一个类体创建一个匿名对象类，此接口被认为是实现了接口的类去掉类声明后的类体，称作匿名类。

如果某个方法的参数是接口类型，那么可以使用接口名和类体组合创建一个匿名对象传递给方法的参数，类体必须要重写接口中的全部方法。

public class test {
    public static void main(String[] args) {
        B b = new B();
        b.say(new A() {
            @Override
            public void speak() {
                System.out.println(" A is speaking.");
            }
        });
    }
}

interface A{
    void speak();
}
class B{
    public void say(A a){
        a.speak();
    }
}

Lambda表达式代替匿名类

介绍：如果一个接口是一个函数接口，程序就可以把一个Lambda表达式的值（即方法的入口地址）赋给变量，那么接口变量就可以调用Lambda表达式实现的接口中的方法。即，将一个Lambda表达式的值作为实参传给方法的接口类型的形参

public class test {
    public static void main(String[] args) {
        B b = new B();
        b.say(()->{
            System.out.println("A - b is speaking");
        });
    }
}
interface A{
    void speak();
}
class B{
    public void say(A a){
        a.speak();
    }
}

匿名类还可以划分成四类

定义在外部类的局部位置（例方法内）：局部内部类（有类名），匿名内部类（无类名）；
定义在外部类的成员位置：成员内部类（无static），静态内部类（有static）

异常类

异常

异常就是程序运行时可能出现的一些错误，例：打开一个不存在的文件，异常处理将会改变程序的控制流程，让程序有机会对错误做出处理。

Java使用throw关键字抛出一个Exception子类的实例表示异常发送。

Java允许在定义方法时声明该方法调用过程中可能出现的异常，即允许方法在调用过程中抛出异常对象，终止当前方法的继续执行。

Java使用try-catch语句来处理异常，将可能出现的异常操作放在try-catch语句中的try部分，一旦try部分抛出异常，或调用某个可能抛出的异常对象的方法，并且该方法抛出了异常对象，那么try部分将立刻介绍执行，转向执行相应的catch部分，所以程序可以将发生异常后的处理放在catch部分。无论try部分是否发生异常，finally子语句都会被执行。

public class test {
    public static void main(String[] args) {
        int m = 0;
       try{
           m = Integer.parseInt("12a3");//代码A
           m = 3;
       }catch (NumberFormatException e){
           System.out.println("发生异常:"+e.getMessage());
       }finally {
           System.out.println("m = "+m);
           System.out.println("执行结束");
       }
    }
}

代码A注释掉，执行结果是：
m=3
执行结束

自定义异常类

一个方法在声明时可以使用throws关键字声明要产生的若干个异常，并在该方法的方法体中具体给出产生异常的操作。

public class test {
    public static void main(String[] args) throws BankException {
       int money = -23;
       if(money<0){
           throw new BankException(money);//方法抛出异常
       }
    }
}

//自定义异常类
 class BankException extends Exception{
    String message;
    public BankException(int m){
        message = "入账资金"+m+"是不符合系统要求";
    }
    public String warnMess(){
        return message;
    }
}

断言

断言语句一般用于程序不准备通过捕获异常来处理的错误。当程序正式运行时就可以关闭断言语句，但仍把断言语句保留在源代码中，如果以后应用程序又需要调试，可以重新启用断言语句。

注：当使用Java解释器直接运行应用程序时，默认关闭断言语句，在调试程序时可以使用-ea启用断言语句

例如： java -ea mainClass

public class test {
    public static void main(String[] args)  {
       int a = -100;
       int b = 400;
       assert a > 0;//方式1:a不能为负数
        System.out.println("aaaa");
       assert b < 300 : "b超过规定范围300";//方式2:b<300
        System.out.println("bbb");

    }
}