内部类（局部类）

内部类
1.内部类：就是在类的内部进行其他类结构的嵌套

class Outter{
    private String msg = "I am Outter";
    //以下为内部类定义--------------------------------------
    class Inner{
        public void fun(){
            System.out.println(msg);
        }
    }
    //----------------------------------------------------
    //在外部类中定义了一个普通方法
    public void test(){
        //实例化了一个内部类对象
        Inner in = new Inner();
        in.fun();
    }
}

定义内部类后造成类结构复杂，最大的优点内部类可以直接访问外部类私有域、私有属性

1.1内部类的存在原因（优点）
a.内部类方法可以访问外部类所有数据，包含被private封装的数据。
b.内部类可以对外部类之外的类进行隐藏，使用内部类也是封装的一种。（人和心脏，汽车和发动机）
c.使用内部类可以实现多继承概念

class A{
   private String name="A类的普通私有属性";
   public String getName(){
       return this.name;
   }
}
class B{
   private int age=20;
   public int getAge(){
       return this.age;
   }
}
class C{
    //   --------------------------------均为C的内部类
    //内部类继承A
    class InnerClassA extends A{
        public  String name(){
            return super.getName();
        }
    }
    //内部类继承B
    class InnerClassB extends B{
        public  int age(){
            return  super.getAge();
        }
    }
    public  String name(){
        return new InnerClassA().name();
    }
    public int age(){
        return new InnerClassB().age();
    }
    //   --------------------------------
}
public class Day6 {
    public static void main(String[] args) {
       C c=new C();
        System.out.println(c.name());
        System.out.println(c.age());
    }
}

2.内部类与外部类关系
a.对于非静态内部类（成员内部类），内部类的创建需要依赖外部类的对象。在没有外部类实例之前无法创建内部类对象。
b.内部类是一个相对独立的个体。与外部类不是is-a（继承）关系，仅仅是包在外部类内部（嵌套关系）而已。
c.内部类可以直接访问外部类的元素（包含私有域），外部类可以间接（用过内部类对象）访问内部类的所有元素（包含私有域）
即：内外部可以访问彼此的私有属性（内部类直接访问，外部类通过对象间接访问）

class Outter{
    private  String msg="Outter 中的私有属性";
//    ----------------------------------------
    class Inner{
        private  String msg1="Inner 中的私有属性";
        public void fun(){
            //内部类可以直接当问外部类的私有属性
            System.out.println(msg);
        }
    }
//    --------------------------------------
    public  void test(){
        Inner in = new Inner();
        System.out.println(in.msg1);
    }
}
public class Day6 {
    public static void main(String[] args) {
      Outter out = new Outter();
      out.test();
    }
}

3.内部类的分类
3.1 成员内部类-类比普通方法
定义在类中不加static修饰符
3.1.1成员内部类要求：
a.成员内部类需要依赖外部类对象，先创建外部类对象后再创建成员内部类对象。

b.成员内部类不能拥有静态属性或方法，但可以访问外部类的静态域。

3.1.2声明并创建成员内部类的语法：
(1)在外部类内部创建成员内部类的对象：就和创建普通类一模一样。

class Outter{
    //成员内部类
    class Inner{ }
    public void test(){
        Inner in = new Inner();
    }
}

(2)在外部类外部创建成员内部类对象：(前提是内部类没有被private封装)
先创建外部类对象，再创建内部类对象
语法： 外部类.内部类 内部类引用= new 外部类( ).new 内部类（）；

class Outter{
    private  String msg="Outter 中的私有属性";
    class Inner{
        private String msg1="Inner 中的私有属性";
        public void fun(){
            System.out.println(msg);
        }
        }
    }
public class Day6 {
    public static void main(String[] args) {
//在外部类的外部创建内部类对象
      Outter.Inner in = new Outter().new Inner();
      in.fun();
    }
}

3.2静态内部类-类比静态方法
定义在类中，使用static修饰；静态内部类与普通外部类没有任何区别，仅仅是定义一个类的内部而已。
a.静态内部类的创建不需要依赖外部类对象，可以直接创建
1)在外部类外部创建静态内部类语法：
外部类.内部类 内部类引用=new 外部类.内部类（）；

Outer.Inner in = new Outer.Inner();

2)在外部类的内部创建静态内部类语法同创建成员内部类一样
b.静态内部类能否拥有普通属性？
静态内部类能拥有普通属性但是不能访问外部类的普通属性。
成员内部类不能拥有静态域，可以访问外部类的静态域
静态内部类不能访问外部类静态域，但是可以拥有静态域

3.3方法内部类（局部内部类）
定义：定义在外部类方法中的类

class Outer {
   public void fun(){
       class Inner{}//方法内部类
   }
}

特点：
a.方法内部类不允许使用访问权限修饰符 public，private，protected均不允许。
b.方法内部类对外部完全隐藏，除了创建这个类的方法可以访问外均不能访问。
c.方法内部类要想使用方法的形参，该形参必须使用final（形参不能更改）声明（JDK8之后变为隐式的final声明）。