内部类

1、一般成员内部类

（内部类类在成员变量位置）
1.1在外部类外创建对象。Outter.Inner in = new Outter().new Inner();
1.2一般成员内部类中不能有静态成员，除了static final修饰的常量
1.2.1static final修饰的都是一般数据类型和String
1.3一般成员内部类可以直接使用外部类的所有成员包括静态和非静态成员。
属性名重名的话就近原则，用外部类属性 外部类.this.属性
1.4外部类调用内部类成员需要创建内部类对象

2、静态成员内部类

2.1在外部类外创建内部类对象：Outter.Inner in = new Outter.Inner();
2.2静态成员内部类中可以存在任意修饰符修饰的静态和非静态成员
2.3静态成员内部类中只能直接使用外部类的静态成员，如果要用非静态成员需要创建外部类对象
2.4外部类中只能直接使用静态成员内部的静态属性和方法（通过类名调用），如果要使用非静态属性和方法要创建内部类对象。

3、私有成员内部类

3.1私有成员内部类只能在外部类内使用。不能在外部类之外使用
3.2私有成员内部类就是一般成员内部类加private权限修饰符，其他用法一样

4、局部内部类

4.1在类中方法内定义（在局部变量的位置）
4.2通过在方法中创建局部内部类的对象，然后再调用。并且该局部内部类的所在方法必须被调用，才能执行。

5、匿名内部类

5.1匿名实现接口或继承抽象类或重写父类方法，多用于线程。
5.2注意：A a = new A(){重写方法；私有方法}；a.私有方法； 编译不通过。因为他向上转型了。匿名的对象相当于他的子类。可以不转型直接调用
即

public static void main(String[] srgs){
	A a = new A(){
		public void eat(){
			syso("重写吃");
		}
		public void drink(){
			syso("私有方法，喝");
		}
	};
	a.drink();//这个会报错，找不到drink。以为{}代码块里的是一个匿名的A的子类，现在是向上转型了，所以他的私有方法就不能调用了。
	new A(){
		public void eat(){
			syso("重写吃");
		}
		public void drink(){
			syso("私有方法，喝");
		}
	}.drink();//这样是可以的，但只能调用一次
}
class A{
	public void eat(){
		syso("A吃");
	}
}

匿名内部类的线程应用举例：

public class Demo {
    public static void main(String[] args) {
        Thread t = new Thread() {
            public void run() {
                for (int i = 1; i <= 5; i++) {
                    System.out.print(i + " ");
                }
            }
        };
        t.start();
    }
}

匿名内部类

package exercise;

/**
 * @author ‘帅的一批’
 *	匿名内部类练习
 */
public class Topic2 {
	public static void main(String[] args) {
		new I1(){ //实现接口
			@Override
			public void func() {
				// TODO Auto-generated method stub
				System.out.println("匿名内部类1");
			}
		}.func();
		
		new A1(){ //继承抽象类
			@Override
			public void func() {
				System.out.println("匿名内部类2");
			}
		}.func();
		
		new A1(){ //匿名内部类中的局部内部类
			@Override
			public void func() {
				class InnerA1{
					public void funs() {
						System.out.println("匿名内部类A1中的局部内部类InnerA1.FUNS()");
					}
				}
				InnerA1 a1 = new InnerA1();
				a1.funs();
			}
		}.func();
		
		new Animal(){ //重写方法
			@Override
			public void eat() {
				//super.eat();
				System.out.println("猫吃鱼；这是一个匿名的猫对象，继承动物类，重写eat方法");
			}
		}.eat();
		
		new Animal().fun();
	}
}
interface I1{
	public abstract void func();
}
abstract class A1{
	public abstract void func();
}
class Animal{
	public void eat() {
		System.out.println("动物吃。。。");
	};
	
	
	
	public void fun() {
		new A1(){
			public void func() {
				// TODO Auto-generated method stub
				System.out.println("在fun方法中的匿名内部类的func方法");
			}
		}.func();
	}
}

匿名内部类的构造代码块可以实现构造方法的效果

不过还是需要调用super（），用父类构造方法实例化

package com.edu.bdu;

public class Test1 {
	public static void main(String[] args) {
		new A() {
			{
				this.b = 21;
			}
			public void fun() {
				System.out.println(this.b);
				System.out.println("匿名内部子类重写的普通方法");
			}
		}.fun();
	}
}
class A{
	int b = 20;
	public void fun() {
		System.out.println("父类方法");
	}
}

https://www.runoob.com/w3cnote/java-inner-class-intro.html