JavaSE:匿名内部类、static关键字、文档注释

一、匿名内部类

1.声明格式

（1）new 父类（）{

​ 匿名子类的成员

}

匿名子类的构造器中一定调用的父类的无参构造

（2）new 父类（实参列表）{

​ 匿名子类的成员

}

匿名子类的构造器一定调用的父类的有参构造

（3）new 父类接口名（）{

​ 匿名子类的成员

}

匿名子类的构造器中一定调用的父类Object的无参构造

为什么声明类有new呢？

因为匿名内部类是没有名字的，所以必须在声明类的同时直接创建它的对象，否则就没有机会了。
说明匿名内部类的对象是唯一的。

2.特点

（1）类没有名字

（2）必须在声明类的同时创建唯一的对象

（2）匿名内部类没有任何修饰符

没有权限修饰符

没有static

没有abstract

没有final

(4)匿名内部类也是一个类

1.有自己的字节码文件：外部类名$编号.class

2.成员有限制

不能声明自己的静态成员，除非是static final,或者是从父类继承的

不能声明自己的构造器

public class TestInner {
    public static void main(String[] args) {
        //第一种声明形式，这是Object的一个匿名子类
        new Object(){
            public void method(){
                //...
            }
        };

        //第一种声明形式，这是Object的另一个匿名子类
        //以下这个对象和上面的对象不是同一种类型
        new Object(){
            public void method(){
                //...
            }
        };

        //第一种声明形式
        new Father(){
            public void method(){
                //...
            }
        };

        //第二种声明形式
        new Father(10){
            public void method(){
                //...
            }
        };

        //第三种声明形式
        new MyInter(){
            public void method(){
                //...
            }
        };
    }
}
class Father{
    private int a;

    public Father() {
    }

    public Father(int a) {
        this.a = a;
    }
}

interface MyInter{
    void method();
}

3.如何使用：

形式一：直接匿名内部类的匿名对象.成员

new 父类/父接口（【实参】）{

​ 成员列表

}.成员；

形式二：用一个变量接受匿名内部类的对象，然后通过对象.成员

父类/父接口 变量 = new 父类/父接口（【实参】）{

​ 成员列表

}；

变量.成员（…）;

这种形式，只能多态引用，即只能用父类或父接口的变量接收匿名内部类的对象。
只能调用重写父类/父接口的方法，不能用于调用子类扩展的方法。

形式三：匿名内部类的对象直接作为调用方法的实参

方法（new 父类/父接口（【实参】）{

​ 成员列表

}

）；

只能通过形参调用匿名内部类中重写父类/父接口的方法。

public class TestInner2 {
    public static void main(String[] args) {
        //形式一： 直接匿名内部类的匿名对象.成员
        new Object(){
            public void method(){
                System.out.println("匿名内部类1的method方法");
            }
        }.method();

        //形式二：但是Object类中没有method方法，无法调用
        Object object = new Object(){
            public void method(){
                System.out.println("匿名内部类2的method方法");
            }
        };
//        object.method(); //object的编译时类型是Object父类，method属于子类扩展的方法，编译时看父类

        //形式二：
        Fu fu = new Fu(){
            //重写父类的method方法
            public void method(){
                System.out.println("匿名内部类3的method方法");
            }
        };
        fu.method();

        //形式三：
        other(new Fu(){
            //重写父类的method方法
            public void method(){
                System.out.println("匿名内部类4的method方法");
            }
        });//需要Fu类的子类对象，因为Fu是抽象类，子类必须重写抽象方法
    }

    public static void other(Fu fu){//多态参数，形参是父类类型，实参是子类对象，这个子类可以是有名字的子类，也可以是匿名子类的对象
        fu.method();
    }
}

abstract class Fu{
    public abstract void method();
    }

二、static关键字

1、static： 静态的

2、static: 是一个修饰符可以修饰：

（1）static可以修饰成员没不类

（2）可以修饰方法，称为静态方法

（3）static可以修饰成员变量，称为静态变量

（4）static可以修饰代码块，称为静态代码块

（5）静态导入：

形式：import static 包.类名.*;

形式：import static 包.类名.静态成员名；

public class TestStatic {
    public static void main(String[] args) {
/*        System.out.println(Math.sqrt(3));//求平方根
        System.out.println(Math.random());//求随机数
        System.out.println(Math.PI);
        System.out.println(Math.pow(2,5));//求2的5 次方*/

        System.out.println(sqrt(3));//求平方根
        System.out.println(random());//求随机数
        System.out.println(PI);
        System.out.println(pow(2,5));//求2的5 次方
    }
}

三、注释

1.@注解名

例如：@Override

(1)@Override

作用：重写方法

重写方法的要求：

（1）方法名必须形同

（2）形参列表必须形同

（3）返回值类型

基本数据和void必须完全相同

引用数据类型 <=

（4）权限修饰符:`>=

（5）其他修饰符

不能是final,static,private

（2）@SuppressWarnings：抑制警惕（了解）

尽量不要让代码弹警告，不是靠抑制，而是避免写这种代码

（3）@Deprecated：标记xx已过时（必须知道）

已过时的xx，包括方法，变量，类等尽量不要使用，因为他们可能有风险，或者说不方便。