Java-20内部类

内部类

概述和特点

内部类：把类定义在其他类的内部，这个类被称为内部类。

内部类访问特点：内部类可以直接访问外部类的成员，包括私有的

外部类想要访问内部类的成员，必须创建对象。

public class Outer {

private int num=10;

class Inner{
	
	private int num=20;
	
	public void show() {
		System.out.println(num);//20
	}
	
}

public void method() {
	
	//show();
	
	Inner inner=new Inner();
	inner.show();
	
}

内部类的划分

成员位置：在成员位置定义的内部类，叫做成员内部类

局部位置：在方法中定义的内部类，叫做局部内部类

public class Outer2 {
	

	//成员位置
	class Inner{
		
	}
	
	
	public void method() {
		
		//局部内部类只能方法中使用
		
		class Inner2{
			
			public void show() {
			   System.out.println("show");	
			}
		}
		
		new Inner2().show();
	}
	
	

}

成员内部类的直接创建

public class OuerDemo {
	
	public static void main(String[] args) {
		
		//Outer outer=new Outer();
		//outer.method();
		
		
		//外部类名.内部类名 对象名=new 外部类对象().new 内部类对象()
		Outer.Inner outer=new Outer().new Inner();
		
	}

}

限制外部直接创建成员内部类

public class Person {
	
	//如果不想外界直接创建成员内部类的对象，我们可以把修饰符变成私有的
	private class Heart{
		
		public void operator() {
			System.out.println("心脏搭桥手术!");
		}
		
	}
	
	public void method() {
		Heart heart=new Heart();
		heart.operator();
	}	

}

静态内部类

静态内部类就是static修饰的内部类，这种内部类的特点是：

1、静态内部类不能直接访问外部类的非静态成员，但，可以通过new外部类().成员的方式访问；

package lulux.neibul;

public class Helloworld {
    String name = "sdas";

    public static class Inner {
        public void show() {
            System.out.println(new Helloworld().name);
        }
    }


    public static void main(String[] args) {
        Inner a = new Inner();
        a.show();
    }
}

如果外部静态成员与内部类的静态成员相同，可以通过“类名.静态成员”来访问外部类的静态成员；如果不同，可以直接调用外部类的静态成员名

package lulux.neibul;

public class Helloworld {
   static String name = "sdas";

    public static class Inner {
       static String name = "sdw12";
        public void show() {
            System.out.println(Helloworld.name);
            System.out.println(name);
        }
    }


    public static void main(String[] args) {
        Inner a = new Inner();
        a.show();
    }
}

方法内部类（局部内部类）

方法内部类就是定义在外部类的方法中，方法内部类只在该方法中可以用；

由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和static修饰符。

//局部内部类为什么访问的局部变量必须是一个常量?
//A:局部内部类局部变量必须加上final修饰
//B:为什么?
//   局部变量随着方法的调用而存在,随着方法的调用完毕而消失
//   而局部内部类需要创建对象，这个对象不会立即消失
//如果把一个变量加上final，其实这个变量就会是一个常量
public class Outer3 {
	
	private int num=3;

	public void method() {
		
		//局部内部类访问局部变量，这个局部变量必须是一个常量
		//但是在jdk1.8中final可以省略不写
		//final int num=2;
		int num=2;
		
		class Inner{
						
			public void show() {
				System.out.println(num);//就近原则
			}
			
		}
		
		Inner inner=new Inner();
		inner.show();
		
	}
	
	public static void main(String[] args) {
		
		Outer3 outer3=new Outer3();
		outer3.method();
		}
}

匿名内部类

匿名内部类

interface Inter{
	
	public void show();
	
}

//class InterImpl implements Inter{
//
//	@Override
//	public void show() {
//		
//		System.out.println("show...");
//		
//	}
//	
//} 


class InterDemo{
	
	//接口作为方法的返回值  返回的是接口的实现类对象
	public Inter method() {
		
		//局部内部类
//		class InterImpl implements Inter{
//
//			@Override
//			public void show() {
//				System.out.println("show...");
//			}
//			
//		}
		
		//匿名内部类
//		Inter inter=new Inter() {
//			
//			@Override
//			public void show() {
//				System.out.println("show ...");
//			}
//		};
		
//		return inter;
		
		return new Inter() {
			
			@Override
			public void show() {
				System.out.println("show...");
			}
		};
	}
	
}

public class InterOuer {
	
	public static void main(String[] args) {
		
		InterDemo interDemo=new InterDemo();
		Inter inter = interDemo.method();
		inter.show();
		
	}
	
}