内部类

概述

在一个类的内部定义的类称为内部类，其实就是类定义的位置发生了变化。早类中定义的内部类叫成员内部类。静态内部类使用很少，用的最多的就是成员内部类。
要注意的是：内部类产生的class文件为”外部类$内部类“，它表明改内部类是属于哪个外部类的。

成员内部类

1. 成员内部类也是一个类，可以有自己的成员属性、成员方法。
2. 成员内部类可以访问外部类的方法和成员属性。
3. 在内部类中，this.name中的this表示内部类
   总结
   内部类访问外部类的字段：外部类名.this.字段
   内部类访问外部类的方法：外部类名.this.方法
   内部类访问内部类的字段：this.字段
   内部类访问内部类的方法：this.方法

package com.ycy1;

//外部类
public class Fruit {
	private int type = 10;

	public int getType() {
		return type;
	}

	// 内部类
	class Apple {
		private String name;

		public String getName() {
			return name;
		}

		public void setName(String name) {
			this.name = name;
		}
		
		public int getFruitType() {
			//访问外部属性
			int type = Fruit.this.type;
			return type;
		}
	}

}

成员内部类的使用

成员内部类必须依赖与外部类的对象，所以，首先要创建外部类，然后使用外部类的实例创建普通内部类
写法一：

		//创建外部类对象
		Fruit fruit = new Fruit();
		//创建内部类对象
		Fruit.Apple apple = fruit.new Apple();
		//内部类对象调用方法
		int fruitType = apple.getFruitType();
		System.out.println(fruitType);

写法二：

		Fruit.Apple apple = new Fruit().new Apple();
		int fruitType = apple.getFruitType();
		System.out.println(fruitType);

小结：
内部类的访问特点：

1. 内部类可以直接访问外部类的成员，包括外部类的私有属性。
2. 外部类要访问内部类的成员，必须先创见对象。

静态内部类

静态内部类的定义：
静态内部类就是一个Java类，它可以访问外部类的静态成员和静态方法，不能访问外部类的实例成员和实例方法。

package com.ycy1;

//外部类
public class Fruit {
	private int type = 10;

	public int getType() {
		return type;
	}

	private static int price = 100;

	public static int getFruitPrice() {
		return price;
	}

	// 内部类
	static class Apple {
		private String name;

		public String getName() {
			return name;
		}

		// public int getFruitType() {
		// //静态类不能访问外部成员变量
		// int type = Fruit.this.type;
		// return type;
		// }

		// public int getValue() {
		// //静态类不能访问外部类的成员方法
		// return Fruit.getFruitType();
		// }

		public static int getValue() {
			// 静态类能访问外部类的静态变量
			return Fruit.price;

		}

		public int getFruitPrice() {
			// 静态内部类能访问外部类的静态方法
			return Fruit.getFruitPrice();
		}
	}

}

静态内部类的使用
创建静态内部类时，不需要创建外部类的实例，直接使用 new Friut.Apple()语法就可一创建一个实例。
如果静态内部类中有静态成员和静态方法，那么调用方式：Fruit.Apple.getValue();

		Fruit.Apple a = new Fruit.Apple();
		System.out.println(a.getName());//静态成员变量
		System.out.println(Fruit.Apple.getValue());//静态类能访问外部类的静态方法

局部内部类

包含在外部类的函数中的内布类称之为局部内部类。这种内部类一班不用，知道方式就行。
局部内部类只能访问所在函数的final属性。

匿名对象

1. 没有名字
2. 仅能使用一次

匿名内部类

匿名内部类是一种特殊的内部类，它在语句内部定义，没有类名。例如：在GUI程序中作为时间处理函数
	匿名内部类必须继承一个父类或者是实现一个接口。语法格式：
	new 父类或接口(){
		执行代码···
	}；
	每次创建匿名内部类的对象时，必须先定义匿名内部类，然后马上使用new创建对象。如果希望再次创建这个匿名内部类的对象，必须重新定义匿名内部类，即每个匿名内部类的定义只能使用一次。

基于接口实现匿名内部类

public interface Goods {
	public double getPrice();
	public String getName();
}

public class Demo2 {

	public static void main(String[] args) {
		Demo2 demo2 = new Demo2();
		demo2.printGood(new Goods() {
			@Override
			public double getPrice() {
				// TODO Auto-generated method stub
				double price = 9.5;
				return price;
			}

			@Override
			public String getName() {
				// TODO Auto-generated method stub
				String name = "方便面";
				return name;
			}
		});
	}

	// 打印商品信息
	public void printGood(Goods g) {
		System.out.println(g.getName());
		System.out.println(g.getPrice());
	}
}

基于类实现匿名内部类

public abstract class Animal {
	public abstract void run();
	public abstract void sleep();
}

public class Demo3 {
	public static void main(String[] args) {
		Demo3 demo3 = new Demo3();
		demo3.printAnimal(new Animal() {

			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("小狗在睡觉！");
			}

			@Override
			public void sleep() {
				// TODO Auto-generated method stub
				System.out.println("小狗在奔跑！");
			}
			
		});
	}
	
	public void printAnimal(Animal a) {
		a.sleep();
		a.run();
	}