Java 内部类总结

雨点打透心脏的1/2处 2022-10-20 12:28 191阅读 0赞

**Java内部类总结**

**一. 定义:**

将一个类定义在另一个类的局部或者成员位置，成为内部类。

**二. 内部类定义规则**

1. 一个内部类的成员不能被static所修饰，如果要被static修饰，那么这个内部类也要用static修饰。

2. 当一个内部类定义在外部类的成员位置上时，就可以被成员修饰符修饰，如private、public、static、final。

3. 内部类定义在局部时(成员方法中)，不可以被成员修饰符修饰，private、public、static，但是可以被final修饰，局部内部类的成员可以被成员修饰修饰(static除外，因为它一旦声明为static，意味着它所在的内部类也要修饰成static，但是局部内部类不用成员修饰符修饰)

**三. 内部类的访问规则**

1. 一个非静态内部类(其成员绝对不能是静态)，可以访问外部类的任何成员。

而它的外层类的方法则需要通过new 内部类的对象方式进行访问内部类的成员。

**格式:** Inner in = **new** Inner();

2. 一个被private修饰内部类(其成员绝对不能是静态)，也可以访问外层类类的任何成员，但是一个内部类一旦被private修饰之后，外界就不能直接进行访问，创建对象等操作。

**注意:** 之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

3. 一个非静态内部类，如果它外层类静态方法要访问内部类的话，就必须使用如下方式创建对象进行访问(或者将内部类修饰为静态内部类):  
**格式:** MyOuter.MyInnerin = **new**MyOuter().**new**MyInner();

public classInnerTestDemo
    {
           public static voidmain(String[] args)
           {
                  MyOuter.myMethod();
           }
    }
    classMyOuter
    {
               classMyInner
                         {
                                 int a =23;
                                     public  voidshow()
                                     {
                                            System.out.println(a);
                                     }
                         }
           public static voidmyMethod()
           {
    //不能编译
    //new MyInner().show();
    //编译成功。因为内部类相当于外层类的成员，因为myMethod()方法存//在时，这些非静态的成员必须建立对象才能在内存中存在，所以要先//创建外层内的对象，再创建内部//类的对象。
                  MyOuter.MyInner  in = newMyOuter().newMyInner();
                  in.show();
           }
    }

4. 外部类要访问内部类，必须建立内部类对象。

5. 当内部类定义在外部类成员位置上，而且不是私有，可以被外部类的其他类直接建立对象。

**格式:**   
外部类.内部类 变量名 = 外部类对象.内部类对象;

MyOuter.MyInner in = **new**MyOuter().**new**MyInner();

6. 当内部类被static修饰之后，具备static的特性，只能访问外部类的static的成员。

7. 在外层内中如何访问静态内部类的非静态成员？

**格式:new**Inner().show()

classOuter
    {
                  static int x = 0;
                  int y = 1;
                 
                  static classInner
                  {
                         voidshow()
                         {
                               System.out.println(x);
                         }
                  }     
                  public static voidfunction()
                  {
                           newInner().show();//ok
                  }
                  public voidfunction2()
                  {
                           newInner().show();//ok
                  }
    }

8. 外层类如何访问静态内部类的静态成员？

**格式**:Inner.*show*();  
因为都是内部类和内部类的成员都是静态的，外层类就可以直接以类名.静态成员的方法访问。

9. 在外部的其他类中，如何直接访问静态内部类的非静态成员呢？  
**格式**: new Outer.Inner().show();

public classInnerTestDemo2
    {
           public static voidmain(String[] args)
           {
    //因为内部类是static的，可以通过外部类.内部类的方法，但是
    //静态内部类的show()方法是非静态的，无法在静态main方法中//调用，只能创建Inner内部类的对象来调用。
                   newOuter.Inner().show();//ok
                   Outer.function();
           }
    }
    classOuter
    {
                 static int x = 0;
                 int y = 1;
                 
                 static classInner
                 {
                        voidshow()
                        {
                              System.out.println(x);
                        }
                 }     
                 public static voidfunction()
                 {
                          newInner().show();//ok
                 }
                 public voidfunction2()
                 {
                          newInner().show();//ok
                 }
    }

10. 在外部其他类中，如何直接访问静态内部类的静态成员呢？  
格式:Outer.Inner.show();

public classInnerTestDemo2
    {
        public static voidmain(String[] args)
        {
                    Outer.Inner.show();//ok
                   Outer.function();
        }
    }
    classOuter
    {
              static int x = 0;
              int y = 1;
              static class Inner
              {
                     static voidshow()
                      {
                            System.out.println(x);
                      }
              }
              
              public static voidfunction()
              {
                        
                     Inner.show();
              }
              public voidfunction2()
              {
                        Inner.show();
              }
    }

