JAVA类（内部类、匿名内部类、异常、自定义异常）

内部类

package AA;

public class 类 {

    int de=;
    StringBuffer dee=new StringBuffer();
    public class 成员内部类{
        public void ff() {
            System.out.println("这是成员内部类方法");
        }
    }
    /*
    1.可以访问外部类所有的成员，包括被声明为私有(private)的；

    2.可以使用任何访问权限修饰符，包括protected和private；
    */

    public void ff1() {

        int de1=;
        class 局部内部类{
            public void ff() {
                System.out.println("局部内部类方法");
                System.out.println(de);
            }
        }
         new 局部内部类().ff();
    }
    /*
    1.不允许使用任何访问权限修饰符；

    2.创建局部内部类的对象的语法，必须在声明局部内部类之后；调用只能在该方法里

    3.可以访问外部类所有的成员，包括被声明为私有(private)的；

    */

    private static class 静态内部类{
        public void ff() {
            System.out.println("这是静态内部类方法");

        }
    }
    /*
    1.只能访问static成员

    2.可以使用任何访问权限修饰符，包括protected和private；

    3.可以在其它类中直接创建静态内部类的对象，语法格式为：

    */

    public  void dy() {

        new 成员内部类().ff();//调用成员内部类方法
        //调用方法二：   类.成员内部类 de=new 类.成员内部类();
        new 类().ff1();//调用局部内部类方法
        new 静态内部类().ff();//调用静态内部类方法
        //调用方法二：类.静态内部类  de=new 静态内部类();

    }

    public static void main(String[] args) {

        new 类().dy();
    }

}

---

参考：

https://www.cnblogs.com/zhncnblogs/p/6222750.htmlhttps://blog.csdn.net/mrbacker/article/details/84500918

---

匿名内部类

---

参考：

https://baijiahao.baidu.com/s?id=1600814193634680238&wfr=spider&for=pc

https://www.cnblogs.com/baizhuang/p/11393778.html

---

抽象类

参考：
https://www.runoob.com/java/java-abstraction.html

---

异常

先来点基础的：

public class xin {
    public static void main(String[] args) {
    try{
        System.out.println("hhhhh");
        int de[]=new int[];
                    de[]=;

    }catch(ArrayIndexOutOfBoundsException fr){
        System.out.println("chucuo");
    }
    }
}

上面代码解释了：一个基本异常的基本格式，try{  } ......catch(){   }
try。。。catch：不需要抛出异常

自定义异常：

package AA;
import java.util.Scanner;

 class de1 extends Exception{//首先类要继承Exception（就是异常类）

public de1(String fr) {
    super(fr);
}
}

public class de{

    public static int fg(int a,int b) throws de1{//声明方法并且抛出异常（throws de1）
        Scanner de1=new Scanner(System.in);

       System.out.println("请输入数值1");
       a=de1.nextInt();
       System.out.println("请输入数值2");
       b=de1.nextInt();

       if(a<||b<) {
           throw new de1("负数错误");//抛出异常
       }
       if(a>||b>) {
           throw new de1("数大于100错误");
       }
       return a+b;
        }
    public static void dayin() {
        System.out.println("异常啦");
    }
    public static void main(String[] args)  {
       try {

        fg(,);      //调用上面的方法，下面并且打印出结果，打印方法是打印方法的返回值
                            //这里的数字没多大用处，主要是不出错
                            //根据上面的方法给出的变量所以这里必须要加
                            //但是上面有输入流，就直接将这个覆盖了
        System.out.println(fg(,));

       }catch(de1 e) {//这个是try后面必须接的
                      //括号里面的是异常类型，e是结果
           dayin();
           System.out.println(e);
       }
    }
}
//1，程序通过try走，并且执行fg方法
//2，当用户输入数值时，会进行判断，如果不符合就会抛出异常（这里是抛在de1类里面，关键字：throw new 类名）
//3，try执行已经异常了，所以将会执行catch，而catch可以有多个，那个catch则会判断try异常属于哪一类型的异常
//4，判断完后，将会执行catch里面的语句，用来提示用户
//4的注意：上面的判断下面什么（负数错误）（da数错误），其实是de1类的构造string方法，可以去掉，直接在catch里面加提语句都一样
//列如下面：去掉构造，在catch里面加已是语句

