Java中内部类的学习

类中定义类，即内部类----------当类中的成员也是另一个事物时，可以把这个事物定义为内部类。

成员内部类

​ 当内部类作为外部类的成员时，就是成员内部类。

特点：
成员内部类即使类又是成员，所以它可以由成员修饰符来修饰如：public，private；也可以继承、实现。

​使用范围：

1. 成员内部类可以使用外部类中的内容（并列于成员）成员变量中不允许定义静态内容，除了静态的常量

2. 外部类不能直接调用内部类的内容，需要通过内部类的对象调用内部类内容

3. 其他类如果要调用某一内部类，需要先通过对象调用内部类的外部类，再由外部类的对象调用内部类。

public class Outer01{
//成员内部类
    int haha=1;
	int hehe=123;
	public class Inner{
		int haha=2;
		public void way(){
			int haha=3;
			System.out.println(hehe); //内部类调用外部类的数据
			System.out.println(haha); //内部类调用最近的haha
			System.out.println(this.haha);//内部类调用内部类对象的haha
			System.out.println(Outer01.this.haha);//内部类调用外部类对象的haha
		}
	public void outer(){        //外部类调用成员内部类中的数据
		Inner inner = new Inner();
		System.out.println(inner.haha);
	}
	}
}
//其他类调用内部类中的内容。先用外部类对象，调用外部类成员
public class Test {
	public static void main(String[] args) {
		Outer01 outer= new Outer01();
		Outer01.Inner  inner  = outer.new Inner();
		System.out.println(inner.haha);
		inner.way();
	}
}

静态内部类

适用范围：

1. 私有内部类中可以使用外部类中的私有内容
2. 外部类中可以使用私有内部类中的私有内容，但是需要通过内部类对象使用。
3. 私有的内部类只能在外部类中使用，其它类中无法使用。

public class Outer002 {
	private class Inner01{
		private int haha=10;
		private void way(){
			System.out.println("私有内部类中的方法");
			way1();   //私有内部类可以使用外部类中的私有内容
		}
		
	}
	//外部类中的私有内容
	private void way1(){
		System.out.println("外部类中的方法");
	}
	private void use1(){
		Inner01 in =new Inner01();  //外部类调用内部类中的内容，需要通过内部类的对象。
		in.way();   
	}
}
//私有内部类中的内容只能在外部类中使用不能再其它类中使用

私有内部类

静态内部类中可以定义静态内容,其他内部类只能定义静态常量

​适用范围：

1. 静态内部类中的静态方法，只能调用外部类和内部类中的静态内容；对于外部类和内部类中的非静态内容只能通过相应的类对象来调用。
2. 静态内部类中的非静态方法，可以调用内部类中的静态与非静态内容、外部类中的静态内容；对于外部类中的非静态内容只能通过外部类的对象来调用。
3. 外部类中的方法，可以通过内部类名直接调用内部类中的静态内容；而非静态内容需要内部类的对象来调用

public class Outer003 {
	int a=10;                  //外部类中的成员变量
	static int b=5;            //外部类中的静态成员变量
	public static class Inner{
		int c=15;              //内部类中的非静态成员变量
		static int d=20;        
		//静态内部类中可以定义静态内容,其他内部类只能定义静态常量
		static void way(){     
			System.out.println("静态内部类中的静态方法");
			//静态内部类只能调用静态内容，非静态内容需要通过相应类的对象调用
			System.out.println(new Outer003().a); 
			System.out.println(b);
			System.out.println(new Inner().c);
			System.out.println(d);

		}
		//静态内部类中的成员方法
		public void way1(){
			System.out.println("静态内部类中的成员方法");
			System.out.println(new Outer003().a); //在调用外部类的内容时，需要通过外部类的对象
			System.out.println(b);
			System.out.println(c);
			System.out.println(d);

	}

	}
	public void outer(){
		System.out.println(Inner.d);//外部类中的方法，可以通过内部类名调用内部类中的静态变量
		System.out.println(new Inner().c);
	}
	
}

局部内部类

适用范围：

1. 局部内部类可以调用外部类，其方法中的内容
2. 包含局部内部类的方法可以通过内部类的对象，调用内部类中的内容
3. 方法外，外部类不能带哦用局部内部类

public class Outer004 {
		int a=5;
	//★局部内部类想要使用方法中的参数，该参数的传递必须是final的。在jdk中，fianl可被省略，省略时默认。
    public void way(final int args){
		int b=10;
		class Inner{//★在方法中的类，不能用public、static修饰；可以用final修饰，但该内部类不能被继承。
			int c=15;
			
			public void inner(){
				System.out.println(a); //调用外类中内容
				System.out.println(b); //调用内部类中内容
				System.out.println(c); //调用方法中内容
			}
			
			
		}
		Inner in = new Inner();//在方法中要调用内部类的内容，需要通过内部类的对象来实现
		System.out.println(in.c);

	}
	//外部类不能调用方法内部类。
}

★匿名内部类

在不使用匿名内部类时：

​ 创建demo对象仅仅只是为了实现Smoke接口的功能。

public class Outer005 {
	public static void main(String[] args) {
		Demo demo=new Demo();
        demo.smoke();
}
interface Smoke{
	void smoke();
}
class Demo implements Smoke{
	public void smoke() {
		System.out.println("吐心形烟圈...");
	}

}

使用匿名内部类可以达到同样的作用
1.接口多态

public class Outer005 {
	public static void main(String[] args) {
		Smoke s=new Smoke(){
            public void smoke(){
                System.out.println("具体的实现内容");
            }
        };
        s.smoke();
        
}
interface Smoke{
	void smoke();
}

2.没有引用接收匿名内部类的对象地址,只能在当前行使用以此

public class Outer005 {
	public static void main(String[] args) {
		new Smoke(){  //一个没有名字的实现类的类体,实现了Smoke
			public void smoke() {
				System.out.println("具体的实现内容.");
			}
		}.smoke();
}
interface Smoke{
	void smoke();
}

3.做方法的参数

public class Outer005 {
	public static void main(String[] args) {
		void test(new Somke(){  //一个没有名字的实现类的类体,实现了Smoke
			public void smoke() {
				System.out.println("具体的实现内容.");
			}
		}；)
}
public static text(Smoke smoke){
        smoke.smoke();
}
}
interface Smoke{
	void smoke();
}