内部类：成员内部类，局部内部类，匿名内部类，静态内部类 。包

对于外部类来说，只有两种修饰，public和默认（default），因为外部类放在包中，只有两种可能，包可见和包不可见。


在Java中，可以将一个类定义在另一个类里面或者一个方法里边，这样的类称为内部类，广泛意义上的内部类一般包括四种：成员内部类，局部内部类，匿名内部类，静态内部类 。

1.成员内部类

（1）该类像是外部类的一个成员，可以无条件的访问外部类的所有成员属性和成员方法（包括private成员和静态成员）；

（2）成员内部类拥有与外部类同名的成员变量时，会发生隐藏现象，即默认情况下访问的是成员内部类中的成员。如果要访问外部类中的成员，需要以下形式访问：【外部类.this.成员变量  或  外部类.this.成员方法】；

（3）在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问；

（4）成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象；

（5）内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。如果成员内部类用private修饰，则只能在外部类的内部访问；如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。外部类只能被public和包访问两种权限修饰。

2.局部内部类

（1）局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内；

（2）局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

3.匿名内部类

（1）一般使用匿名内部类的方法来编写事件监听代码；

（2）匿名内部类是不能有访问修饰符和static修饰符的；

（3）匿名内部类是唯一一种没有构造器的类；

（4）匿名内部类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是重写。

4.内部静态类

（1）静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似；

（2）不能使用外部类的非static成员变量或者方法。

权限修饰符：

       Protected 修饰的  在不同包下的无关类 不能访问

                       在不同包下的子类中可以访问

---

成员内部类：

Class test_InnerClass {

       Public static void main(String[ ] args) {

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

              oi.method( );

}

}

class Outer {

       private int num = 10;

       class Inner {

              public void method（）{

                     System.out.println(“hello！”)

                     //System.out.println(num);

}

       }

}

成员内部类的创建方式及访问特点：

　　

1. 成员内部类可以直接访问外部类的成员，包括私有；
2. 成员外部类要访问内部类的成员，必须创建一个成员内部类对象
3. 外部类名.内部类名 对象名 = new 外部类对象. new 内部类对象
4. 

---

 局部内部类：

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

 注意，局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

 

---

 静态成员内部类：

 

静态内部类是不依赖于外部类的，也就说可以在不创建外部类对象的情况下创建内部类的对象。另外，静态内部类是不持有

指向外部类对象的引用的，

---

 匿名内部类：

匿名内部类应该是平时我们编写代码时用得最多的，在编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护。

就是内部类的简写，前提是存在一个类或者接口，这个类也可以是抽象类；

格式：

　　new 类名或者接口名（）{

　　　重写方式；

　　　}

本质：是一个继承该类或者实现了该接口的子类匿名对象

把匿名内部类当作参数传递，（把匿名内部类当作一个对象） 

package com.gaoyang.www;

public class test_NoNameInnerClass {
    public static void main2(String[] args) {        
        //System.out.println("dsadsa");
        PersonDemo pd = new PersonDemo();
        pd.method(new Person() {//匿名内部类当作参数传递。本质时把匿名内部类当作一个对象
            public void show() {
                System.out.println("匿名内部类show了！");
            }
        });
    }
}

//抽象类
abstract class Person {
    public abstract void show();
}

class PersonDemo {
    
    public void method(Person p) {
        p.show();
    }
}

package com.gaoyang.www;

public class test2_NoNameInnerClass {
    public static void main(String[] args) {
        Outer.method().show(); //链式编程，每次调用方法后还能继续调用方法，证明调用方法返回的是
    }
}


interface Inter1 {
    void show();
}


class Outer {
    public static Inter1 method() {
        return new Inter1() {
            public void show() {
                System.out.println("hello,world!");
            }
        };
    }
}

---

Tip：封装 就是隐藏实现细节，对外提供功能方式。私有 只是封装的一种体现

为什么要有包：

1. 将字节码（ .class ）进行分类存放
2. 包其实就是文件夹

一般将域名倒着写用作包的名称：比如 www.baidu.com  那包名为 com.baidu.www

定义包的格式：

       package 包名；

       多级包， 用 . 分开即可

1.package语句必须是程序的第一条可执行代码

2.package语句在一个java 文件中只能有一个

3.如果没有package，默认表示无包名

带包的类编译和运行

1. 编译时 javac -d . HelloWorld.java
2. 执行   java 包名.HelloWorld

不同包下类的访问：

       Import 包名

package import class  三种 要按照顺序来写

---

内部类的使用场景和好处

　　为什么在Java中需要内部类？总结一下主要有以下四点：

　　1.每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整，

　　2.方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。

　　3.方便编写事件驱动程序

　　4.方便编写线程代码

　　个人觉得第一点是最重要的原因之一，内部类的存在使得Java的多继承机制变得更加完善。