JAVA抽象类中都能写哪些东西

/**
 *
 * 抽象类
 * @date:2022/7/21
 */
public abstract class Abastract01 {

    public void pintees(){

        int a;

        /**
         * 静态方法中的抽象类
         */
        abstract class AbastractMoth{

        }

        /**
         * 静态方法内部内
         */
        class AbastractMothes extends AbastractMoth{

        }

    }

    /**
     * 静态方法
     */
    public static void printer() {

        int a;

        /**
         * 静态方法中的抽象类
         */
        abstract class AbastractMoth{

        }

        /**
         * 静态方法内部内
         */
        class AbastractMothes  {

        }

    }

    /**
     * 接口
     */
    public interface AbaInnerIF {
        int a = 0;

        public void pring();

    }

    /**
     * 在抽象类内定义 实例内部类 修饰权限为默认，不能是public,private,protected，默认权限
     */
    protected class AbaInnerClass extends AbaOutclass {

        /**
         * 全局实例变量
         */
        private int x;

        /**
         * 全局常量
         */
        private final static int Z = 1;

        /**
         * 构造器
         */
        public AbaInnerClass() {
            System.out.println("我是实例内部类的构造器");
        }

        /**
         * 实例方法
         */
        public void printes() {
            System.out.println("我是实例内部类的实例方法");
        }


    }

    /**
     * 在抽象类内定义 实例外部类 修饰权限为默认，不能是public,private,protected，默认权限
     */
    public static class AbaInnerStaitcclass extends AbaOutclass {

        /**
         * 全局实例变量
         */
        private int x;

        /**
         * 全局静态变量
         */
        private static int y;

        /**
         * 全局常量
         */
        private final static int Z = 1;

        /**
         * 构造器
         */
        public AbaInnerStaitcclass() {
            System.out.println("我是外部类的构造器");
        }

        /**
         * 实例方法
         */
        public void printes() {
            System.out.println("我是外部类的实例方法");
        }

        /**
         * 静态方法
         */
        public static void printings() {
            System.out.println("我是外部类的静态方法");
        }

    }

    /**
     * 抽象方法,不能为 private 权限
     */
    public abstract void print();

    public void printing() {
        System.out.println("抽象类的具体方法");
    }

    /**
     * Main方法
     *
     * @param args
     */
    public static void main(String[] args) {

    }
}

/**
 * 在抽象类外定义 实例外部类 修饰权限为默认，不能是public,private,protected权限
 */
class AbaOutclass extends Abastract01 implements Abastract01.AbaInnerIF {

    /**
     * 全局实例变量
     */
    private int x;

    /**
     * 全局静态变量
     */
    private static int y;

    /**
     * 全局常量
     */
    private final static int Z = 1;

    /**
     * 构造器
     */
    public AbaOutclass() {
        System.out.println("我是外部类的构造器");
    }

    /**
     * 实例方法
     */
    public void prints() {
        System.out.println("我是外部类的实例方法");
    }

    /**
     * 静态方法
     */
    public static void printings() {
        System.out.println("我是外部类的静态方法");
    }

    /**
     * 抽象方法,不能为 private 权限
     */
    @Override
    public void print() {

    }

    @Override
    public void printing() {
        super.printing();
    }

    @Override
    public void pring() {

    }
}

 上述代码编写了在抽象类中都能创建哪些类，哪些方法，包括外部类，实例内部类，静态内部类，接口，实例方法，静态方法，实例变量，静态变量，实例方法的内部类，实例方法的抽象类，静态方法的抽象类，静态方法的内部内等知识。