Java学习笔记-内部类

内部类在Android中有着大量的运用

内部类

内部类提供了更好的封装；内部类可以直接访问外部类的私有数据；匿名内部类适合那些只需要使用一次的类。非静态内部类不能拥有静态成员。内部类比外部类可以多使用三个修饰符：private、protected、static

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）

访问特点：

内部类可以直接访问外部类中的成员，包括私有成员
而外部类要访问内部类中的成员必须要建立内部类的对象

内部类的位置

内部类定义在成员位置上

可以被private static成员修饰符修饰
被static修饰的内部类只能访问外部类中的静态成员

内部类定义在局部位置上

也可以直接访问外部类中的成员
同时可以访问所在局部中的局部变量，但必须是被final修饰

非静态内部类

成员内部类是类的成员而局部内部类和匿名内部类则不是
使用ClassName.this.Xxx来调用外部类的重名变量
内部类可以访问外部类的private变量，反之则不行。如果外部类要访问内部类的成员话，则必须显式创建非静态内部类对象来调用访问其实例成员
不允许在非静态内部内定义静态成员
外部类名.内部类名变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();

class Outer {

	private int x = 3;

	class Inner {
        int x = 4;
		void function() {
            int x = 5;
			System.out.println("outer x: " + Outer.this.x);
		}
	}
}

静态内部类

用static修饰的内部类，属于类本身
可以包含静态成员也可以包含非静态成员
静态内部类不能访问外部类的实例成员只能访问外部类的类成员。即使是静态内部类的实例方法也不能够访问外部类的实例成员
外部类访问内部类的类成员可以使用类名调用，而实例成员可以通过实例调用
当内部类中定义了静态成员，该内部类必须是static的
new Outer.Inner().function();

class Outer {

	private static  int x = 3;
	
    static class Inner {//静态内部类
		static void function(){
			System.out.println("innner :"+x);
		}
	}
}

内部类的使用

接口内定义的内部类都为public static修饰的

内部类的使用：

在外部类中使用内部类

在外部类中以外使用非静态内部类

此时内部类不可使用private修饰
OuterClass.InnerClass varName
OuterInstance.new InnerConstructor()

class Out{
	class In{
		public In (String s){···}
	}
}
···
Out.In in = new Out().new In("test");
//等价于
Out.in in;
Out out = new Out();
in = out.new In("test");
···

非静态内部类的构造器必须使用外部对象来调用。

public class SubClass extends Out.In{
	//显示定义SubClass的构造器
	public SubClass ( Out out ){
		//通过传入的Out对象显式调用In的构造器
		out.super("hello");
	}
}

在外部类以外使用静态内部类

new OuterClass.InnerConstructor()

class StaticOut{
	static class StaticIn{
		public StaticIn(){···}
	}
}
···
StaticOut.StaticIn in = new StaticOut.StaticIn();
//等价于
StaticOut.StaticIn in;
in = new StaticOut.StaticIn();

局部内部类

若一个类存在于方法体中，则这个类称之为局部内部类，仅在该方法内有效。局部内部类不能在外部类的方法以外的地方使用，因此不能够使用static修饰

class Outer {

	int x = 3;

	void method(final int a) {
		final int y = 4;
		class Inner {
			void function() {
				System.out.println(y);
			}
		}
		new Inner().function();
	}
}

class Test {

	public static void main(String[] args) {
		Outer out = new Outer();
		out.method(7); //当此语句执行完毕，释放内存
		out.method(8); 
	}
}

匿名内部类

就是内部类的简化写法

前提：

内部类可以继承或实现一个外部类或者接口

格式为：

new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内)}

简单理解：

就是建立一个建立一个带内容的外部类或者接口的子类匿名对象

匿名内部类其实就是内部类的简写格式
定义匿名内部类的前提：内部类必须是继承一个类或者实现接口
匿名内部类的格式：new 父类或者接口(){定义子类的内容}
其实匿名内部类就是一个匿名子类对象。可以理解为带内容的对象
匿名内部类中定义的方法最好不要超过3个

abstract class AbsDemo {
	abstract void show();
}

class Outer {
	int x = 3;
	public void function() {
		new AbsDemo() {
			int num = 9;
			void show() {
				System.out.println("num = " + num);
			}
			void abc() {
				System.out.println("增加的方法");
			}
		}.show();
	}
}

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

匿名内部类的应用

interface Inter {
	void method();
}

class Test 
{
	//补足代码。通过匿名内部类。
	/*
	static class Inner implements Inter {
		public void method() {
			System.out.println("method run");
		}
	}
	*/

	static Inter function() {
		return new Inter() {
			public void method() {
				System.out.println("method run");
			}
		};
	}
}

class InnerClassTest {
	public static void main(String[] args) {

		//Test.function():Test类中有一个静态的方法function
		//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象
		//因为只有是Inter类型的对象，才可以调用method方法
		Test.function().method();
		show(new Inter(){
			public void method() {
				System.out.println("method show run");
			}
		});
	}

	public static void show(Inter in) {
		in.method();
	}
}

没有父类及接口如何使用匿名内部类

class InnerTest {
    public static void main(String[] args) {
		new Object() {
			public void function() {
				//方法主体
			}
		}.function();
	}
}

Java8改进的匿名内部类

匿名内部类适合只使用一次的类，其定义格式为：

new 实现接口() | 父类构造器(实参列表){
	//匿名内部类的类体部分
}

匿名内部类不能是抽象类，因为在创建匿名内部类的同时会创建对象
匿名内部类不能定义构造器。由于匿名内部类没有类名，但却可以使用初始化块
最常用的创建匿名内部类的方式是需要创建某个接口类型对象

interface Product{
	public double getPrice();
	public String getName();
}
public class AnonymousTest{
	public void test ( Person p ){
		System.out.println( "" + p.getName() + p.getPrice());
	}
	public static void main(String[] args){
		AnonymousTest ta = new AnonymousTest();
		ta.test(new Product(){
			public double getPrice(){
				return 123.4;
			}
			public String getName(){
				return "书本";
			}
		});
	}
}

class AnonymousProduct implements Product{
	public double getPrice(){
		return 123.4;
	}
	public String getName(){
		return "书本";
	}
}
ta.test ( new AnonymousProduct());

在Java8以前，Java要求被局部内部类、匿名内部类访问的局部变量必须使用final修饰，从Java8开始这个限制被取消了：如果局部变量被匿名内部类访问，那么该局部变量相当于自动使用了final修饰