java 可以内联汇编吗

Java里面有种类叫做内部类。在Java里面有四种内部类分别是匿名内部类，静态内部类，成员内部类，局部内部类。今天就来说说这几个内部类。

（1）匿名内部类：说白了就是把接口的实现写在方法的调用里面，而这个匿名的类就是接口的实现，而不是单独写出来。

这段代码，是把接口的实现单独写出来，没有用到匿名内部类：

public class Test {
	//静态方法
	public static void test(CustomerServcie cs){
		cs.logout();
	}
	
	//入口
	public static void main(String[] args) {
		test(new CustomerServiceImpl());
	}
}

//接口
interface CustomerServcie{
	void logout();
}

//编写一个类去继承去实现这个接口
class CustomerServiceImpl implements CustomerServcie{
	public void logout(){
		System.out.println("系统已经安全退出了!!!");
	}
}

这段代码是使用了匿名内部类的：

public class Test02 {
	//静态方法
		public static void test(CustomerServcies cs){
			cs.logout();
		}
		
		//入口
		public static void main(String[] args) {
//			test(new CustomerServicesImpl());
			//使用匿名内部类的方式执行test方法
			//整个这个”new CustomerServcies(){}“就是一匿名个内部类
			test(new CustomerServcies() {
				public void logout() {
					System.out.println("系统已经安全退出了!!!");
				}
			});
			
		}
}

//接口
interface CustomerServcies{
	void logout();
}

匿名内部类的优缺点：

优点：少定义一个类

缺点：缺点：不能重复使用

（2）成员内部类：成员内部类可以等同的看作成员变量

代码如下：

public class OutClass {
	//静态变量
	private static String s1 = "A";
	
	//成员变量
	private String s2 = "B";
	
	//静态方法
	private static void m1(){
		System.out.println("static'm1 method execute");
	}
	
	//成员方法
	private void m2(){
		System.out.println("m2 method execute");
	}
	
	//静态内部类
	//可以用访问权限的修饰符来修饰
	static class InnerClass{
		//定义静态方法
		public static void m3(){
			System.out.println(s1);
			m1();
			
			//System.out.println(s2);
			//m2();不允许的
		}
		
		public void m4(){
			System.out.println(s1);
			m1();
			
//			System.out.println(s2);
//			m2();
		}
	}
	
	public static void main(String[] args) {
		OutClass.InnerClass.m3();
		
		//想让m4执行
		InnerClass inner = new OutClass.InnerClass();
		inner.m4();
	}
}

成员内部类的作用：可以访问外部类中私有的数据。

（3）静态内部类：<1>.成员内部类可以等同的看做成员变量。<2>.成员内部类中不能有静态方法。<3>成员可以访问外部类中所有的数据

代码如下：

public class OuterClass {
	//静态变量
	private static String s1 = "A";
	
	//成员变量
	private String s2 = "B";
	
	//静态方法
	private static void m1(){
		System.out.println("static'm1 method execute");
	}
	
	//成员方法
	private void m2(){
		System.out.println("m2 method execute");
	}
	
	//成员内部类
	//可以用访问权限的修饰符来修饰
	class InnerClass{
		//成员内部类中不能定义静态方法
//		public static void m3(){
//			System.out.println(s1);
//			m1();
//			
//			//System.out.println(s2);
//			//m2();不允许的
//		}
		
		public void m4(){
			System.out.println(s1);
			m1();
			
			System.out.println(s2);
			m2();
		}
	}
	public static void main(String[] args) {
		//创建外部类的对象
		OuterClass out = new OuterClass();
		InnerClass inner = out.new InnerClass();
		inner.m4();//可以跑
	}
}

静态内部类可以直接访问外部类的静态数据，无法直接访问成员。

局部内部类：<1>局部内部类等同于局部变量。<2>局部内部类在访问局部变量的时候，局部变量必须使用final修饰

public class OuterClass {
	public void m1(){
		//局部变量
		final int i = 10;
		 
		//局部内部类
		//局部内部类不能用访问控制权限修饰符修饰
		//该类只在m1()方法里面有效	
		class InnerClass{
			//内部类中不能有静态声明
//			public static void m(){
//				
//			}
			
			//成员方法
			public void m2(){
				System.out.println(i);
			}
		}
		
		//调用m2()方法
		InnerClass inner = new InnerClass();
		inner.m2();
	}
	
	//入口
	public static void main(String[] args) {
		OuterClass out = new OuterClass();
		out.m1();
	}
}