常用类

内部类

  • 概念：在一个类的内部再定义一个完整的类
  • 特点：
    编译之后可生成独立的字节码文件（class文件）
    内部类可直接访问外部类的私有成员，而不破坏封装
    内部类可以为外部类提供必要的内部功能组件

成员内部类

  • 在类的内部定义，与实例变量，实例方法同级别的类
  • 创建内部类对象时，必须要先创造外部类对象
public class Outer {

    private String name = "张三";
    private int age = 20;

    class Inner{
        private String address = "北京";
        private String phone = "110";

        public void show(){
            System.out.println(name);
            System.out.println(age);
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //创建内部类对象
        Outer.Inner inner = new Outer().new Inner();
        inner.show();

    }
}
  • 当外部类，内部类存在重名属性时，会优先访问内部类属性，可以用外部类名.this.属性来访问外部类
public class Outer {

    private String name = "张三";

    class Inner{
        private String name = "李四";
        public void show(){
            System.out.println(name);//输出李四，重名时优先访问呢内部类
            System.out.println(Outer.this.name);//输出张三
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //创建内部类对象
        Outer.Inner inner = new Outer().new Inner();
        inner.show();

    }
}
  • 成员内部类中不能定义静态成员，可以包含静态常量

静态内部类

  • 在成员内部类的基础上加static关键字
  • 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员，相当于一个外部类
  • 只有内部类才可以用static修饰
public class Outer {
    private String name = "张三";
    //静态内部类，级别和外部类相同
    static class Inner{
        private String address = "北京";
        private static int count = 1000;
        public void show(){
            //静态内部类项方伟外部类的属性，需要先对外部类进行实例化
            Outer outer = new Outer();
            System.out.println(outer.name);
            System.out.println(address);
            System.out.println(count);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //只需要表示包含关系就可以，只用到内部类不用对外部类实例化
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}

局部内部类

  • 定义在方法里的类，称为局部内部类，作用范围和创建对象范围只限当前方法
  • 与局部变量一样，不能加任何修饰符
  • 局部内部类不常用
public class Outer {
    private String name = "张三";

    public void show(){
        //局部变量前不能加修饰符
        String address = "北京";
        /*
        由于是局部变量，方法加载完变量就消失
        但内部类不会消失，所以在内部类中无法调用消失的局部变量
        但从jdk1.8以后会在局部变量前默认加上finally，默认常量
        局部变量在方法加载完后也不会消失
         */

        //局部内部类也不能加修饰符，不能加静态成员
        class Inner{
            private String phone="190";
            public void show2(){
                System.out.println(name);//访问外部类属性
                System.out.println(phone);//访问内部类
                System.out.println(address);
            }

        }
        Inner inner = new Inner();//因为局部内部类只能在该方法中有效，所以需要在该方法内进行实例化
        inner.show2();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

匿名内部类

  • 没有命名的局部内部类，一切特征都与局部内部类相同
  • 必须继承一个父类或者实现一个接口
  • 匿名内部类其实是定义类，实现类，创建对象的语法合并，只能创建一个该类的对象
  • 实现类在方法中
public class Test {
    public static void main(String[] args) {

        class Fan implements UserService{//Fan为UserService的实现类
            @Override
            public void service() {
                System.out.println("连接电脑成功，风扇开始工作了");
            }
        }
        UserService user = new Fan();//只能new实现类
        user.service();
    }
}

public interface UserService {

    void service();//service方法
}
  • 匿名内部类
public class Test {
    public static void main(String[] args) {

        //类只用一次，就用匿名内部类
        UserService user = new UserService() {
            @Override
            public void service() {
                System.out.println("点奶连接成功");
            }
        };//分号不要忘记
        user.service();
    }
}

public interface UserService {

    void service();//service方法
}