内部类相关——定义、匿名内部类、回调实现及静态内部类

内部类，顾名思义就是在一个类中的类。内部类可以访问所在类的数据，包括私有数据，而又可以对其他类隐藏，在快速实现回调函数时可以使用匿名内部类，比较便捷。

1、以下为一个简单的内部类例子，内部类可以定义为私有以对其他类隐藏起来；可以用内部类来达到实现多继承的效果。需要注意的是，通过成员函数传入内部类的变量必须定义为final类型，以保证数据的一致性。

public class Cat extends Walk{
	//private私有类，继承Walk和Eat
	private class LittleCat extends Eat {
		public void doSomething() {
			System.out.println("Walking....Eating....");
		}
	}
	
	public static void main(String[] args) {
		LittleCat lCat = new Cat().new LittleCat();//创建内部类对象方式，通过先创建所在外围类对象再创建内部类对象
		lCat.doSomething();
	}
	
	public void event(final String name) {
		class EatFish{
			public void eat() {
				//name = "Tom";//在这里修改会报错，name 必须为final类型，保证数据一致
				System.out.println(name);
			}
		}
		EatFish test = new EatFish();
		test.eat();
	}
}

两个父类：

public class Walk {
}

public class Eat {
}

2、匿名内部类
从名称可以知道匿名就是没有类名的类，匿名内部类用于快速调用接口或抽象类等等中的方法，不需要多写一个实现类来实现调用。

抽象类

public abstract class Dog {
	abstract void eat();
}

接口

public interface Animal {
	void eat();
}

测试类

public class AnonymousDemo {
	
	public static void main(String[] args) {
		 
		/**
		 * 通过创建的一个接口或抽象类分引用，快速便捷重写需要实现的方法，不需要先写一个实现类再实例化以调用方法
		 */
		
		//实现接口方式
		Animal dog = new Animal() {
			@Override
			public void eat() {
				System.out.println("like bone.");
			}
		};
		dog.eat();//向上转型的实例，直接调用重写的eat方法
		
		//继承抽象类的方式
		Dog littleDog = new Dog() {
			@Override
			void eat() {
				System.out.println("I like bone.");
			}
		};
		littleDog.eat();
	}
}

此外，Java的回调函数式可以通过匿名内部类来实现，比如以下例子

(1)封装的类和提供的接口
封装给别人调用的类

public class Person {
	
	private EatFood eatFood;
	
	/**
	 * 普通方式，构造传递引用
	 */
	public Person(EatFood eatSomething){
		this.eatFood = eatSomething;//构造时传入引用
	}
	
	
	/**
	 * 普通方式，成员函数传递引用
	 */
	public Person(){
	}
	public void setCallBack(EatFood eatSomething) {
		this.eatFood = eatSomething;//用成员函数传入引用
	}
	
	//需要调用的方法
	public void eatFood() {
		eatFood.eat();
	}
}

调用类需要的接口定义

public interface EatFood {
	void eat();
}

(2)实际调用
一般做法都会写一个类实现接口

public class EatRice implements EatFood {
	@Override
	public void eat() {
		// TODO Auto-generated method stub
		System.out.println("It's time to eat rice.");
	}
}

然后是实际使用的类

public class PeronEatTest {
	public static void main(String[] args) {
		//普通方式，构造传递引用
		Person personOne = new Person(new EatRice());//EatRice实现类方式。多写一个方法传入也可
		personOne.eatFood();

		//普通方式，成员函数传递引用
		Person personOne = new Person();
		EatRice eatRice = new EatRice();
		personOne.setCallBack(eatRice);
		personOne.eatFood();
}

如果使用匿名内部类就便捷了许多

public class PeronEatTest {
	public static void main(String[] args) {	
		Person personTwo = new Person(new EatFood() {
			@Override
			public void eat() {
				// TODO Auto-generated method stub
				System.out.println("It's time to eat rice.");
			}
		});
		personTwo.eatFood();
	}
}

3、静态内部类
创建是不需要依赖于外围类，但也不能使用任何外围类的非static成员变量和方法

public class Cat{
	
	private String str = "cat";
	private static String str_static = "cat";
	
	private class LittleCat{
		//public static String str_test = "test";//错误，非静态内部类变量不能为静态
		public static final String str_test = "test";//但加上final就可以
		public void doSomething() {
			str = "little cat";
			System.out.println("Walking....Eating....");
		}
	}
	
	static class BigCat{
		public void doSomething() {
			//str = "little cat";//错误，静态内部类反问外围非静态变量和方法
			str_static = "big cat";
			System.out.println("I am a big cat.");
		}
	}
	
	public static void main(String[] args) {
		LittleCat lCat = new Cat().new LittleCat();//依赖外围类
		lCat.doSomething();
		
		BigCat bigCat = new BigCat();//不依赖外围类
		bigCat.doSomething();
	}