Java--四大内部类介绍及代码实现

内部类

1.成员内部类

2.局部内部类

3.静态内部类

4.匿名内部类

代码理解

      package com.justin.innerclass;
      public class OuterClass {
     	private int x = 0;
     	private static int y = 2;
     	// 1.成员内部类：
     	// （1）顾名思义，定义在一个类的内部
     	// （2）可以访问外部类的所有的属性（变量）和方法，包括static变量和方法。
     	// （3）成员内部类不能定义静态属性和方法。（static相关的加载顺序是：类->static变量->static代码块->成员变量->成员方法。）
     	// （4）实例化成员内部类，必须先创建外部类的实例化对象。
     	class MInnerClass {
     		private int x = 1;
     		public void show() {
      			System.out.println("成员内部类");
      			System.out.println("x=" + x + ",y=" + y);
      		}
      	}
     	// 2.局部内部类：
     	// （1）定义在一个类当中的某个方法或作用域内。
     	// （2）和成员内部类的区别是成员内部类仅限于方法或作用域内访问。
     	// （3）局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的，并且只能访问final变量。
     	public void show(final int a) {
     		class PartInnerClass {
     			private int x = 2;
     			public void show() {
      				System.out.println("局部内部类");
      				System.out.println("a=" + a);
      			}
      		}
     		//只能在方法内部实例化
      		PartInnerClass	pInnerClass = new PartInnerClass();
      		pInnerClass.show();
      	}
     	// 3.静态内部类：
     	// （1）和成员内部类一样定义在类的内部，但是使用static关键字修饰。
     	// （2）不能访问外部类的普通属性和方法。
     	static class StaticInnerClass {
     		private int x = 3;
     		public void show() {
      			System.out.println("静态内部类");
      		}
      	}
     	// 4.匿名内部类
     	// （1）继承父类或实现接口并重写父类或接口的方法，会产生一个实例化对象。
             // （2）并且只能访问final变量。
             // 匿名内部类创建线程的两种方法：
     	// 一、继承Thread类
      	Thread t1 = new Thread() {
     		@Override
     		public void run() {
     			for (int i = 0; i < 10; i++) {
      				System.out.println(Thread.currentThread().getName() + "--" + i);
      			}
      		}
      	};
     	// 二、实现Runable接口
      	Thread t2 = new Thread(new Runnable() {
     		@Override
     		public void run() {
     			for (int i = 0; i < 10; i++) {
      				System.out.println(Thread.currentThread().getName() + "--" + i);
      			}
      		}
      	});
     	public static void main(String[] args) {
      		OuterClass outerClass = new OuterClass();
     		// 成员内部类
      		OuterClass.MInnerClass mInnerClass = new OuterClass().new MInnerClass();
      		mInnerClass.show();
     		// 静态内部类
      		OuterClass.StaticInnerClass sInnerClass = new OuterClass.StaticInnerClass();
      		sInnerClass.show();
     		// 匿名内部类
      		outerClass.t1.run();
     		//
      		outerClass.show(777);
      		test(666);
      	}
     	public static void test(final int a) {
     		new Thread() {
     			@Override
     			public void run() {
     				// TODO Auto-generated method stub
      				System.out.println(a);
      			}
      		}.start();
      	}
      }
  
 

PS>>>static加载顺序

类->static变量->static代码块->普通变量->普通方法。

因此可知，成员内部类不能定义静态属性和方法，成员内部类就好比一个普通变量或方法，如果在内部定义static静态变量或方法，还没加载到内部类，就加载内部类的static变量了，java编译器编译的时候是会报错的。其他类似情况同理。

文章来源: blog.csdn.net，作者：吾日三省贾斯汀，版权归原作者所有，如需转载，请联系作者。

原文链接：blog.csdn.net/JustinQin/article/details/77835883