Java学习笔记（35）—— 内部类

这里将自己学习java及其应用的一些笔记、积累分享一下，如果涉及到了文章、文字侵权，请联系我删除或调整。

---

一、内部类

1.1 概述

• 内部类：嵌套定义在类内部，或方法内部，或局部代码块内部的类
• 可分为：

非静态内部类

静态内部类

局部内部类

匿名内部类

1.2 非静态内部类

class A {

      class Inner {

      }

}

• Inner对象，必须依赖于外部对象才能存在
• 不能独立创建对象
• Inner 对象，属于一个 A 对象
• 非静态内部类中，不能定义静态成员

​​​​​​​A a1 = new A()

A a2 = new A()

Inner i = a1.new Inner();

1.3 静态内部类

class A {

       static class Inner {

       }

}

• 静态内部类，可以独立创建对象

Inner i = new Inner();

1.4 局部静态类

• 定义在局部代码块中的类型，只能在局部使用

​​​​​​​​​​​​​​class A {

        Weapon f() {

                class Inner implements Weapon {

               }

              Inner i = new Inner();

             return i;

      }

}

A a = new A();

Weapon w = a.f();

1.5 匿名内部类

Weapon w = new Weapon() {};

• 大括号：匿名类
• new：新建匿名类的对象
• Weapon：父类型
• 小括号：super()、super(参数)

​​​​​​​​​​​​​​​​​​​​​1.6 练习：静态内部类、非静态内部类

package 内部类;

import 内部类.A.Inner1;

/*
 *	内部类测试 
 */
public class Test1_静态类与非静态类 {
	public static void main(String[] args) {
		/*	相关内部类使用方法：
		 * 	1.	A.Inner1;外部类类名.内部类名-调用
		 * 	2.	Inner1;先加载对应的类，通过类名可直接调用
		 */
		Inner1 d1 = new Inner1();// 通过方法1使用内部类
		System.out.println(d1);// 默认调用toString，显示地址
		
		/*
		 *	非静态内部类的使用方法与上述一样
		 */
		A a1 = new A();
		A a2 = new A();
		A.Inner2 d2 = a1.new Inner2();// 通过方法2使用内部类
		System.out.println(d2);
		
	}
}

class A{
	static class Inner1{
		
	}
	
	class Inner2{
		
	}
}

1.7 练习：局部内部类

package 内部类;

public class Test2_局部内部类 {
	public static void main(String[] args) {
		Weapon w1 = f1();// f1()方法代码中定义局部内部类并实现了Weapon接口,返回其对象
		System.out.println(w1);
		// 内部类.Test2_局部内部类$1AK47@659e0bfd
		/* 其中，内部类的类名被编译为“Test2_局部内部类$1AK47”，
		 * 其中，$1是编译器添加的内部类的编号*/
		w1.kill();
		System.out.println("-------------------------------------");
		
		Weapon w2 = f2("青龙偃月刀");// f2()方法，得到指定名字的武器
		System.out.println(w2);
		w2.kill();
	}

	// 局部内部类，匿名类实现
	private static Weapon f2(final String name) {// 局部内部类中，使用外面的一个局部变量，必须加final(1.8版本后缺省)
		// 匿名类-不命名的类，只用大括号括起来
		/* 匿名类的声明，在定义的同时新建对象:
		 * 	类名/接口 引用变量名 = new 父类/父接口(){...};
		 *	其中，	new 新建一个匿名类对象
		 *			父类/父接口，表示继承的类或接口
		 *			()表示调用父类构造方法，super()或super(参数)；
		 *			｛...｝表示匿名类
		 *			;不能少，因为是赋值语句
		 */
		Weapon w = new Weapon(){
			@Override
			public void kill() {
			// 局部内部类中，使用外面的一个局部变量，必须加final(1.8版本后缺省)
				System.out.println("使用"+name+"攻击！");
			}
		};
		return w;
	}
	
	// 局部内部类，显示定义
	private static Weapon f1() {
		class AK47 implements Weapon{
			@Override
			public void kill() {
				System.out.println("AK47");
			}
		}
		// 局部的类，只能在局部使用
		// 但是他的对象，可以作为父类型向外传递
		AK47 ak = new AK47();
		return ak;
	}
}

1.8 练习：匿名内部类

ArrayList集合中存放一组数字格式的字符串， 并进行自定义的排序。例如"1" ，"10" ，"11" ，"2" ，"20" ，"21" ，"3"。

package 内部类;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class Test3 {
	public static void main(String[] args) {
		ArrayList<String> list = new ArrayList<String>();
		// 一次向list添加多个值
		Collections.addAll(list, 
		/* Collections.addAll(c, elements)
		* 向集合c添加内容elements,其中elements可以包含多个数据 
		*/
				"1","4","7","21","6","54",
				"41","53","12","76","16","34",
				"43","56","111","234","15","90");
		System.out.println(list);//默认toString
		Collections.sort(list);
		System.out.println("默认排序（字符编码）："+list);
		
		// 为Collections.sort()添加Comparator<T>接口子类对象，指定具体比较方法
		Comparator<String> c = new Comparator<String>() {// 定义匿名类并new对象
			@Override
			public int compare(String o1, String o2) {
				int a = Integer.parseInt(o1);
				int b = Integer.parseInt(o2);
				return a-b;
				}
		};
		// 利用实现接口的类对象，重新排序
		Collections.sort(list, c);
		/*
		 *	比较器对象c被传递到sort()方法内部，
		 *	在sort()内部会调用c.compareTo(...)
		 *	并根据该方法结果来判断数据的大小
		 */
		System.out.println("排序器："+list);
	}
}