0027 Java学习笔记-面向对象-(非静态、静态、局部、匿名)内部类

内部类

• 内部类就是把一个类写在另一个类的内部
• 用途：
  • 如果一个类只希望它被某一个类访问，那么可以把它定义在另一个类的内部，并用private修饰
  • 内部类可以访问它所在外部类的private成员；但所在的外部类的成员不能直接访问内部类的数据
  • 内部类适合于创建那些仅需要一次使用的类
• 内部类除了可以用省略和public外，还可以用private/protected/static修饰
• 非静态内部类不能拥有静态成员

内部类的分类

• 成员内部类：
  • 非静态内部类：没用static修饰
  • 静态内部类：用static修饰
• 局部内部类：
• 成员内部类是5大类成员之一；局部内部类和匿名内部类则不是

非静态内部类

• 非静态内部类不用static修饰，属于外部类的对象而不是类本身；非静态内部类寄生在一个外部类对象上；在外部类外部创建内部类的对象时，要先创建外部类的对象
• 内部类可以访问所在外部类的任意成员，即使是private修饰的，因为非静态内部类对象里保存了它所寄生的外部类的对象的引用。也就是说有了非静态内部类的对象，那么必定有它的外部类的对象
• 外部类不能直接访问内部类成员，必须创建对象
• 外部类的静态成员不能访问非静态内部类，包括其变量、创建实例等
• 非静态内部类不能拥有静态成员：？为啥
• 非静态类的对象必定寄生在它外部类的对象里，因此内部类才能访问到外部类的私有成员
• 重名变量：外部类的成员变量；内部类的成员变量；内部类的局部变量，见代码：

package testpack;
public class Test1{
    public static void main(String[] args) {
    	A a=new A();
    	a.show();
    }
}
class A{
	private String str="外部类的成员变量";
	class B{
		public String str="内部类的成员变量";
		public void show(){
			String str="内部类的局部变量";
			System.out.println(str);         //局部变量依次覆盖前面的成员变量
			System.out.println(this.str);    //通过this.变量名访问
			System.out.println(A.this.str);  //通过外部类名.this.变量名访问
		}
	}
	public void show(){
		new B().show();
	}
}

静态内部类

• 静态内部类用static修饰
• 静态内部类属于类，非静态内部类属于外部类的对象
• 静态内部类可以包含静态和非静态成员，可以访问外部类的静态成员，但不能访问非静态成员
• 可以在外部类的所有方法、初始化块中创建静态内部类的对象
• 外部类得通过静态内部类的类名或者对象调用静态内部类的类成员或者实例成员

接口中定义内部类

• 接口中可以定义内部类，默认public static修饰，所以只能是静态内部类
• 接口中定义内部类一般没啥意义

内部类的使用

• 在外部类中使用内部类
  • 可以在外部类中声明内部类类型的变量、创建内部类的实例
  • 外部类得通过创建内部类的实例才能访问到内部类的成员，包括private成员
  • 静态成员不可使用非静态内部类
  • 可以在外部类中定义内部类继承另一个内部类
• 在外部类的外部使用非静态内部类
  • 类的四个访问权限修饰，这时候就起作用了；private修饰的内部类在外部类的外部就访问不了了
  • 定义内部类类型的变量：OuterClass.InnerClass varName
  • 创建内部类的对象：new OuterClass().new InnerClass().也就是说要先创建外部类对象，再调用内部类的构造器创建内部类的对象。内部类的构造器得通过外部类的对象来调用
  • 继承一个内部类：特别注意，因为子类默认要调用父类的构造器，而内部类的构造器要通过外部类对象调用，因此在子类构造器中必须得有外部类的对象，可以将外部类对象作为参数传入子类的构造器

class Outer{
	class Inner{
		Inner(){
			System.out.println("内部类构造器");
		}
	}
}
class subInner extends Outer.Inner{
	subInner(){
		new Outer().super();      //继承内部类，得通过外部类的对象调用内部类的构造器
	}
}

• 在外部类以外使用静态内部类
  • 可以在外部类的外部创建静态内部类的对象：new OuterClass.InnerClass()
  • 因为静态内部类属于类，不需创建外部类的对象来创建内部类对象
  • 继承内部类的情况下，直接用super()即可调用内部类父类的构造器

public class Test1{
    public static void main(String[] args) {
    	subInner sb=new subInner();

    	Outer.Inner oi=new Outer.Inner();
    	oi.show();
    }
}
class Outer{
	static class Inner{
		Inner(){
			System.out.println("内部类无参构造器");
		}
		Inner (String str){
			System.out.println("内部类有参构造器");
		}
		 void show(){
			System.out.println("这是内部类的show()方法");
		}
	}
}
class subInner extends Outer.Inner{
	subInner (){
		super("ABC");  //直接用super()即可调用内部类父类的构造器
	}
}

局部内部类

• 局部内部类比较鸡肋
• 局部内部类定义在一个方法的内部，在方法内部有效
• 不能使用static和访问修饰符

匿名内部类

• 匿名内部类适用于只需要一次使用的类，定义一个匿名内部类时，就会创建一个实例，然后类的定义就消失了，不能重复使用
• 匿名内部类实际上就是一个子类对象，在定义子类的同时创建子类的对象，名字就跟父类或父接口相同
• 用法：
  • 匿名内部类只能实现一个接口，或者继承一个类，当实现一个接口时不能传入参数
  • 匿名内部类不能是抽象类
  • 匿名内部类不能定义构造器，因为这个类就没有名字，可以用初始化块完成构造器完成的初始化工作
  • 多用于创建一个某接口类型的对象，
  • 一般用于简化书写，很少使用，接口或父类中只有一两个方法的时候才适合
  • 调用匿名内部类的方法：直接在定义好之后.方法名()
  • 1.8之后，如果一个局部变量被匿名名内部类访问，那么该变量默认有final修饰，因而不能二次赋值
• 匿名内部类示例：

package testpack;
public class Test1{
    public static void main(String[] args) {
    	ProcessArray pa=new ProcessArray();
    	int[] target={5,35,-2,35,-21};
    	pa.process(target, new Command(){        //匿名内部类实现一个接口Command，不能传入参数
    		public void process(int[] target){
    			int sum=0;
    			for (int tmp:target) {
    				sum+=tmp;
    			}
    			System.out.println("数组元素总和： "+sum);
    		}
    	});
    }
}
interface Command{
	void process(int[] target);
}
class ProcessArray{
	public void process(int[] target,Command cmd){
	cmd.process(target);
	}
}

其他

• 非静态内部类不能拥有静态成员，为啥？
• 创建外部类对象的时候，会先进行类的初始化，内部类会一起执行吗