黑马程序员---Java基础---内部类

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ 

一、内部类概述：

把类定义到其他类的内部，这个类就被称为内部类。

举例：在类A中定义了一个类B，类B就是内部类。

二、内部类的访问特点：

a：内部类可以直接访问外部类的成员，包括私有的。

b：外部类要访问内部类的成员，必须创建对象。

package cn.hebei.sjz_内部类;

/*
 * 内部类的访问特点
 */
class Outer {
	private int num = 20;

	class Inner {
		public void show() {
			System.out.println(num);// 内部类可以直接调用外部类的成员，包括私有的。
		}
	}

	public void method() {
		// 创建内部类对象
		Inner i = new Inner();
		i.show();
	}
}

public class Demo {
	public static void main(String[] args) {
		// 调用内部类中的show（）方法
		Outer o = new Outer();
		o.method();
	}
}

三、内部类分类：

a：按照内部类位置分类

成员位置：在成员位置定义的类，被定义为成员内部类。

在测试类中直接访问内部类的成员的方法：

外部类名.内部类名  对象名 = 外部类对象.内部类对象；

局部位置：在局部位置定义的类，被定义为局部内部类。

package cn.hebei.sjz_内部类;

/*
 * 成员内部类的直接使用
 */
class Outer1 {
	private int num = 20;

	//成员内部类
	class Inner1 {
		public void show() {
			System.out.println(num);
		}
	}
}

public class Demo2 {
	public static void main(String[] args) {
		//直接访问成员内部类的成员
		Outer1.Inner1 oi = new Outer1().new Inner1();
		oi.show();
	}
}

四、成员内部类private修饰符

成员内部类相当于外部类的一个成员，被private修饰的成员不能直接访问，隐藏了内部类,外界无法直接访问了,保证数据的安全性。

package cn.hebei.sjz_内部类;

/*
 * 成员内部类修饰符private
 */
class Outer3 {
	private int num = 20;

	private void show2() {
		System.out.println(num);
	}

	// 被private修饰的成员内部类
	private class Inner3 {
		public void show() {
			System.out.println(num);
		}
	}

	// 提供公共的访问方法
	public void method() {
		Inner3 i = new Inner3();
		i.show();
	}
}

public class Demo3 {
	public static void main(String[] args) {
		// 创建外部类对象
		Outer3 o = new Outer3();
		// 通过外部类的公共方法访问成员内部类的show（）方法
		o.method();
	}
}

五、成员内部类static修饰符

使用static修饰符是为了方便访问数据。

调用静态成员    类名.方法名

注意： a、静态内部类访问的外部数据必须用静态修饰（指的是调用）。

b、内部类中的成员方法可以是静态的，也可以是非静态的（指的是定义）。

访问静态的成员内部类的格式：外部类名.内部类名   方法名  = new 外部类名.内部类名；

package cn.hebei.sjz_内部类;

/*
 * 成员内部类的static修饰符
 */
class Outer4 {
	private static int num = 20;

	public static void show2() {
		System.out.println("外部类方法");
	}

	// 静态成员内部类
	static class Inner4 {
		public void show() {
			System.out.println(num);
			show2();
		}
	}
}

public class Demo4 {
	public static void main(String[] args) {
		// 访问静态成员内部类
		Outer4.Inner4 oi = new Outer4.Inner4();
		oi.show();
	}
}

六、局部内部类访问局部变量

a：可以直接访问外部类成员，包括私有的。

b：可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能。

c：局部内部类访问局部变量必须使用final修饰符。

因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

package cn.hebei.sjz_内部类;

/*
 * 局部内部类访问局部变量
 */
class Outer5 {
	private int num = 20;

	public void method() {
		// 局部变量用final修饰
		final int num2 = 30;

		// 局部内部类
		class Inner5 {
			public void show() {
				System.out.println(num);
				System.out.println(num2);
			}
		}
		Inner5 i = new Inner5();
		i.show();
	}
}

public class Demo5 {
	public static void main(String[] args) {
		// 通过外部类对象调用method（）方法
		Outer5 o = new Outer5();
		o.method();
	}
}

七、匿名内部类

A：匿名内部类：就是内部类的简化写法。

B：前提：存在一个类（可以是具体类，也可以是抽象类）或者接口。

C：格式：  new 类名或者接口名（）{

重写方法；

  }；

D：本质是一个继承了该类或实现了改接口的子类匿名对象。

package cn.hebei.sjz_匿名内部类;

/*
 * 匿名内部类
 */
interface Animal {
	// 接口中的方法都是抽象方法，没有语句体
	public abstract void eat();

	public abstract void sleep();
}

public class Demo {
	public static void main(String[] args) {
		// 用接口引用指向该实现类的匿名对象
		Animal a = new Animal() {
			public void eat() {
				System.out.println("吃东西");
			}

			public void sleep() {
				System.out.println("睡好觉");
			}
		};
		a.eat();
		a.sleep();
	}
}