内部类

1. 为何要使用内部类

  主要有如下缘由：

1. 若是一个类只有另一个类在使用它，其它的类都没有用到它，能够把这个类定义为一个内部类。

2. 这里又有产生了一个问题？咱们干吗不把一个类的修饰符设置为private的呢？

3. 结果是没有这种语法。一个类不能被设置为private权限的（内部类固然能够用private修饰了）。

4. java中的类是(接口是能够有多继承的)没有多继承机制，可是在某些特殊状况下是要实现多继承的，这个时候咱们就能够考虑到使用内部类，由于每个内部类均可以独立的继承自一个（接口的）实现，因此不管外部类是否已经继承了某个（接口的）实现，对于内部类来讲都没有影响。

 

内部类的一些特性：

内部类访问它所在的外部类(方法或者是属性)，外部类不能方法该内部类，缘由是内部类持有外部类的引用。

学习内部类的关键点：不要把内部类当作一个类，就把他当作外部类的一个属性或者方法。

内部类的分类：

成员内部类

 clclass OuterCalzz {
     private int age = 100;
     class InnerClazz{
         private int age = 20;
         public void show(){
            System.out.println(age);
            //访问外部类的属性
            System.out.println(new OuterCalzz().age);
            //访问外部类的方法
            new OuterCalzz().test();
     }
 } 
  public void test(){
     System.out.println("OuterClazz");
  }
}

//访问成员内部类的过程
public class InnerTest{

     public static void main(String[] args) {
         OuterCalzz outerCalzz = new OuterCalzz();
         outerCalzz.new InnerClazz().show();
    }
}

 静态内部类

 class OuterCalzz {
      //静态类，不能访问非静态的变量，因此这里age设置成为了static
      private static int age = 100;
      //成员内部类，是一个类的成员
      static class InnerClazz{
            public void show(){
                System.out.println(age);
           }
      }
     public void test(){
       System.out.println("OuterClazz");
     }
} 

//访问静态内部类的过程
public class InnerTest{
 
    public static void main(String[] args) {
      //静态能够直接用类名来访问
      OuterCalzz.InnerClazz in = new OuterCalzz.InnerClazz();
      in.show();
    }
}

 局部内部类(定义在方法中的类)

注意：局部内部类访问局部变量的时候，这个局部变量必定要定义为final，为何呢？

方法在执行完成以后，它里边的变量就会被销毁，当你再次使用的时候没有了，因此就要用final修饰，让定义的变量变成不变的值

class OuterCalzz {
    //test()方法不能反回内部类，缘由是方法没有执行前不可以建立内部类对象
    public Object test(){
       final int age = 30;
       class InnerClazz{
       public void show(){
            System.out.println("InnerClazz");
            System.out.println(age);
       }
       public String toString(){
            return "fff";
       }
   }
   return new InnerClazz();
  }
}

 

匿名内部类

匿名内部类里边定义的属性在初始化块里边初始化

class OuterCalzz {
  public Person test(final String name_, final int age_){
  /**
   * 内部类构建一个相似的javaBean
   */
  return new Person() {
    private String name;
    private int age;
    {
     name = name_;
     age = age_;
    }
    
   @Override
   public String run(String name) {
    return name;
   }
   public String getName(){
    return this.name;
   }
   public int getAge(){
    return this.age;
   }
  };
  }
}
 
 interface Person{
  public abstract String run(String name);
  public abstract String getName();
  public abstract int getAge();
 } 
 
 
 //匿名内部类的使用
 public class InnerTest{
 
    @Test
    public void myJunit(){
    OuterCalzz outerCalzz = new OuterCalzz();
    Person p = outerCalzz.test("quincy",23);
    p.getAge();
 }
}

 

 嵌套类

class MNA{
     class A{
         private void f(){}
         public class B{
                 private void g(){}
                 void h(){
                   g();
                   f();
                 }
          }
    }
}

使用

public class MultiInnerClass {
         public static void main(String[] args) {
                MNA mna = new MNA();
                MNA.A mnaa = mna.new A();
                MNA.A.B mnaab = mnaa.new B();
  
         }
}

 

 

 

局部代码块的做用是控制局部变量的释放时间，节省内存

 public void test(){
     {
       int count = 0;
         while(count < 10){
         count ++;
       }
     }
     //其余的代码
 }
 count变量只会在，代码块中有效，在代码块外就会被释放