Java内部类

Java内部类：就是讲一个类定义另一个类的内部

内部类的特点：

１．可以很好的实现隐藏，使用protected,private关键字修饰

２．内部类可以直接访问外部类的所有成员，包括私有成员

３．外部类不能直接访问内部类成员，必须首先建立内部类的对象才可以访问

４．内部类可以解决一些问题，例如间接实现多继承，可以避免修改接口而实现同一个类中的两种同名方法的调用

内部类分类：

１．成员内部类

２．静态内部类

３．匿名内部类

４．局部内部类

１．成员内部类

成员内部类属于外部类的实例成员，成员内部类可以有public private default protected修饰，在成员内部类中访问外部类的成员方法和属性，要使用”外部类名．this．成员方法“和”外部类名．this．成员属性“的形式来访问。

创建成员内部类格式：外部类名　外部类实例变量名　＝　ｎｅｗ　外部类名（）；

　　　　　　　　　外部类名．内部类名　内部类实例变量名　＝　外部类实例变量名．ｎｅｗ　内部类名（）；

成员内部类的限制：

１．成员内部类不能与外部类重名

２．不能在成员内部类中定义ｓｔａｔｉｃ属性，方法和类（static final 常量定义除外）

下面是一个例子：

package com.pyj.inner;


public class MemberInnerClass {
	public static void main(String[] args) {
		// 创建外部类的对象
		Outer outer = new Outer();
		outer.outerShow();
		// 创建内部类对象
		Outer.Inner inner = outer.new Inner();
		inner.innerShow();
	}
}

// 定义一个外部类
class Outer {
	private String name = "张三";
	private int age1 = 18;

	public void outerShow() {
		System.out.println(name + "====" + age1);
	}

	// 内部类
	public class Inner {
		private String name = "李四";
		private int age2 = 20;

		public void innerShow() {
			System.out.println(name + "=======" + age2);
		}
	}
}

２．静态内部类

静态内部类的特点：

１．使用static修饰成员内部类叫静态内部类

２．静态内部类跟外部类没有任何关系，只是在生成类名和类定义时有影响

３．静态内部类可以看做是外部类的平级类，使用方式与外部类完全相同

创建静态内部类格式：外部类名．内部类名　实例名　＝　ｎｅｗ　内部类名（）；

　　　　　　　　　或者　外部类名．内部类名　实例名　＝　ｎｅｗ　内部类名．外部类名（）；

静态内部类限制：

１．不能重名

２．静态内部类不能访问外部类非静态的属性和方法，外部类不能访问内部类的非静态的属性和方法

实例如下：

package com.pyj.inner;

import com.pyj.inner.Outer1.Inner1;

public class StaticInnerClass {
	public static void main(String[] args) {
		//构造一个静态内部类对象
		//Outer1.Inner1 inner = new Inner1();
		//inner.innerShow();
		Outer1.Inner1 inner = new Outer1.Inner1();
		inner.innerShow();
		Outer1 out = new Outer1();
		out.outerShow();
	}
}

//创建一个外部类
class Outer1{
	private String name = "张三";
	private int age1 = 18;
	private static int age3 = 100;
	public void outerShow() {
		System.out.println(name+"==="+age1);
		//访问静态类中非静态属性需要实例化
		Inner1 inner = new Inner1();
		System.out.println(inner.name);
		//访问静态属性，直接类名．属性
		System.out.println(Inner1.age3);
	}
	public static class Inner1{
		private String name = "李四";
		private int age2 = 20;
		private static int age3 = 300;
		public void innerShow() {
			//System.out.println(Outer.this.name);
			//静态内部类不能访问外部类的非静态成员
			System.out.println(Outer1.age3);
			System.out.println(name+"==="+age2);
		}
	}
}

３．匿名内部类

匿名内部类特点：

１．匿名内部类是没有名称的内部类，没有办法引用他们，必须在创建时作为ｎｅｗ语句的一部分来声明并创建他们的实例。

２．匿名内部类必须继承一个类（抽象，非抽象，接口）

３．匿名内部类可以定义代码块，用于实现初始化，但是不能定义静态代码块

语法格式：new interface/superclass{//类实体}

具体实现如下：

package com.pyj.inner;

public class AnonymousInnerClass {
	public static void main(String[] args) {
		Person p = new Person();
		new IAnimal() {
			@Override
			public void eat() {
				//抽象类中的抽象方法
				System.out.println("吃饭");
			}
			//接口或者抽象类中没有的方法
			public void show() {
				System.out.println("小明");
			}
		}.show();//匿名内部类调用内部方法
		
		p.feed(new IAnimal() {
			
			@Override
			public void eat() {
				System.out.println("吃肉");
			}
		});
	}
}
//创建一个人，会喂食动物的方法,动物可以使用接口或者抽象类来实现
class Person{
	public void feed(IAnimal animal) {
		animal.eat();
	}
}
interface IAnimal{
	public abstract void eat();
}
/*abstract class Animal{
	public abstract void eat();
}*/

４．局部内部类

局部内部类特点：

１．定义在代码块，方法体内的类叫局部内部类

２．局部内部类访问外部类的属性和方法

　　外部类名．ｔｈｉｓ．属性名

　　外部类名．ｔｈｉｓ．方法名（参数）

３．对外部完全隐藏，只能在作用域内生成对象

限制：

１．局部内部类不能加访问修饰符，因为它不是类成员

２．不能与外部类重名

３．局部内部类访问作用域内的局部变量需要使用ｆｉｎａｌ修饰

例子如下

package com.pyj.inner;

public class LocalInnerClass {

}
//创建一个外部类
class Outer2{
	private String name = "张三";
	private int age1 = 18;
	private static int age2 = 100;
	public void outerShow() {
		final int age4 = 1000;
		//局部内部类不能添加访问修饰符
		class Inner2{
			private int age1 = 20;
			private int age3 = 30;
			public void innerShow() {
				System.out.println(age3);
				System.out.println(age1);
				//访问外部非静态变量
				System.out.println(Outer2.this.age1);
				//访问外部静态变量
				System.out.println(Outer2.age2);
				//局部内部类只能访问其声明方法中的常量
				System.out.println(age4);
			}
		}
		Inner2 inner = new Inner2();
		inner.innerShow();
	}
}