package AA;
import java.util.Scanner;

 class de1 extends Exception{

}

public class de{
    static int fg(int a,int b) throws de1{//声明抛出异常（throws de1）

        Scanner de1=new Scanner(System.in);

       System.out.println("请输入数值1");
       a=de1.nextInt();
       System.out.println("请输入数值2");
       b=de1.nextInt();

       if(a<||b<) {
           throw new de1();//抛出异常，说白了就是
       }
       if(a>||b>) {
           throw new de1();
       }
       return a+b;
        }
    static void dayin() {
        System.out.println("异常啦");
    }
    public static void main(String[] args)  {
       try {

        fg(,);      //调用上面的方法，下面并且打印出结果，打印方法是打印方法的返回值
                            //这里的数字没多大用处，主要是不出错
                            //根据上面的方法给出的变量所以这里必须要加
                            //但是上面有输入流，就直接将这个覆盖了
        System.out.println(fg(,));

       }catch(de1 e) {//这个是try后面必须接的
                      //括号里面的是异常类型，e是结果
           dayin();
           System.out.println("有错误哟！");
           System.out.println(e);
       }
    }
}

结论：

1，首先一个自定义异常的要有一个拋回来的异常类，这个类用于其它类执行的方法时抛出来的异常，就抛在这个类里面
注意：这个类必须是继承Exception（推荐）和RuntimeException

2，然后就可以在‘其他类’里面随意加方法了，
注意：需要抛出异常就必须在方法名后面加throws 类名，格式：方法名 throws 类名（被抛异常类）

3,声明好方法后，就可以了
注意：这里番外哈，1,如果里面有if判断语句，可以在判断下方在加个'异常抛出'，格式：throw new 类名（被抛异常类）
2,注意：throw：是放在方法体里面的
throws：是放在方法体上面的（就是方法名上面）

4,接下来就是用try.....catch了。try里面放异常的方法（说白了就是在try里面执行方法体）
catch就是异常类型了，自定义异常，那‘异常类型’肯定就是‘被抛异常类名’
catch语句格式：catch（类名 返回值（结果）），结果随意
这个语句一般放在开始执行程序是调用方法那里

下面再举一个例子：判断输出输入的值是否是负数

package hhh;
public class hh  extends Exception{
    static int a,c;
    static int b=;

    public static void de(int a1) throws hh{
        if(a1<){
            throw new hh();
        }
        a=b*a1*;
        System.out.println("输出："+a);
    }
public static void main(String []args){
    try{
        de(-);
    }catch(hh re){
        System.out.println("负数无效");
    }
}
}

执行结果：抛出异常，执行catch语句

例子二

package AA;
import java.util.InputMismatchException;
import java.util.Scanner;

public class 异常 extends Exception{
    Scanner de=new Scanner(System.in);
    public void ks()throws 异常 {
        try {
            for(;;) {
        System.out.println("请输入数字");
        int dee=de.nextInt();
        if(dee<)throw new 异常();
        System.out.println("正确");
    }
        }

        catch(异常 e) {
        System.out.println("对不起你输入的有误！！");
        new 异常().ks();
        }
        catch(InputMismatchException ee) {
            System.out.println("数字过大或者非数字");
            new 异常().ks();
        }
    }
public static void main(String[] args) throws 异常 {
    new 异常().ks();
}
}

/*
编写程序：判断用户输入的是否为负数，否则异常
*/

执行结果：

（内部类、匿名类、匿名内部类、抽象类、异常、终态）