（43）Java基础 --匿名内部类

目录

一、内部类的概念

二、使用内部类的理由

三、内部类的分类

四、普通的成员内部类

五、私有的成员内部类

六、静态的成员内部类

七、局部内部类

八、匿名内部类【常用】

---

一、内部类的概念

在一个类内部定义的类叫做内部类。包含这个内部类的类叫做外部类。

一个器件可能会包含专用的内部器件，内部类的作用相当于这些内部器件。

public class Demo01_内部类概述 {
	private int id;
	private String name;
	class MyInner{//内部类	
	}
}

class A{// 不是内部类	
}

二、使用内部类的理由

1避免名字的泛滥。生成的.class模式为：外部类名$内部类名。

2 内部类可以直接使用其外部类的私有成员。

三、内部类的分类

1. 根据定义的位置不同，可以分为：

      成员内部类

      局部内部类

（1）成员内部类：

      普通的成员内部类

      私有的成员内部类

      静态的成员内部类

（2）局部内部类

2. 根据表示的方式不同，可以分为：

     有名字的内部类

   【匿名内部类】

四、普通的成员内部类

定义在成员位置上的类，就是成员内部类。

格式：

class 外部类{

     class 内部类类名 {

         内部类成员

     }

}

成员内部类的说明：

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

  2、外部类访问内部类的成员，必须先创建内部类的对象

  3、在外部类以外，创建内部类的对象的格式：

    外部类名.内部类名 内部类对象名 = new 外部类名().new 内部类名();

public class Demo02_普通成员内部类 {
public static void main(String[] args) {
Body b = new Body();
	  b.hello();
		
//在其他类中创建内部类对象  先有外部类对象才能创建内部类对象         内部类的类名为:外部类类名.内部类类名
	  Body.Heart h = new Body().new Heart();
	  h.show();		
	}
}

class Body{  //外部类
	private double height= 180.0;  // 外部类的私有成员变量
	class Heart{ //普通成员内部类
		int beats = 70;  //内部类的成员变量
		public void show(){
			System.out.println("我所在的身体身高为"+height+"每分钟跳动"+beats+"次");
		}
	}
	
	public void hello(){  // 外部类的成员方法——要调用内部类的方法——先创建内部对象才能访问
		Heart h = new Heart();  //在外部类中创建内部类对象的方式
		h.show();
	}
}

在普通成员内部类中有两个this

class Outer{
	private int id = 1;
	private String name="张三";
	
	class Inner{
		private String name="小毛";  // 内部类中定义了一个和外部类同名的变量
		public void sayHello(){
			System.out.println(id);
			System.out.println(name);        //内部类的成员
			System.out.println(this.name);   //内部类的成员
			System.out.println(Outer.this.name); // 外部类成员
		}
	}
}

五、私有的成员内部类

也是一个成员内部类，在成员内部类前面加上一个private关键字

访问方式：

  1、在外部类以外，不能直接访问外部类中的私有成员内部类

  2、可以在外部类中，定义一个访问私有成员内部类的公有方法，让外界可以调用公有方法，间接的访问外部类中的私有成员内部类。

public class Demo03_私有成员内部类 {
	 public static void main(String[] args) {
		 Body2 b2 = new Body2();
		 b2.hello();
		 //Body2.Shen shen = new Body2().new Shen(); 在其他类中不能创建私有成员内部类的对象
	}
}

class Body2{  //外部类
	private double height=190.0;
	private class Shen{  // 私有成员内部类
		int age = 40;
		public void show(){
			System.out.println("该走心的时候别TM找我..." + height + "..." + age);
		}
	}
	public void hello(){
		Shen shen = new Shen();
		shen.show();
	}
}

六、静态的成员内部类

也是一个成员内部类，在成员内部类前面加上一个static关键字

访问方式：

  1、成员内部类是外部类的静态成员，所以可以通过外部类名.内部类名的方式直接访问，而不需要创建外部类的对象

  2、静态内部类中的非静态成员，需要将所在的内部类对象创建出来之后，才能被调用。

  3、总结：一个类是否需要创建对象，不取决于该类本身是否是静态，而取决于要访问 的成员是否是静态

静态成员内部类的对象创建格式：

  外部类名.内部类名 内部类对象名 = new 外部类名.内部类名();

public class Demo04_静态成员内部类 {
	  public static void main(String[] args) {
 
		  Body3.Gan gan = new Body3.Gan();
		  gan.show();
	}
}

class Body3{  //外部类
	private double height=150.0;
	static class Gan{
		String color="黑色";
		
		public  void show(){
// 静态成员内部类中无法访问外部类的非静态成员  如果要访问，需要先创建外部类的对象
//System.out.println(height + "..." + color + "求你了哥，放过我吧别喝了");
			Body3 b = new Body3();
			System.out.println(b.height + "..." + color + "求你了哥，放过我吧别喝了");
		}
	}
	public void hello(){
		Gan gan = new Gan();
		gan.show();
		//Gan.show();
	}
}

七、局部内部类

局部内部类：定义在方法中的内部类

局部内部类的访问方式：

  方法中的局部变量，外界都没有办法访问到

  所以方法中定义的内部类，外界也没有办法访问到

解决方式：

  在方法内部，就创建局部内部类的对象，调用对象的方法

  外界调用局部内部类所在的方法，间接的创建局部内部类的对象，间接的访问局部内部类的方法

public class Demo05_局部内部类 {
	public static void main(String[] args) {
		Body4 b = new Body4();
		b.breath();
	}
}

class Body4{  //外部类
	private double height = 160.0;
	public void breath(){
		//final int age = 30;
		int age = 30;
		
		class Fei{  // 局部内部类
			private String color="黑色";
			public void show(){
				System.out.println(age + "..." + color + "...饶了我吧受不了了太呛了"+"..."+height);
			}
		}
		
		Fei fei = new Fei();
		fei.show();
		
	}
}

局部内部类访问方法局部变量和方法参数的问题

当局部内部类中取访问方法的参数或者方法的局部变量时，要求方法的参数或者局部变量必须被final修饰。jdk1.8中没有强制添加final关键字

 

为什么会有这样的要求

即使是内部类，生命周期也比 局部变量的生命周期长！所以，添加final的意义是增长局部变量的生命周期

八、匿名内部类【常用】

没有名字的内部类

匿名内部类的使用前提：

  匿名类：继承一个类

  匿名类：实现一个接口

格式：

new 父类类名或者接口名() {

     父类方法的重写或者是接口内容的实现

}

本质：创建了一个类的子类对象、接口的实现类对象

public class Demo06_匿名内部类 {
	public static void main(String[] args) {
	// 创建了一个实现了IPlay接口的匿名内部类，并创建了它的对象
		IPlay p = new IPlay(){
			public void playGame() {
				System.out.println("玩游戏");
			}
		};
		p.playGame();

		// 创建了一个继承自Object的匿名内部类并创建了对象
		Object obj = new Object(){
			public void sayHello(){}
			public String toString() {
				return super.toString();
			}
		};
		
		//obj.sayHello();
		Date d = new Date(){
			
		};
	}
}

interface IPlay{     // 接口
	void playGame();
}

/*
class PlayImpl implements IPlay{  // 实现类

	public void playGame() {  // 实现接口中的方法
		System.out.println("玩游戏###");
	}
}*/

上一篇：（42）Java基础 --包装类

下一篇：（44）Java基础 --异常