Java内部类的使用小结
Java内部类的使用小结
☆：为什么要使用内部类：
使用内部类最吸引人的原因是：每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。
内部类：顾名思义就是把类放在某个范围里
类可以放在包中
类可以放在文件夹中
类可以放在类中 //内部类
类可以放在方法中 //内部类
一、成员内部类
类中放置内部类，类里套类，类中类
要使用内部类，就需要在外部类中实例化内部类的对象，然后通过对象打点调用内部类中的方法，通过方法操作内部类数据
内部类可以直接使用外部类的属性和方法，就像孙悟空钻进铁扇公主肚子里
1 public class OuterClass { 2 //外部类中的属性 3 private int outer_1=100; //私有属性 4 public int outer_2=10; //公有属性 5 6 //外部类方法outer_method1 7 public void outer_method1(){ 8 System.out.println("outer_method1"); 9 InnerClass ic=new InnerClass(); 10 //调用内部类中的方法 11 ic.inner_method1(); 12 //调用内部类中的私有属性和公有属性 13 System.out.println(ic.inner_1+" "+ic.inner_2); 14 } 15 16 //有名的内部类InnerClass 17 class InnerClass{ 18 //内部类中的属性 19 private int inner_1=123; //私有属性 20 public int inner_2=321; //公有属性 21 //内部类方法inner_method1 22 public void inner_method1(){ 23 //调用外部类中的方法， 24 outer_method1(); 25 //调用外部类中的私有属性和公有属性 26 System.out.println(outer_1+" "+outer_2); 27 } 28 } 29 }
二、局部内部类
方法中中放置内部类
要使用方法中的内部类，就必须在方法中，内部类定义的下面实例化内部类的对象，然后通过内部类对象打点调用内部类的方法，
内部类的作用域仅限于当前方法，对内部类定义开始到方法结束，作用域消失。
在内部类中可以直接使用外部类中的当前方法中的局部变量，在方法的外面不能使用方法中的内部类
1 /** 2 *方法中放置内部类 3 */ 4 public class OuterClass { 5 //外部类中的属性 6 private int outer_1=100; //私有属性 7 public int outer_2=10; //公有属性 8 //外部类中的方法 9 public void outer_method1(){ 10 System.out.println("outer_method1()"); 11 System.out.println("outer_1"+"outer_2"); 12 13 //方法中的内部类 14 class InnerClass{ 15 //内部类中的属性 16 private int inner_1=123; //私有属性 17 public int inner_2=321; //公有属性 18 //内部类中的公有方法 19 public void inner_method1(){ 20 System.out.println("public method1"); 21 System.out.println(outer_1); 22 } 23 //内部类中的私有 方法 24 private void inner_method2(){ 25 System.out.println("private method2"); 26 System.out.println(outer_1+" "+outer_2); 27 } } 28 //实例化内部类 29 InnerClass ic=new InnerClass(); 30 ic.inner_method1(); 31 ic.inner_method2(); 32 System.out.println(ic.inner_1+" "+ic.inner_2); 33 //作用域到此处结束 34 } 35 }
三、匿名内部类
1. 匿名内部类是没有访问修饰符的。
2.有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字
3.匿名内部类是没有构造方法的。因为它连名字都没有何来构造方法。
4.当前匿名内部类中实现的方法，只能实现一次，如果还想其他的实现，必须用匿名内部类重新new实现
1 public class Demo { 2 public void TetMethod1(){ 3 //匿名内部类 new 的是CommonPerson的子实现，但没有类名，把子实现的对象赋值给长辈引用 4 CommonPerson cp=new CommonPerson(){ 5 @Override 6 public void study() { 7 } 8 @Override 9 public void eat() { 10 } 11 }; 12 } 13 public static void main(String[] args) { 14 //有名内部类 15 class Student implements IPerson{ 16 public void study(){} 17 public void eat(){} 18 } 19 Student stu1=new Student(); 20 IPerson ip=stu1; 21 22 //匿名内部类 23 IPerson ip1=new IPerson(){ 24 public void study(){} 25 public void eat() {} 26 }; 27 IPerson ip2=new IPerson(){ 28 public void study(){} 29 public void eat() {} 30 }; 31 } 32 } 33 34 35 public interface IPerson { //定义的接口IPerson 36 37 public void study(); 38 public void eat(); 39 }
四、嵌套内部类
嵌套内部类分为静态内部类和非静态内部类
1.静态内部类
1、 它的创建不需要依赖于外部类。
2、 它不能使用任何外围类的非static成员变量和方法。
2.非静态内部类
1.它的创建需要依赖于外部类
2.在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围类，可以随便调用外部类中的成员，不管是静态的还是非静态的，相当霸道。
1 public class OuterClass { 2 private String sex; 3 public static String name = "ma"; 4 /** 5 *静态内部类 6 */ 7 static class InnerClass1{ 8 /* 在静态内部类中可以存在静态成员 */ 9 public static String name1 = "1_static"; 10 public void display(){ 11 //静态内部类只能访问外围类的静态成员变量和方法 12 System.out.println("OuterClass name :" + name); 13 } } 14 /** 15 * 非静态内部类 16 */ 17 class InnerClass2{ 18 /* 非静态内部类中不能存在静态成员 */ 19 public String name2 = "2_inner"; 20 /* 非静态内部类中可以调用外围类的任何成员,不管是静态的还是非静态的,这就有点霸道了*/ 21 public void display(){ 22 System.out.println("OuterClass name：" + name); 23 } 24 } 25 public void display(){ 26 // 外部类访问静态内部类 27 System.out.println(InnerClass1.name1); 28 new InnerClass1().display(); 29 /* 非静态内部的创建需要依赖于外部类 */ 30 OuterClass.InnerClass2 inner2=new OuterClass().new InnerClass2(); 31 System.out.println(inner2.name2); 32 inner2.display(); 33 } 34 }
版权声明：本文为MJ1234原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。