内部类(匿名内部类)

内部类(次重点)
(1)把一个类定义在某个类中的，这个类就被称为内部类，内置类，嵌套类。
(2)访问特点：
A:内部类可以直接访问外部类中的成员，因为内部类持有外部类的引用，
 格式为：外部类名.this
B:外部类要想访问内部类的成员，必须创建对象访问。
(3)内部类的访问格式：
A:当内部类定义在外部类的成员位置，而且非私有，则可以在其他外部类中直接建立内部类对象
 格式：外部类名.内部类名  变量名 = new 外部类对象.内部类对象
如：Outer.Inner in = new Outer().new Inner()
B:当内部类在外部类成员位置，且被static修饰时
**外部其他类可直接访问静态内部类的非静态成员
 格式：new 外部类名.内部类名().内部类成员
 如：new Outer.Inner().function();
**外部其他类可直接访问静态内部类的静态成员
 格式：new 外部类名.内部类名.内部类成员
 如：new Outer.Inner.function();
(4)什么使用时候内部类呢？
假如有A类和B类，A类想直接访问B类的成员，B类访问A类成员的时候，
需要创建A类对象进行访问，这个时候，就可以把A类定义为B类的内部类。
(5)内部类的位置
A:成员位置
**可以被private修饰(Body，Heart)
**可以被static修饰。(它访问的外部类的成员必须是静态的)
B:局部位置
**可以直接访问外部类中的成员，因为还持有外部类的持用
也可以直接访问局部成员，但是局部成员要用final修饰。  
注意：局部内部类不能用private和static修饰
(6)通过class文件我们就可以区分是否带有内部类，以及内部类的位置
Outer$Inner:成员内部类

Outer$1Inner:局部内部类

代码演示：

class  InnerDemo
{
	public static void main(String[] args) 
	{
		new Outer().getInner().print();
	}
}

class Outer
{
	private String name = "haoren";
	class Inner
	{
		public void print(){
			System.out.println(name);
		}
	}
	public Inner getInner(){
		Inner in =  new Inner();
		return in;
	}
}

使用static定义内部类：

class  InnerDemo
{
	public static void main(String[] args) 
	{
		//new Outer().getInner().print();
		new Outer.Inner().print();
	}
}

class Outer
{
	private static String name = "haoren";
	static class Inner
	{
		public void print(){
			System.out.println(name);
		}
	}
}

方法中的内部类：

class Outer{
  private String info = "hello world";//定义内部类
  public void fun(final int temp){  //参数要被访问之前必须用final
      class Inner{  //在方法中定义内部类
          public void print(){
              System.out.println(""+);
              System.out.println(""+);
          }
      };
      new Inner().print();
  }
}

28、匿名内部类(局部内部类的简写) (重点)
(1)前提：继承一个类或者实现一个接口
(注意不要弄混匿名内部类的前提和多态的前提)
(2)格式：
new 父类名或者接口名()
{
重写父类方法或者实现接口中的方法。
也可以自定义其他方法。
};
(3)什么时候定义匿名内部类？
匿名内部类只是为了简化书写，匿名内部类有局限，通常定义匿名内部类时，该类方法不超过3个
(4)匿名内部类的好处和弊端：
好处：简化代码书写
弊端：
不能直接调用自己的特有方法
不能执行强转换动作

如果该类里面方法较多，不允许使用匿名内部类

代码：

class NoNameDemo 
{
	public static void main(String[] args) 
	{
		Do d = new Do();
		//d.print(new B());
		d.print(new A(){public void test(){
		System.out.println("haha");
	}});
	}
}
interface A
{
	void test();
}
/*
class B implements A
{
	public void test(){
		System.out.println("hahah");
	}
}
*/
class Do
{
	public void print(A a){
		a.test();
	}

}