内部类

这里先讲解三种内部类的方式：

1.成员内部类  2.方法内部类（局部内部类） 3.匿名内部类

 一.成员内部类

      1. 成员内部类可以使用外部类的成员变量和成员方法，不管用什么修饰，不管是private还是public
      都是可以使用，因为这个内部类是在外部类的类内
      2. 【在外部类类外创建内部类对象的方法】
       外部类名.内部类名  引用类型变量 = new 外部类名().new 内部类名();
      3. 如果在内部类当中，想要使用和外部类同名的成员变量或者方法
          用这个格式
     外部类名.this.同名成员变量;
     外部类名.this.同名成员方法;
     4. 在外部类中可以创建内部类对象

class Outer{
 int num=100;
 class Inner{
  int num=50;
  public void testInner1(){
   System.out.println("内部类的成员方法testInner1");
   System.out.println(num);
   System.out.println(Outer.this.num);
   test();
   Outer.this.test();
  }//内 public testInner1
  public void test(){
   System.out.println("内部类的成员方法test");
  }//内  public test
 }//class
 public void test(){
  System.out.println("外部类的成员方法test");
 }//外  public test
}
public class TestMemberInnerClass {
 public static void main(String[] args) {
  //成员内部类的创建对象的方法
  Outer outer=new Outer();
  Outer.Inner in=outer.new Inner();
  
  Outer.Inner in1=new Outer().new Inner();//这种方法是通过匿名对象调用的
 }
}

二.局部内部类

 局部内部类(方法内部类)
  局部内部类 :放在方法或者函数里面的类，称之为局部内部类
 [必会知识]
  1. 局部变量的
  【生存期】
   从声明位置开始，到代码块结束
  【作用域】
   只能在代码块里面
  2. 类对象的
  【生存期】
   通过new关键字创建的时候开始，JVM进行垃圾回收机制的时候销毁对象。结束
  【作用域】 
   哪里有这个对象的首地址，哪里就是他的作用域
    【记住】局部内部类对象是在函数的内部通过JVM虚拟机创建的，并且通过JVM的垃圾回收机制来销毁，
  这个类对象的生存周期于testInner函数不同
  
  但是testInner函数中普通局部变量n 他的生存周期是和testInner()一致的
  
  如果在局部内部类对象里面使用了testInner函数的局部变量，就有可能存在testInner函数里面的
  局部变量n的生存周期被拉长，这不符合Java原理
  
  为了解决这个问题
  
  如果局部内部类对象要使用所在函数的局部变量，这个局部变量用 final修饰(但是也不能重新赋值) 

class Outer1{
 int num=100;
 public void testInner(){
  final int n=56;
  class MethodInner{
    int i=40;
   public void function(){
    //n=14;
    System.out.println(n);
    System.out.println(num);
    System.out.println(i);
    System.out.println("局部内部类的function方法");
   }
  }
  MethodInner mi=new MethodInner();
  mi.function();
 }
}
public class TestMethodInnerClass {
 public static void main(String[] args) {
  Outer1 outer=new Outer1();
  outer.testInner();
 }
}
三. 匿名内部类

abstract class Animal {
 int age;
 public abstract void test();
 abstract public void jump();
 
}
class Monkey extends Animal {

 @Override
 public void test() {
  System.out.println("探究什么是类的本体");
 }

 @Override
 public void jump() {
  System.out.println("猴子能跳");
 }
 
}
interface A{
 int i=12;
 public void testA();
}
public class TestAnonymousInnerClass {

 public static void main(String[] args) {
  Monkey m=new Monkey();
  m.test();
  m.jump();
  
  /*
   Animal 是一个抽象类 a 是一个抽象类的引用类型变量
  
   new Animal() {
    这里的内容是要求继承于该抽象类的子类完成的方法
    这里就是类的本体
    但是这个类没有名字，所用称之为【匿名内部类】~~
    
    这里有一个隐含的【继承】关系
   };
   
   */
  Animal a=new Animal() {//匿名内部类
   
   @Override
   public void test() {
    System.out.println("这是匿名内部类的test()方法");
   }
   
   @Override
   public void jump() {
    System.out.println("这是匿名内部类的jump()方法");
   }
  };
  a.test();
  a.jump();
  
  
  new A() {
   
   public void testA() {
    System.out.println("匿名内部类里面的遵从接口的test（）方法");
   }
  }.testA();//匿名内部类的匿名对象调用自己的方法

 }
}

内部类的作用:

1.内部类可以很好的实现隐藏:一般的非内部类，是不允许有 private 与protected权限的，但内部类可以

2.内部类拥有外围类的所有元素的访问权限

3.可以实现多重继承

4.可以避免修改接口而实现同一个类中两种同名方法的调用