1 内部类

1.1 内部类概述

  • 在一个类的内部定义另外一个类，那么另外一个类则称作为内部类。
  • 内部类的class文件名： 外部类$内部类.class
  • 成员内部类的访问方式：（普通的访问方法）
    • 方式一：在外部类提供一个方法创建内部类的对象进行访问。
    • 方式二：在其他类中直接创建内部的对象进行访问。

      格式：外部类.内部类 变量名 = new 外部类().new 内部类();

疑问: 什么时候使用内部类呢?
当我们分析事物时，发现事物的内部还有具体的事物，这时则应该定义内部类了。比如人体是一个类，人体有心脏，心脏的功能在直接访问人体的其他内容。这时就将心脏定义在人体类中，作为内部类存在。
内部类的优势: 成员内部类作为外部类的成员，那么可以访问外部类的任意成员。

1.2 外部类访问内部类的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Outer {
	int num=10;
	
	class inter{
		int count=20;
		public void print(){
			System.out.println(num);
		}
	}
	
	public void show(){
		new inter().print();
	}
	
	public static void main(String[] args) {
		new Outer().show();   //10
	}
}

1.3 成员内部类访问细节

1
2
3
4
5
6
7
private class inter{ 
//私有的内部类，只能在当前的外部类可见。
	int count=20;
	public void print(){
		System.out.println(num);
	}
}

1、私有的成员内部类不能在其他类中直接创建内部类对象来访问。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Outer{
	static class inter{
	 	static int num2=2;
		public void print(){
			System.out.println(1);
		}
	}
}

public class Test {
	public static void main(String[] args) {
	Outer.inter	oi=new Outer.inter();
	}
}

2、如果内部类中包含有静态成员，那么java规定内部类必须声明为静态的访问静态内部类的形式：
Outer.Inner in = new Outer.Inner();
*总结: 成员内部类(成员属性、成员方法)

  1. 私有的成员内部类
    • 特点：不能在其他类中直接创建内部类对象来访问
  2. 静态的成员内部类
    • 特点：如果内部类中包含有静态成员，那么java规定内部类必须声明为静的访问静态内部类的形式:Outer.Inner in = new Outer.Inner();

1.4 成员内部类注意的细节

  • 内部类可以直接访问外部类的所有成员。
  • 内部类与外部类存在同名的成员时， 在内部类中默认是访问内部类的成员，可以通过”外部类.this.成员”进行指定访问外部类的成员。
  • 私有的成员内部类只能通过在外部类提供一个公共的方法进行访问。 在其他类无法访问。
  • 如果一个成员内部类定义了静态的成员，那么该类也必须使用static修饰。

2. 局部内部类

2.1 局部内部类概述

局部内部类概述: 包含在外部类的函数中的内部类称之为局部内部类。
访问: 可以在包含局部内部类的方法中直接创建局部内部类的对象调用局部内部类的成员。
注意: 局部内部类只能访问所在函数的final属性。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*内部类定义在类中的局部位置
内部类定义局部位置上，只能访问该局部中被final修饰的常量*/
class Outer{
	int num=4;
	public void method(final int x){
		final int y=3;
		class Inter{
			void show(){
				System.out.println("run_show"+Outer.this.num);
				System.out.println(x);
				System.out.println(y);
			}
		}
		new Inter().show();	
	}
}

public class Test {
	public static void main(String[] args) {
		new Outer().method(5);
	}
}

3. 匿名内部类

  1. 匿名内部类其实就是内部类的简写格式。
  2. 定义匿名内部类的前提：
    • 内部类必须是继承一个类或者实现接口。
  3. 匿名内部类的格式： new 父类或者接口(){定义子类的内容}
  4. 其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
  5. 匿名内部类中定义的方法最好不要超过3个。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    interface Show{
    	public abstract void show();
    }

    class Outer{
    /*	class Inter{
    		public void show(){
    			System.out.println("内部类show方法");
    		}
    	}
    	public void print(){
    		new Inter().show();
    	}
    	*/
    	
    	public void print(){
    		new Show(){
    			public void show() {
    				System.out.println("匿名内部类show方法");
    			}
    		}.show();
    	}
    }

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

​