基础--java内部类学习

一、内部类

把一个类的定义放在另一个类中，这个类就是内部类。

二、内部类分类

1、成员内部类(最常见的内部类，内部类的定义与类成员平级)
2、局部内部类( 局部内部类，是指内部类定义在方法和作用域内)
3、匿名类
4、静态内部类
5、接口内部类

三、使用方法

1、内部类直接在类的内部进行声明。可以声明为private、protected、public或者默认访问权限，这个访问权限约定和外部类完全一样。

2、内部类自动拥有对其外围类所有成员（方法、属性）的访问权。如果内部类和外部类成员的名字完全相同，在内部类方法中要访问外部类成员，则需要使用下面的方式来访问： 外部类名.this.外部成员名，例如Outer.this.i++;  （看例子）

3、必须使用外部类对象来创建内部类对象，而不是直接去new一个。

格式为： 外部对象名.new 内部类构造方法

比如要创建一个内部类iner对象，需要这么做：

        Outer outer = new Outer();
        Outer.Inner iner = outer.new Inner();

四、举例

1、成员内部类

public class OutClass {

	private int value=0;
	public static void main(String[] args) {
		OutClass oc = new OutClass();
		Inner in = oc.new Inner();
		in.display();
		
		Inner in2 = oc.getInnerClass();
		in2.display();
	}

	public Inner getInnerClass(){
		return new Inner();
	}
	
	public class Inner{
		
		public Inner(){
			this.value = OutClass.this.value;
		}
		
		private int value;

		public int getValue() {
			return value;
		}

		public void setValue(int value) {
			this.value = value;
		}
		
		public void display(){
			System.out.println("value="+this.value);
		}
	}
}

2、局部内部类

interface innerface{
	public void display();
}

public class OutClass {

	private int value=123;
	public static void main(String[] args) {
		OutClass oc = new OutClass();
		innerface in = oc.test();
//		Inner in = oc.test(); //编译不通过，因为Inner在方法内部，方法体外不能使用，必须返回接口
		in.display();
	}

	public innerface test(){
		class Inner implements innerface{
			
			public Inner(){
				this.value = OutClass.this.value;
			}
			
			private int value;

			
			@Override
			public void display(){
				System.out.println("value="+this.value);
			}
		}
		return new Inner();
	}
	
}

再看另外一种：

public class OutClass {

	private int value=123;
	public static void main(String[] args) {
		OutClass oc = new OutClass();
		oc.test();
	}

	public void test(){
		if(Boolean.TRUE){
			class Inner{
				
				public Inner(){
					this.value = OutClass.this.value;
				}
				
				private int value;

				public void display(){
					System.out.println("value="+this.value);
				}
			}
			Inner in = new Inner();
			in.display();
		}
		
	}
	
}

3、匿名内部类

匿名内部类是不能加访问修饰符的

interface innerface{
	public void display();
}

public class OutClass {
	private int value=123;
	private static int v = 456;
	public OutClass(){
		System.out.println("Out create");
	}
	public static void main(String[] args){
		OutClass out = new OutClass();
		out.test();
	}
	private void test(){
		new innerface(){
			@Override
			public void display() {
				System.out.println("OK");
			}
		}.display();
	}
}

4、静态内部类

就是修饰为static的内部类。

a.和普通的内部类还有一个区别：普通内部类不能有static数据和static属性

b.静态内部类是static class型的内部类，这种内部类特点是：它不能访问外部类的非静态成员。要创建静态内部类对象时候，也不需要外部类对象了，直接可以：new 外部类名.内部类构造方法

public class OutClass {
	private int value=123;
	private static int v = 456;
	public OutClass(){
		System.out.println("Out create");
	}
	public static void main(String[] args) {
		Inner inner = new OutClass.Inner();
		inner.display();
	}
	public static class Inner{
		public Inner(){
			this.value = OutClass.v;//无法访问非静态的成员
			System.out.println("Inner create");
		}
		private int value;
		public void display(){
			System.out.println("value="+this.value);
		}
	}
}

5、接口内部类

接口内部类自动都是public static的，相当于为接口定义了一种变量类型，这在java的设计中就有使用，比如在HashMap中，就有：

static class Entry<K,V> implements Map.Entry<K,V>

interface innerface{
	public void display();
	class innerClass{ //默认是public static
		public void mark(){
			System.out.println("test");
		}
	}
}

public class OutClass {
	public OutClass(){
		System.out.println("Out create");
	}
	public static void main(String[] args){
		innerface.innerClass inner = new innerface.innerClass();
		inner.mark();
	}
}

还有其他部分，比如内部类的嵌套和继承，就不做介绍了。用的不多吧。

内部类最明显的好处就是实现了java的短板，不能多继承，而内部类可以变通的做到。