关于java内部类的一些总结

拼搏现实的明天。 2022-03-18 14:30 322阅读 0赞

> 1.  成员内部类
> 2.  局部内部类
> 3.  静态内部类
> 4.  内部类的继承

###  成员内部类 ###

> 成员内部类的语法如下：
> 
> public  class OuterClass\{         //外部类
> 
>     private  class InnerClass\{    // 内部类
> 
>     \}
> 
> \}

>  在内部类中可以随意使用外部类的成员，尽管外部类的成员被修饰为private  在内部类的可以直接调用外部类的成员。
> 
> 内部的实例一定要绑定到外部的实例上，如果从外部类中初始化一个内部类  那么就可以绑定了   内部类 实例也是通过new关键字。

public class OutClass{
    
      InnerClass innerClass = new InnerClass();  // 将内部类的实例绑定在外部类
      
      public void ouf(){ // 外部类的方法
      
      }
    
      class InnerClass { // 内部类
          InnerClass() { // 内部类的构造方法
               
          }
    
          public void ouf(){   // 普通方法
      
          }
          int y = 0;           // 内部类的成员变量
      }
    
      public InnerClass doit(){
          in.y = 4
          return new InnerClass();
      }
      public static void main(String[] args) {
          OutClass outClass = new OutClass();  // 外部类实例化
          // 内部类的对象实例化必须在外部类或者外部类的非静态方法上实现
          OutClass.InnerClass = outClass.doit();
      }
    
    }

**以上程序得出：**

> 1.   内部类可以方法外部类的成员，但是内部类的成员只有在内部类的范围是可使用的  不能被外部类使用
> 2.  如果在外部类和非静态的之外的方法实例化内部类   需要使用外部类  内部类的形式指定该对象的类型

如果说 不使用外部类调用doit（）方法的返回内部类的对象引用   也可以直接使用内部类    由于在主方法中实例内部类对象  必须要在new操作符之前提供一个外部类的引用

public static void main(String[] args) {
    	OutClass outClass = new OutClass();
            OutClass.inNerClass = outClass.doit();
            OutClass.inNerClass in = outClass.new InNerClass(); //实例化内部对象
    }

在实例化内部类的对象中  不能再new操作符之前通过外部类名称实例化内部类对象  而是通过外部类对象来创建其内部的对象

> 内部类对象会依赖外部类对象  除非已经存在一个外部类对象  否则类中不会出现内部类对象

### 局部内部类  ###

public class OutClass3 {
    	public OutInterface2 doit(final String x) {  //doit()方法参数为final类型的
    		// 在doit()方法中定义一个内部类
    		class InnerClass2 implements OutInterface2{
    			InnerClass2(String s){
    				s = x; 
    				System.out.println(s);
    			}
    		}
    		return new InnerClass2("doit");
    	}
    
    }
    interface OutInterface2 {  // 定义个接口
    	
    }

> 内部类被定义在doit()中  外部是不可以访问的 但是内部类可以访问当前的常量 以及外部类的所有成员变量

**疑问 ：为什么doit的参数要为final类型的  **

> 这是因为在方法中的内部类只能访问final的局部变量，因为在方法中的变量  它的作用域相当于一个常量  如果说超出了生命周期，由于局部变量为final类型的，所以不能在内部类中改变局部变量的值

###  静态内部类 ###

public class StaticInnerClass3 {
    	int x = 100;
    	static class Inner {
    		void doitInner() {
    			System.out.println("外部类" + x); // 调用外部类的成员变量
    		}
    	}
    }

> 在内部类中加上static，这个内部类就变为静态内部类了。在非静态内部类中不可声明静态成员，静态内部类最大的特点，就是不可以使用外部类的非静态成员。
> 
> 1.  创建静态内部类的对象 ，不需要其外部类的对象
> 2.  不能从静态内部类访问非静态外部类的的对象。

###  内部类的继承 ###

public class OutputInnerClass extends ClassA.ClassB { // 继承内部类ClassB
    	public OutputInnerClass(ClassA a) {
    		a.super();
    	}
    }
    class ClassA {
    	class ClassB {
    	}
    }

> 内部类继承有特殊的语法：
> 
> **某个类继承内部类，必须要强制的给予这个类一个带参数的构造方法，并且当前参数为内部类的外部类引用，同时在构造方法使用a.super(),这样才可以继承提供了必要的对象引用**

以上是对内部类的总结  ：欢迎大佬们来讨论