Java学习总结-----内部类

什么是内部类？

定义：内部类即是在一个类内部嵌套了其他类，我们把这些嵌套的类即称为内部类。
内部类与外部类就如人与心脏，车与发动机之间的关系.。
注：内部类里面可以在再嵌套内部类，一个类中可以嵌套多个内部类。

为什么要有内部类？

内部类的主要功能是弥补Java中不能多重继承的缺陷，其次内部类可以方便的访问外部类的数据（包括private修饰的数据，且不依赖于对象），同时内部类可以实现对除外部类之外的类进行隐藏，体现面向对象的封装和隐藏。利用内部类可以简化程序的结构。

内部类的简单使用（1,2,3）

1.内部类直接访问外部类的私有域

class Outer 
{
    private String str = "外部类的私有属性";
    class Inner 
    {
        public void display()
        {
            System.out.println(str); //直接输出外部类的私有属性
        }
    }
}
public class Test
{
   public static void main(String[] args) 
   {
        Outer.Inner in = new Outer().new Inner();
        in.display();
   }
}

输出结果：

代码分析，在内部类中定义display方法直接访问外部类的私有属性，在主方法中通过内部类对象调用display方法即可输出外部类的私有属性值。

2.外部类必须通过内部类对象访问内部类的所有数据。

class Outer 
{
    class Inner 
    {
        private String str = "内部类的私有属性";
        public void display()
        {
            System.out.println(this.str);
        }
    }
    public void fun()
    {
        
        Inner in = new Inner();//创建内部类对象
        in.display();   //通过内部类对象访问内部类的数据
    }
}

public class Test
{
    public static void main(String[] args) 
    {
        Outer out  = new Outer();
        out.fun();

    }
}   

输出结果： 内部类的私有属性

3.内部类访问外部类中同名的属性或者方法

class A 
{
    private String name = "外部类";
    public void fun()
    {
        System.out.println(this.name);
    }
    public void  test()
    {
        System.out.println("外部类的test方法");
    }
    class B 
    {
        private String name = "内部类";
        public void fun()
        {
            System.out.println(A.this.name);  //访问外部类中的name属性
        }
        public void test()
        {
            System.out.println("内部类的test方法");
        }
        public void fun1() 
        {
            A.this.test();  //调用外部类中的test方法
        }
    }
}
public  class Test 
{
    
    public static void main(String[] args) 
    {
       A.B b = new A().new B();
       b.fun();
       b.fun1(); 
    }
}

输出结果：

使用内部类实现多继承

class A 
{
    class B
    {
       
    }
    class C 
    {

    }
}
//--------------------------------
class C 
{

}

class B extends C
{

}

class A extends B
{

}

这两种写法都可以使得类A里面含有类B和类C的所有数据。

内部类的分类（根据内部类所处的位置不同）

1.成员内部类 ------------类似于普通方法

定义：没有被static修饰的内部类。

注：普通内部类中不能含有静态属性和方法，但可以访问外部类中的静态属性和方法。定义内部类对象依赖于外部类。

原因：程序执行时，优先加载外部类，然后为静态变量和方法分配空间，再执行内部类，即在执行内部类之前必须为静态变量分配空间，所以普通内部类中不能含有静态属性和方法。

2.静态内部类 ------------类似于静态方法

定义：被static修饰的内部类。

注：静态内部类可以含有普通属性和方法，但不能访问外部类中的普通属性和方法。定义内部类对象不再依赖于外部类对 象。（因为静态内部类和外部类对象无关是和外部类的一个属性或者方法是一样的额，通过类名即可以访问）。

原因未知！”

3.方法内部类（局部内部类） ------------类似于局部变量

定义：定义在方法中的内部类，方法内部类只能在该方法中使用，出了该方法就会失效。
1）.局部内部类不允许使用public、private、protected等关键字修饰。
2）.局部内部类对外完全隐藏，除了类所处的方法之外。
3）.局部内部类若想使用方法形参，该形参必须被final修饰，jdk8之后变为隐式的了。

4.匿名内部类（待续）

创建内部类对象

1.在外部类外创建成员内部类对象

格式：外部类.内部类 内部类对象引用 = new 外部类（）.new 内部类（）；

class A 
{
     class B 
    {
        public void fun()
        {
            System.out.println("hehe");
        }
    }
}

public class Test
{
    public static void main(String[] args) 
    {
      A.B b = new A().new B();
      b.fun();
    }
}

2.在外部类里面创建成员内部类对象

格式：内部类 内部类对象引用 = new 内部类（）；

class A 
{
     class B 
    {
        public void fun()
        {
            System.out.println("heh");
        }
    }
    public void display()
    {
        B b =new B();
        b.fun();
    }
}

public class Test
{
    public static void main(String[] args) 
    {
      A a = new A();
      a.display();
    }
}

3在外部类外创建静态内部类对象

格式： 外部类.内部类 内部类对象引用 = new 外部类.内部类（）；

class A 
{
    static class B 
    {
        public void fun()
        {
            System.out.println("heh");
        }
    }
    public void display()
    {
        B b =new B();
        b.fun();
    }
}

public class Test
{
    public static void main(String[] args) 
    {
        A.B b = new A.B();
        b.fun();
    }
}

4.在外部类里面创建静态内部类对象

格式：内部类 内部类对象引用 = new 内部类（）；

class A 
{
    static class B 
    {
        public void fun()
        {
            System.out.println("heh");
        }
    }
    public void display()
    {
        B b =new B();
        b.fun();
    }
}

public class Test
{
    public static void main(String[] args) 
    {
       A a = new A();
       a.display();
    }
}

注：静态内部类与普通外部类没有任何区别，只是定义位置的不同而已。