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