1、 静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问 

2、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员

3、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

内部类的定义：

1、成员内部类

2、静态内部类

3、方法内部类

4、匿名内部类

内部类的主要作用：

1、将内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2、内部类的方法可以直接访问外部类的所有数据

面向对象的三大特性：封装，继承，多态

这一小节比较关键

方法内部类

方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内部使用，故内部类的对象创建及方法调用也只能在该方法内，内部类之后！

如图：

       MInner mi=new MInner（）；

       mi.print();

       这两句在class MInner之后，外部类方法show（）之内！！！

另外：

       因为方法内部类不能在外部类的方法以外的地方使用，所以方法内部类不能使用访问控制符（public等）和static修饰符！（没有必要）

静态内部类（static修饰）

静态内部类就是static修饰的内部类，其特点是：

1、静态内部类不能直接访问外部类的非静态成员，必须通过new  外部类().成员  的方式访问（实际是将创建外部类对象和利用外部类对象调用非静态成员合二为一了）

2、静态内部类访问外部类的静态成员时，若外部类的静态成员名与内部类的静态成员名不同，则可通过“成员名”直接调用外部类的静态成员；若外部类的静态成员名与内部类的静态成员名相同，则可通过“类名.静态成员”的方式访问外部类的静态成员

3、创建静态内部类的对象时，可以直接创建，而不需要先创建外部类的对象，即 内部类  对象名=new 内部类( );

package com.imooc;

//外部类HelloWorld

public class HelloWorld {

private int a=99;//外部类的私有变量a

static int b=1;//外部类的静态变量b

//静态内部类Inner

public static class Inner{

int b=2;//内部类的变量b

public void test(){

System.out.println("访问外部类中的b："+HelloWorld.b);

System.out.println("访问内部类中的b："+b);

}

}

    //测试静态内部类

public static void main(String[] args){

Inner i=new Inner();//直接创建内部类的对象

i.test();//调用test方法

}

}

封装的步骤：
1.修改属性的可见性：设为private
2.创建getter/setter方法：用于属性的读写
3.在getter/setter方法中加入属性控制语句：对属性值的合法性进行判断

接口:

接口是一种特殊的类，接口的内部全部是由常量和公共的抽象方法组成。

接口通常是用来被继承、被实现的，所以一般用public来做修饰符，不能用private和protected。

[修饰符] interface 接口名 [extends 父接口1，父接口2...]{

0到多个常量定义...

0到多个抽象方法的定义...

}

接口被继承后，在main中调用时使用：

接口名 对象名 = new 接口名（ ）；

就可以调用了。

匿名内部类：

匿名内部类就是没有名字的内部类，常和接口配合使用。

接口名 对象名 = new 接口名（ ）{

}；

或

new 接口名（ ）{

}；

方法内部类：由于方法内部类不能再外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和static修饰符。

1、静态内部类不能 直接 访问外部类的非静态成员，但是可以通过 new.外部类().成员的方式访问。

2、创建静态内部类的对象时，不需要外部类的对象，可直接创建  

   内部类  对象名 = new 内部类（）；

1、外部类不能直接使用内部类的成员和方法

2、如果内外都有相同的成员变量或方法，内部类默认访问自己的。

如想访问外部类的成员变量，可以使用this关键字

例如：外部类Outer，内部类Inner,

Outer.this.

定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，

即：内部类 对象名 = 外部类对象.new 内部类( );

成员内部类（也称为普通内部类）：

//外部类Outer

public class Outer{

     private int a =99;//外部类的私有属性

     //内部类Inner

     public class Inner{

          int b=2;//内部类的成员属性

          public void test（）{

                 System.out.println("访问外部类中的a："+a)；

                  System.out.println("访问内部类中的b："+b)；

          }

     }

     //测试成员内部类

     public static void main（String[] args）{

            Outer o=new Outer();//必须先创建外部对象，对象名为o

             Inner i=o.new Inner();//然后再使用外部对象名o来创建内部对象i

             i.test();//调用内部类对象的test方法

     }

}

成员内部类的使用方法：

1、Inner类定义在Outer类的内部，相当于Outer类的一个成员变量的位置，即为一个普通内部类，Inner类可以使用任意访问控制符，如public、protected、private等

2、Inner类中定义的test（）方法可以直接访问Outer类中的任何数据，不受private等访问控制符的影响

3、定义成员内部类后，必须使用外部对象名来创建内部类的对象名，而不能直接去new一个内部类对象（表明了从属关系），即：内部类  对象名=外部类对象.new  内部类（）； 

4、编译程序后，会产生两个.class文件

其中第2个为外部类的.class文件，第一个为内部类的.class文件，内部类class文件命名规则：外部类名$内部类名.class

注意：

1、外部类的方法不能直接调用内部类的成员和方法，仍必须先通过外部类的对象来定义内部类的对象，再调用内部类成员或方法；

2、如果外部类和内部类拥有相同 名称的成员变量或方法，内部类默认访问自己的成员变量或方法，

如果要访问外部类的成员变量或方法，可以使用this关键字，即外部类.this.外部成员变量名（或外部方法名 ）

 public class Outer{

    static int b=1;

    public class Inner{

        int b=2;

        public void print(){

            System.out.println("调用外部类成员变量b："+Outer.this.b)；//!!!注意Outer.this.b

            System.out.println("调用内部类成员变量b："+b)；

        }

    }

}

每次学习都会发现对接口的理解有所不同