黑马程序员——Java基础--内部类总结

这里东西还是很多的，很杂

我曾经有过问题的地方总结的4.2  为什么方法内的变量都要用final  后来明白了  

方法内部类对象只能访问该内部类所在方法的final修饰的局部变量 

1.内部类可以直接访问外部类中的成员，包括私有
     原因：因为在内部类中持有一个外部类的应用，格式：外部类.this

class Outer {
    private int x = 1;

    class Inner {
        int x = 2;
        public void seeOuter() {
             int x = 3;
             System.out.println(x);
             System.out.println(this.x);
             System.out.println(Outer.this.x);
       }
    }  
 }

 

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

A.从外部类的非静态方法中访问内部类

class Outer {
  private int x = 1;

public void seeInner() {
   Inner in =new Inner();
   in.seeOuter();
  }

class Inner {
   public voidseeOuter() {
    System.out.println(x);
   }
  }
 }

B、从外部类的静态方法中访问内部类

class Outer {
  private int x = 1;
  class Inner {
   public voidseeOuter() {
   System.out.println(x);
   }
  }
  public static voidseeInner(){
   Outer.Innerinner  = new Outer().newInner(); //1
   //如果把1位置的访问方式换成new Inner().seeOuter() 必须保证Inner是静态的
   inner.seeOuter();
  }
 }

C、在外部其它类中访问内部类

class Outer {
  private int x = 1;
  class Inner {
   public voidseeOuter() {
    ystem.out.println(x);
   }
  }
 }

public class Touter{
  public static voidmain(String[] args){
   Outer.Innerinner = new Outer().new Inner();
   inner.seeOuter();
  }
 
 }

对比：在外部类的非静态方法中访问内部类：Inner in = new Inner();
      在外部类的静态方法中访问内部类：Outer.Innerin = new Outer().new Inner();
     在外部其他类中访问内部类：Outer.Inner in = new Outer().new Inner();

 

3.当内部类在成员位置上，就可以被成员修饰符修饰
3.1当内部类被static修饰后，就只能访问外部类中的static成员，出现访问局限
  class Outer {
   private int x= 1;
   static classInner {
    publicvoid seeOuter() {
         System.out.println(x);//error
    }
   }
  } 

3.2在外部其他类中，如何访问static内部类的非静态成员呢？
  newOuter.Inner().seeOuter();
  理由：因为外部内一旦被加载，静态内部类也被加载了，所以直接创建内部类对象调用方法即可

class Outer {
   privatestatic int x = 1;
   static classInner {
    publicvoid seeOuter() {
    System.out.println(x);
    }
   }
  }
  public class Test{
   public staticvoid main(String[] args){
    newOuter.Inner().seeOuter();
   } 
  }

3.3在外部其他类中，如何访问static内部类的静态成员呢？
   Outer.Inner.seeOuter();

class Outer {
   privatestatic int x = 1;
   static classInner {
    publicstatic void seeOuter() {
    System.out.println(x);
    }
   }
  }
  public class Test{
   public staticvoid main(String[] args){
    newOuter.Inner().seeOuter();
   } 
  }

3.4.当内部类中定义了静态成员，该内部类必须是静态的
  class Outer {
   privatestatic int x = 1;
   class Inner{
    staticint y = 2; //error
    publicstatic void seeOuter() { //error
     System.out.println(x);
    }
   }
  }  

3.5.当内部类中的静态方法访问内部类时，内部类也必须是静态的(参考上面2中B位置1处)

 

4.方法内部类（局部内部类）
  把类放在方法内

  class Outer {
        public void doSomething(){
            class Inner{
                 public voidseeOuter(){  
                 }
             }   
        }
  }

4.1、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化

4.2、方法内部类对象不能访问该内部类所在方法的非final局部变量  
    class Outer {
     intb = 1;
        public void doSomething(){
             final int a =10;
             class Inner{
                  public voidseeOuter(){
                      System.out.println(a);//a 必须是final类型
     System.out.println(b);//b 可以不是final类型的
                 }
             }  
             Inner in = new Inner();
             in.seeOuter();  //只能在方法内部访问内部类
        }
        public static void main(String[] args) {
             Outer out = new Outer();
             out.doSomething();
        }
    }

4.3、方法内部类的修饰符
    与成员内部类不同，方法内部类更像一个局部变量
    可以用于修饰方法内部类的只有final和abstract

4.4、静态方法内的方法内部类

    静态方法是没有this引用的，因此在静态方法内的内部类遭受同样的待遇，即：只能访问外部类的静态成员

5.匿名内部类
   匿名内部类就是内部类的简写格式
   定义匿名内部类的前提：内部类必须继承一个类或实现接口
   匿名内部类就是一个匿名子类对象
  格式：new 父类或者接口(){定义子类的内容}