java的内部类（成员内部类，静态内部类，接口内部类，局部内部类，匿名内部类）

内部类：在一个类中声明另外一个类

 

分类：

1. 成员内部类
2. 静态内部类
3. 接口内部类
4. 局部内部类
5. 匿名内部类

 

应用：
        1. B类的对象只在A类中使用，并且B类对象使用到了A类所有的属性，就可以将B类作为A类的成员内部类。
        2. B类的对象只在A类中使用，并且B类对象使用到了A类静态的属性，就可以将B类作为A类的静态内部类。
        3. 抽象类的子类只创建一次对象，就没必要创建子类，直接使用匿名内部类（new 抽象类）。
        4. 接口的实现类只创建一次对象，就没必要创建实现类，直接使用匿名内部类（new 接口）。

//外部类
public class Outter {

	//1.成员内部类
	class Inner01{
	}
	
	//2.静态内部类
	static class Inner02{
	}
	
	public void method(){
		
		//3.局部内部类
		class Inner03{
		}
		
	}
}

public interface I1 {

	//4.接口内部类
	class Inner{
	}
}

//类的
public class Test01 {
	public static void main(String[] args) {
		//5.匿名内部类
		//创建匿名内部类的对象
		//①底层创建一个匿名类(Test01$1.class)，继承A类，重写method方法
		//②创建匿名子类的对象
		//③赋值给父类的引用（类的多态）
		A a = new A() {
			@Override
			public void method() {
			}
		};
		
		a.method();
		
		
	}
}






//接口的
public class Test01 {
	public static void main(String[] args) {
		
		//创建匿名内部类的对象
		//1.底层创建一个匿名类(Test01$1.class)，实现I1接口，重写method方法
		//2.创建匿名实现类的对象
		//3.赋值给接口的引用（接口的多态）
		I1 i1 = new I1() {
			@Override
			public void method() {
				
			}
		};
		
		i1.method();
	}
}

 
 

成员内部类：

tips:
       1.创建成员内部类对象之前，必须创建外部类对象。
        2.成员内部类可以调用外部类所有的属性。
        3.在成员内部类中调用指定的外部类属性：外部类.this.属性。

//外部类
public class Outter {
	
	private 		String str1 = "外部类私有属性1";
					String str2 = "外部类默认属性2";
	protected 		String str3 = "外部类保护属性3";
	public 			String str4 = "外部类公有属性4";
	final 			String str5 = "外部类属性5（final）";
	static 			String str6 = "外部类属性6(static)";
	static final 	String str7 = "外部类属性7(static fina)";

	//成员内部类
	class Inner{
		
		String str1 = "内部类的属性";
		
		public void innerMethod(){
			System.out.println("成员内部类的方法");
            //成员内部类可以调用外部类所有的属性。
			System.out.println(str1);//this.str1
            //在成员内部类中调用指定的外部类属性：外部类.this.属性。
			System.out.println(Outter.this.str1);
			System.out.println(str2);//Outter.this.str2
			System.out.println(str3);//Outter.this.str3
			System.out.println(str4);//Outter.this.str4
			System.out.println(str5);//Outter.this.str5
			System.out.println(str6);//Outter.str6
			System.out.println(str7);//Outter.str7
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
        //创建成员内部类对象之前，必须创建外部类对象。
		//创建成员内部类的对象
		Inner inner = new Outter().new Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

 
 

静态内部类：

tips:
       1.创建静态内部类对象，不用创建外部类对象。
       2.静态内部类只能调用外部类静态的属性。

//外部类
public class Outter {
	
	static 			String str1 = "外部类属性1（static）";
	static final 	String str2 = "外部类属性2（static final）";
    public 			String str3 = "外部类公有属性3";

	//静态内部类
	static class Inner{
		
		public void innerMethod(){
            //静态内部类只能调用外部类静态的属性。
			System.out.println(str1);//Outter.str1
			System.out.println(str2);//Outter.str2
            //System.out.println(str3);//非法
		}
	}
	
}



public class Test01 {
	public static void main(String[] args) {
		//创建静态内部类对象，不用创建外部类对象。
		//创建静态内部类的对象
		 Inner inner = new Outter.Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

 

 

接口内部类：

tips:
        1.接口内部类的使用方式和静态内部类一致。
        2.默认使用public static修饰。

//外部接口
public interface Outter {
	
	//接口内部类，默认使用public static修饰
	class Inner{
		
		public void innerMethod(){
			System.out.println("接口内部类的方法");
		}
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建静态内部类的对象
		 Inner inner = new Outter.Inner();
		
		//调用方法
		inner.innerMethod();
	}
}

 

局部内部类：

tips:
       1.局部内部类不能使用访问修饰符。
       2.局部内部类的作用域就在外部类方法中。

//外部类
public class Outter {
	
	public void method(){
		
		//局部内部类，不能使用访问修饰符。
        //局部内部类的作用域就在外部类方法中。
		class Inner{
			
			public void innerMethod(){
				System.out.println("局部内部类的方法");
			}
		}
		
		
		//创建局部内部类对象
		Inner inner = new Inner();
		
		
		//调用方法
		inner.innerMethod();
		
	}
	
}

public class Test01 {
	public static void main(String[] args) {
		
		//创建外部类对象（外部类中已经创建内部类对象）。
		Outter outter = new Outter();
		
		outter.method();
	}
}

面试题：
 
局部内部类使用到外部类的局部变量时，为什么局部变量会变为常量?
       局部变量变成常量，是让该变量的生命周期变长，是的方法以外还能找的到该数据， 如果该变量时局部变量，方法执行完毕就直接被回收，在方法就不能使用该数据。

 

匿名内部类：

package com.qf.outter_inner_07;
//类的
public class Test01 {    public static void main(String[] args) {        //5.匿名内部类        
    //创建匿名内部类的对象        
    //①底层创建一个匿名类(Test01$1.class)，继承A类，重写method方法        
    //②创建匿名子类的对象        
    //③赋值给父类的引用（类的多态）        
    A a = new A() {            
        @Override            
        public void method() {
        }        
    };                
    a.method();
}}
    //接口的
    public class Test01 {    
        public static void main(String[] args) {                
            //创建匿名内部类的对象       
            //1.底层创建一个匿名类(Test01$1.class)，实现I1接口，重写method方法        
            //2.创建匿名实现类的对象        
            //3.赋值给接口的引用（接口的多态）        
            I1 i1 = new I1() {            
                @Override           
                public void method() {
                }        
            };                
            i1.method();
        }}