Java常用类

内部类分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

内部类概念

概念：在一个类的内部再定义一个完整的类。

特点：

• 编译之后可生成独立的字节码
• 内部类可以直接访问外部类的私有成员，而不破坏封装。
• 可以为外部类提供必要内部功能组件

// 身体
public class Body {
    private  String name;
    // 头部
    class Header{
        public void show(){
            System.out.println(name); // 可以访问外部类的私有成员
        }
    }
}

成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类。

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

  • Outer outer = new Outer();
  • Outer.Inner inner = outer.new Inner();

• 如果内部类和外部类有同一参数，默认为内部类参数。要调用外部类属性，带上 类名.this

  • System.out.println(Outer.this.name);

• 成员内部类不能定义静态成员，但可以有静态常量

  • 就是说不能有 static 成员，但可以有 static final 常量

// Outer.java
// 外部类
public class Outer {
    // 实例变量
    private String name = "张三";
    private int age = 20;

    // 内部类
    class Inner{
        private String address = "北京";
        private String phone = "010";
		private String name = "李四";
        // 方法
        public void show(){
            // 打印外部属性
            // 属性和外部类属性相同时，带上 类名.this
            System.out.println(Outer.this.name);
            System.out.println(age);
            // 打印内部类属性
            System.out.println(address);
            System.out.println(phone);
        }
    }
}

// 实现
public class TestOuter {
    public static void main(String[] args) {

//        // 1. 创建外部类对象
//        Outer outer = new Outer();
//        // 2. 创建内部类对象
//        Outer.Inner inner = outer.new Inner();
//        // 3. 调用
//        inner.show();
        
        // 简单实现
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员

定义类

// 外部类
public class Outer {
    private String name = "xxx";
    private int age = 18;

    // 静态内部类, 和外部类相同
    // 为了给外部类提供功能，使用方法和外部类一样
    static class Inner{
        private String address = "上海";
        private String phone = "111";
        // 静态成员
        private static int count = 1000;
        public void show(){
            // 调用外部类属性
            // 1. 先创建外部类对象
            Outer outer = new Outer();
            // 2. 调用外部类对象的属性
            System.out.println(outer.age);
            System.out.println(outer.name);
            // 调用内部静态类的属性和方法
            System.out.println(address);
            System.out.println(phone);
            // 调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}

实现

public static void main(String[] args) {
        // 直接创建静态内部类
        // 注意：并没有 new Outer对象，不是 new Outer().new Inner()
        //       只是包含关系
        Outer.Inner inner = new Outer.Inner();

        inner.show();
    }

注意：并没有 new Outer对象，不是 new Outer().new Inner()，只是包含关系

静态内部类直接new，成员内部类得一层一层new

局部内部类

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。

• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，变量必须修饰为final

定义类

// 外部类
public class Outer {
    private String name = "刘德华";
    private int age = 60;

    public void show(){
        // 定义局部变量
        String address = "深圳";

        // 局部内部类: 不能加任何访问修饰符
        // 仅限于当前方法
        class Inner{
            private String phone = "15558888";
            private String email = "sdaa@as.com";

            public void show2(){
                // 访问外部类的属性
                // 可以直接访问，相当于省略了 Outer.this.
                System.out.println(name);
                System.out.println(Outer.this.age);
                // 访问内部类的属性
                // 相当于省略了 this.
                System.out.println(phone);
                System.out.println(this.email);
                // 访问局部变量
                // JDK1.7 要求：变量必须是常量final
                // JDK1.8 之后，会自动添加final
                System.out.println(address);
            }
        }
        // 创建内部类对象
        Inner inner = new Inner();
        inner.show2();
    }
}

实现

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

外部类里的函数里面定义了类，最终调用时，应该在对应的函数内创建并实现

匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 作用：方便创建子类对象，最终目的为了简化代码编写。
• 必须继承一个父类或者实现一个接口

例如下面代码，由于Animal是抽象的，所以得用Tiger继承，再实现

public class Demo03 {
	public static void main(String[] args) {
		Animal a = new Tiger();
		a.run();
	}
}

class Tiger extends Animal{
	@Override
	public void run() {
		System.out.println("老虎跑的快");
	}
}

abstract class Animal{
	public abstract void run();
}

匿名内部类的写法如下，直接再新建Animal后面Override实现。

public class Demo03 {
	public static void main(String[] args) {
		Animal a = new Animal() {
			@Override
			public void run() {
				System.out.println("老虎跑的快");
			}
		};
		a.run();
	}
}

abstract class Animal{
	public abstract void run();
}

• 匿名内部类是没有名字的内部类。

• 匿名内部类写出来就会产生一个匿名内部类的对象。

• 匿名内部类的对象类型相当于是当前new的哪个的类型的子类类型。