什么是内部类？
内部类就是定义在java类内部的类。
定义在文件中的类。一个文件中只能有一个公有类，与文件同名，但是也可以定义其它类。
类的修饰：只能是public或者无。一个类文件中，只能有一个定义成public,与文件同名，其它无修饰。
内部类有哪些？
1.成员内部类 2.静态内部类 3.局部内部类 4.匿名内部类
定义在类当中，作为类的成员所存在，可以使用成员访问修饰符。如public private protect 或者空。
如何创建成员内部类的对象？
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
这样就可以创建类的对象了
实例：
package com.situ.chapter1;
public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void say(){
System.out.println("i am a student!");
}
public class MidStudent {//成员内部类
private int age;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void sayHello(){
System.out.println("你好！");
}
}
}
package com.situ.chapter1;
public class Main {
public static void main(String[] args) {
Student student = new Student();
Student.MidStudent ms =student.new MidStudent();
ms.sayHello();
student.say();
}
}
特点：
1.1.在外部类中，可以直接创建内部类的实例，可以访问内部类的任意（不限修饰符）成员。内部类的成员访问修饰符对外部类不限制，实际上是对其外部类的外部类受限。
1.2.成员内部类，可以任意自由的访问外部类实例的成员，不限访问修饰符。成员内部类持有一个指向其外部类的引用。语法：outer.this.成员
1.3 通过hack的方式，可以间接实现类的多重继承。（利用实现一些接口，使其具有多重属性）
静态内部类相对于成员内部类而言，其使用static修饰。相当于类的静态成员（类成员）。
如何创建静态内部类的对象？
无须先创建外部类的对象。
语法：Outer.Inner inner = new Outer.Inner(); 如果通过import导入静态内部类，则Outer
可省略。—这适合用在成员访问修饰符为空或public的情况。
但是私有成员也可以被访问，如下代码：
package com.situ.chapter2;
public class Student {
private static String name;
private static void sayHell0() {
System.out.println("i am a student!");
}
public void method() {
Teacher t = new Teacher();
t.sayHello();
sayHell0();
}
private static class Teacher{
private void sayHello() {
System.out.println("i am a teacher!");
}
}
}
package com.situ.chapter2;
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.method();
}
}
即在外部类中定义公有方法去访问内部私有类的私有方法。
特点：
2.1 静态内部类是其所在外部类的静态成员（类成员），可以使用成员访问修饰符。创建对象，无须先创建外部类的实例，直接创建对象即可。
2.2 没有指向其外部类实例的引用，不能访问其所在外部类的普通成员，但是可以任意自由的访问其外部类的静态成员。
在除类的作用域之外的作用域内定义的类，一般定义在方法的内部。不能使用成员访问修饰符。其可见性（有效空间作用域），从类定义位置开始，到其所在作用域结束。其有效时间作用域，从代码执行到定义类的位置开始，一直到代码执行到作用域结束。
package com.situ.chapter3;
public interface Person {
public String getName();
public void setName(String name);
public void eat();
}
package com.situ.chapter3;
public class Student {
public Person sayHello() {
Person ps = null;
int a=3;
if(a>5) {
class Point implements Person{//局部内部类实现person接口
private int x;
private int y;
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
@Override
public String getName() {
return null;
}
@Override
public void setName(String name) {
}
@Override
public void eat() {
}
}
Point p =new Point();
return p;
}
return ps;
}
}
package com.situ.chapter3;
public class Main {
public static void main(String[] args) {
Person ps = new Student().sayHello();
System.out.println(ps);
}
}
特点：
3.1 仅在局部有效，在其所在作用域内有效。
3.2 使用场景：一、类仅需在局部有意义。二、局部内部类可以继承其它类，或实现接口，使用多态特性，使用接口或父类的引用指向此类的实例。
使用频率高。
顾名思义，没有名字的内部类。
语法：
超类或接口 变量 = new 超类或接口(){
//类定义
};
使用场景：某个对象只需要创建一次的场景
package com.situ.chapter4;
public interface Person {
public String getName();
}
package com.situ.chapter4;
public class Main {
public static void main(String[] args) {
//匿名内部类
Person p = new Person() {//这里为什么内new一个接口呢，实际上这里匿名了，使用了内部匿名类
@Override
public String getName() {
return "张三";
}
};
System.out.println(p.getName());
}
}
特点：在定义类的同时，创建此类的实例，无法第二次创建实例。因为没有类型名称，只能使用超类（祖先类）或接口的引用来指向此内部类的实例。
匿名内部类，必须是继承自其它类，或者实现某接口。
