Java中内部类

内部类的规则：

1.内部类能够直接訪问外部类中的成员，包含私有。

          之所以能够直接訪问外部类中的成员，是由于内部类中持有一个外部类的引用，格式：外部类名.this

2.外部类要訪问内部类。必须建立内部类对象

訪问格式：

1.当内部类定义在外部类的成员位置了，并且非私有，能够在外部其他类中。

能够直接建立内部类对象。

格式：

         外部类类名.内部类名  变量名= new 外部类对象.new 内部类对象。

          Outer.inner out = new Outer().new inner();

2.当内部类在成员位置上，就能够被成员修饰符所修饰。

比方private：将内部类在外部类中进行封装。

        static:内部类就具备了static的特性。

        当内部类被static 修饰后。仅仅能訪问外部类中的static成员。

出现了訪问局限。

      

在外部其他类中,怎样訪问static内部类的非静态成员：

       new Outer2.inner().funciton();

 在外部其他类中,怎样訪问static内部类的静态成员：

        Outer2.inner.funciton();

注意：当内部类中的定义了static成员,该内部类必须是静态的。

          当外部类中的静态方法訪问内部类时。内部类也必须是静态的。

当描写叙述事物时，事物的内部还有事物。该事物用内部类来描写叙述

 由于内部事务在使用外部使用的内容。

class Body{

      private class XinZang //心脏不正确外暴露

       {

       }

       public void show()

       {

             new XinZang();

       }

}

定义内部类主要为了訪问外部类的数据

成员内部类代码：

package com.heima.io;

class Outer {
	private int i = 3;

	class inner {
		private int i = 4;
		// 内部类能够定义为私有,由于他是外部类的成员
		void funciton() {
			System.out.println(Outer.this.i);
		}
	}
}

public class InnerClassDemo {
	public static void main(String[] args) {
		// 直接訪问内部类中的成员
		Outer.inner out = new Outer().new inner();
		out.funciton();
	}
}

静态内部内代码：

package com.heima.inner;

import com.heima.inner.Outer.inner;

class Outer2 {
	private static int i = 3;

	static class inner {

		// 在静态内部中，无法訪问外部类非static数据
		static void funciton() {

			System.out.println("inner:" + " " + i);
		}
	}
}

public class InnerClassDemo2 {
	public static void main(String[] args) {
		Outer2.inner.funciton();
	}
}

局部内部类：

内部类定义在局部时。

1.不能够被成员修饰符修饰

2.能够直接訪问外部类中的成员，由于还持有外部类中的引用。

      可是不能够訪问訪问它所在的局部中(方法中)的变量。仅仅能訪问被final修饰的局部变量。

package com.heima.inner;

/**
 * 局部内部类
 * 
 * @author zp
 * 
 */
class Outer3 {
	int i = 5;

	void method(final int a) {
		
		//final int i=3;//局部内部类中訪问局部变量，须要被声明终于类型
		class Inner {
			int i=4;
			void funtion() {
				System.out.println(a);//4
			}
		}
		new Inner().funtion();

	}
}

public class InnerClassDemo3 {
	public static void main(String[] args) {
		 Outer3 out = new Outer3();
		 out.method(7);
		 out.method(8);
	}
}

匿名内部类：

1.匿名内部类事实上就是内部类简写格式。

2.定义匿名内部类的前提：

           内部类必须继承一个类或者实现一个接口。

3.匿名内部类的格式： new 父类 或者 接口（）{定义子类的内容}.

4.事实上匿名内部类就是一个匿名子类对象。

并且有点胖。能够理解为带内容的对象，匿名对象对方法仅仅能调用一次。

5.匿名内部类中定义的方法最好不要超过3个。

匿名内部类代码：

package com.heima.inner;

/**
 * 匿名内部类
 * 
 * @author
 * 
 */
abstract class AbsDemo {
	abstract void show();

}

class Outer4 {

	public void function() {

		final int a = 3;//匿名内部类中訪问局部变量须要加入修饰符final
		new AbsDemo() {// 匿名实现类，AbsDemo的子类对象

			@Override
			void show() {
				System.out.println("show()" + a);
			}

			void abc() {
				System.out.println("abc()");
			}
		}.show();

	}
}

public class InnerClassDemo4 {
	public static void main(String[] args) {
		new Outer4().function();

	}
}

package com.heima.inner;

interface Inter {
	public void method();
}

class Test {
	public static Inter function() {
		return new Inter() {

			@Override
			public void method() {
				System.out.println("avcs");

			}
		};

	}
}

public class InnerClassDemo5 {
	public static void main(String[] args) {
		// Test.function():Test类中有一个静态的方法叫做function(),
		// function这种方法运算结果后返回的是一个对象

		Test.function().method();
		new Object() {//创建一个Object子类 假设Object obj =new Object(){};这样写是错的。由于Object没有show()；
			public void show() {
				System.out.println("abc");
			}
		}.show();
	}
}