全网最全内部类介绍

内部类：顾名思义内部类是嵌套在其它类内部的类，根据出现的位置和修饰的关键字可分为四种。分别是：成员内部类、静态内部类、方法内部类和匿名内部类。

（1）成员内部类：用法和成员方法类似，定义在外部类的内部使用，并且可以用private修饰，但需注意外部类不可用private修饰。

public class Outter {
        private int age;
        private String name;
    //成员内部类，private可修饰内部类，但不可修饰外部类。

 class Inner{
        private String msg = "hello Inner Class";

        public void test() {
            System.out.println(msg);
            //可以访问外部类的私有域
            System.out.println(age);
        }
    }
}

特点：1.内部类可以用private修饰，但需注意外部类不可用private修饰。

2.内部类和外部类是可以相互访问彼此的私有域，并其内部类可以直接访问外部类的私有域。是因为成员内部类的内部有隐藏的外部对象。实现请看上面的代码块。而外部类访问内部类的私有域则必须经过内部类的对象访问。

   public void fun(){               
        //外部类的成员方法
        //创建内部类对象
        Inner inner = new Inner();
        System.out.println(inner.msg);

    }

3.内部类可以变相解决java的单继承局限。

class A{
    protected int age = 11;
}
class B{
    protected String msg = "hello world";
}
public class Inherit {

    public static void main(String[] args){
        Inherit inherit = new Inherit();
        inherit.fun();

    }
    class InnerClassA extends A{}

    class InnerClassB extends B{}

    public void fun(){
        InnerClassA a = new InnerClassA();
        InnerClassB b = new InnerClassB();
        System.out.println(a.age);
        System.out.println(b.msg);

    }


}

4.内部类可以对外部隐藏。

---------------特点的2.3.4是内部类存在的意义。--------------------------------------------------------------------内部类与外部类的关系：

1.成员内部类的创建需要依赖外部类对象。类比成员方法必须通过对象调用，在没有外部类实例之前无法创建成员内部类对象。

2.内部类与外部类是相对独立。

3.两者之间的私有属性互相访。

4.创建内部类的语法:

(1).在外部类的内部创建内部类对象

        Inherit inherit = new Inherit();

(2).在外部类的外部创建内部类对象（内部类没有被private修饰）

class Text{
    public static void main(String[] args) {
        Outter.Inner inner = new Outter().new Inner();
    }
}

5.在在内部类的内部使用隐藏的的外部类对象（this）

 class Inner{
        private String msg = "hello Inner Class";
        private int age = 20;
        public void test() {
            System.out.println(msg);
            //可以访问外部类的私有域
            System.out.println(Outter.this.age);
            System.out.println(this.age);
        }
    }

**************************************************************************************************************

注意：成员内部类不能拥有静态域，但却可以访问外部类的静态域。

（2）静态内部类：定义在外部类的内部并用static修饰。

特点：1.静态内部类无需外部类对象产生就能使用，但不能访问外部类的成员域，能访问外部类的静态域。

package innerclass;

public class StaticInnerClass {
    static int age;
    String name;
    static class Inner{
        public void test(){
            System.out.println(age);
            System.out.println(name);
        }
    }
}

由上面例子可知，静态内部类可以正常访问age，但不能正常访问name，运行后会出现报错。

 2.静态内部类可以有自己的成员域。

3.静态内部类与成员内部类的比较：

成员内部类▬必须有外部类对象▬类比成员方法▬能访问外部的静态域，但不能拥有静态域。

静态内部类▬不依赖外部类对象▬类比静态方法▬能拥有成员域，但不能访问外部类的成员域（除static修饰以外）

静态内部类的创建语法：

 StaticInnerClass.Inner inner = new StaticInnerClass.Inner()

（3）方法内部类：定义在方法内部

package innerclass;

public class FunClass {
    public void fun(){
        //9方法内部类  局部变量
        int a = 23;
        class Inner{
            
        }
    }
}

特点：

1.对外部完全隐藏，因此方法内部类不能有任何访问修饰符，没有意义。

2.若要使用方法的形参，只能用不能改。

a.方法内部类没有访问形参时，这个形参可以在方法中随意修改。

b.方法内部类使用了形参，这个形参必须被声明为final.

（4）匿名内部类:定义在方法中，类都没有名字。

特点：

1.经常用在多线程部分。

2.必须继承一个抽象类或者实现一个接口。

3.没有构造方法，用一次就销毁。

实现结果如下：

package innerclass;
interface IMessage{
    void fun();
}//接口
public class NoNameClass {
    public static void main(String[] args) {
        IMessage msg = new IMessage() {
            //匿名内部类
            @Override
            public void fun() {
                System.out.println("hello world");
            }
        };
        msg.fun();
    }
}