11. 内部类定义在局部时，可以直接访问外层类的的成员，因为还持有外层类类中的引用，但是不可以访问它所在局部中的变量，只能访问被final修饰的局部变量。

public classInnerTestDemo4
    {
        public static voidmain(String[] args)
        {
            A a = new A();
            a.show();
        }
    }
    class A
    {
              String s = "hello!";
              voidshow()
              {
                     int a= 5;
                     final  int b =6;
                     classInnerB
                     {
                              public  int  c= 7;
                              public voidfunction()
                              {
                 //局部内部类还可以访问外部类的成员
                                System.out.println(s);
                 //编译失败，不能访问局部非final的变量
                 //System.out.println(a);
                 //只能访问局部方法中的final修饰的变量
                                   System.out.println(b);  
                              }
                     }
    //如果需要运行外层类的show()方法必须建立局部内部类的对象
    //再调用局部内部类的方法或成员，而且对象的创建和调用成员语句
    //必须是要放在类的定义后面，因为方法是按照数序执行。
              InnerB ib = newInnerB();
              ib.function();
              System.out.println(ib.c);     
               }
    }

12. 局部内部类访问所在部方法的参数是，参数必须是final修饰的，否则无法访问或编译失败。

public classInnerTestDemo4
    {
        public static voidmain(String[] args)
        {
            A a = new A();
          //当这个方法调用完毕会释放这两个参数在栈内存中的空间
          //并不会影响下一举方法的执行。
            a.show(4,5);
            a.show(6,7);
        }
    }
    class A
    {
              voidshow(final int a, final int b)
              {
                     classInnerB
                     {
                              public  int  c= 7;
                              public voidfunction()
                              {
                //局部内部类要访问局部方法的参数，将参数接收时就必须
                //将其修饰为final
                                   System.out.println(a+b);  
                              }
                     }
              InnerB ib = newInnerB();
              ib.function();
              }
    }

13. 对外界完全隐藏，即使此方法所在的类也不可访问，也就是说，除此方法外，无任何方法知道它的存在。

14. 当外部类中的静态方法访问内部类时，内部类也必须是static的。

**四. 何时使用内部类**

1. 当描述事物时，事物的内部还有事物，则该事物使用内部类来描述，因为内部事物要使用外部事物内容

举例来说:楼房内部还有家庭住户，家庭住户中还有房间，这就可以用内部类描述。（总不能访问一个住户，就建立一个楼房对象吧，那就可真是有钱人的风范了。）

2. 当一个类需要直接访问另一个类中的成员时，则当这个类放入另一个类中，并将内部类封装。

3. 当一个内部类为静态内部类，想去访问外部内的成员时候，它只能访问外部类的静态成员，如果外部类的静态成员相对少的话，定义静态内部类意义不大，只有外部类含有较多静态内部类时候，用是比较方法，比较合适的。

**五. 匿名内部类**

1. 匿名内部类其实就是内部类的简写格式

2. **定义匿名内部类的前提:**内部类必须继承一个类或实现接口。

**注意:**可以不继承一个类，仍可以定义一个匿名类，那么可以依靠Object类来定一个匿名类，因为任何类都是Object类的子类。

3. **匿名类的格式:** new 父类或者接口()\{定义子类的内容\}

**注意:**  
A. 其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。

**B.** 匿名内部类中定义的方法最好不要超过3个。

**C.** 当创建接口或抽象类的匿名子类对象时，必须全部复写接口中的方法。

**D.** 当创建一般类的匿名子类对象时，可以不用复写全部方法，只需复写需要的即可。

public classNoNameInnerDemo
    {
     
        public static voidmain(String[] args)
        {
               OuterClass  oc = newOuterClass ();
               oc.function();
               oc.function2();
        }
    }
    classPerson
    {
           voidshow()
           {
                  System.out.println("父类show");
           }
           voidsay()
           {
                  System.out.println("父类say");
           }
    }
    interfaceInnerClass
    {
             public abstract voidtest();
             public abstract voidgo();
    }
     
    class  OuterClass
    {
              voidfunction()
              {
                
                    final int a =3;
          //当创建一般类的匿名子类对象时，可以不用复写全部方法，
          //只需复写需要的即可。
                     newPerson()
                     {
                           voidshow()
                           {
                                   System.out.println("匿名show:"+a);
                           }
                     }.show();
              }
             
              voidfunction2()
              {
    //当创建接口或抽象类的匿名子类对象时，必须全部复写接口中的方法。
                    InnerClass ic =  newInnerClass()
                     {
                               public void go()
                               {
                                         System.out.println("interfacego!");
                               };
                            public voidtest()
                            {
                                    System.out.println("interfacetest!");
                            
                            }
                     };
                     ic.go();
                     ic.test();
              }
    }