面向对象—内部类、外部类

一、内部类定义

将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类。

二、何时使用内部类

在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述。

三、内部类分类

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符、继承与实现关系等。在内部类中可以直接访问外部类的所有成员。

四、内部类的定义格式

1、成员内部类定义格式

class 外部类 { 
	修饰符 class 内部类 {
		//其他代码
    }
}

访问方式：外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

代码演示

（1）定义类：

package itcast.demo07;

public class Outer {
	 int i = 1;
	//外部类成员位置，定义内部类
	class Inner{
		int i = 2;
		public void inner() {
			int i = 3;
			System.out.println(Outer.this.i);
			System.out.println(this.i);
			System.out.println(i);
		}
	}
}

（2）调用内部类：

package itcast.demo06;

public class Test {
	public static void main(String[] args) {
		/*
		 * 调用外部类中的内部类方法inner()
		 * 依靠外部类对象，找到内部类，再通过内部类对象，调用内部类的方法
		 * 格式：
		 * 		外部类名.内部类名  变量  =  new  外部类对象().new  内部类对象();
		 */
		Outer.Inner in = new Outer().new Inner();
		in.inner();
	}

}

访问结果：1,  2,   3

2、局部内部类定义格式：

class 外部类 { 
	修饰符 返回值类型 方法名(参数) {
class 内部类 {
//其他代码
        }
    }
}

访问方式：在外部类方法中，创建内部类对象，进行访问

代码实现：

（1）定义类：

package itcast.demo08;
/*
 * 局部内部类
 * 	将一个类，定义在方法中
 */
public class Outer {
	
	public void out() {
		
		class Inner{
			public void inner() {
				System.out.println("局部内部类方法");
			}
		}
		
		Inner in  = new Inner();
		in.inner();
	}
	
}

（2）访问类：

package itcast.demo08;

public class Test {
	public static void main(String[] args) {
		//调用局部内部类的方法inner
		Outer ou = new Outer();
		ou.out();
	}
}

五、匿名内部类

      作用：匿名内部类是创建某个类型子类对象的快捷方式。

      格式：

new 父类或接口(){
	//进行方法重写
};

代码演示：

（1）定义类

package itcast.demo09;

public interface Smoking {
	public abstract void smoking();
}
/*
 * 实现类，实现接口，重写接口抽象方法，创建实现类对象
 * class XXX implements Smoking{
 * 		public void smoking(){
 * 		
 * 		}
 * 	}
 * XXX x = new XXX();
 * x.smoking();
 * Smoking s new XXX();
 * s.smoking();
 * 
 * 匿名内部类，就是一个简化问题：
 * 		定义实现类，重写方法，建立实现类对象，合为一步完成
 */

（2）定义测试类

package itcast.demo09;

public class Test {
	public static void main(String[] args) {
		//使用匿名内部类
		/*
		 * 定义实现类，重写方法，创建实现类对象，一步实现
		 * 格式：
		 * 		new 接口或者父类(){
		 * 			重写抽象方法
		 * 		}.方法;
		 * 
		 * 		从new开始到逗号结束，都是在创建接口的实现对象
		 */
		new Smoking() {			
			public void smoking() {
				System.out.println("人在吸烟");				
			}			
		}.smoking();
	}

}

两种方法是同等的，匿名内部类就是代码少了而已。。。。。。。。。。。。。