内部类的定义和使用

最新推荐文章于 2022-09-30 00:18:02 发布

mrbacker

最新推荐文章于 2022-09-30 00:18:02 发布

阅读量2.3k

点赞数 2

分类专栏： Java基础文章标签：内部类

本文链接：https://blog.csdn.net/mrbacker/article/details/84500918

版权

Java基础专栏收录该内容

39 篇文章 65 订阅

订阅专栏

对于内部类的定义使用暂时不作为首要类设计原则。

内部类的基本概念

所谓的内部类指的就是一个类的内部进行其它类结构嵌套的操作语法形式。理论上可以一层层进行类的嵌套。

范例： 内部类的基本使用

class Outer {  //定义一个外部类
	private String msg = "Hello World！";
	class Inner { //此时定义了一个内部类
		public void print() { //定义一个普通方法
			System.out.println(msg); //调用msg属性
		}
	}
	//在外部类之中定义一个方法，这个方法负责产生内部类对象并且调用print()方法
	public void fun() {
		Inner in = new Inner(); //内部类对象 
		in.print(); //内部类提供的print()方法
	}
}
public class TestDemo {
	public static void main(String[] args) {
		Outer out = new Outer(); //外部类对象
		out.fun();  //调用了外部类的方法
	}
}

通过以上的代码实际上就可以立刻发现一个问题：程序的结构有些混乱。虽然内部类破坏了程序结构，从整体上来讲不好，但是从另外一方面来讲，内部类也是有优点，在于外部类的私有访问。

范例： 将以上程序的内部类提取到外部，要求实现同样的功能

Outer和Inner是两个独立的类，而且Inner类需要访问Outer类中的msg属性，但是Outer类中msg属性使用了private进行了封装，所以封装的属性如果要被外部访问，那么需要写getter()方法；
在Inner类中的print()方法之中如果要想访问msg的内容，那么只能够通过getMsg()方法完成，但是getMsg()是一个普通方法，必须通过Outer类对象才可以访问，那么这个时候需要把主方法中的Outer类对象传递到Inner类里面；

class Outer {
    private String msg = "Hello World！";
    public String getMsg() {
        return this.msg;
    }
    public void fun() { //3.现在由out对象调用了fun()方法
		Inner in = new Inner(this); //4.this表示当前对象
		in.print(); //7.调用方法
	}
}

class Inner { 
    private Outer out;
    public Inner(Outer out) {  //5.Inner.out = main.out
        this.out = out; //6.引用传递
    }
    public void print() {  //8.执行此方法
        System.out.println(this.out.getMsg()); 
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer out = new Outer();  //1.实例化Outer类对象
		out.fun();  //2. 调用Outer类方法
    }
}

实际上折腾了这么多的目的就是需要来访问外部类中的私有属性。

对于内部类的操作实际上远远不止于此。

通过以上的代码可以发现，当前的内部类的访问必须通过外部类的方法才可以完成。如果不想通过外部类访问进行调用，要想在程序外部调用，那么必须按照如下的形式进行内部内的实例化创建。
- 语法：外部类.内部类内部类对象 = new 外部类().new 内部类();

class Outer { // 定义一个外部类
	private String msg = "Hello World！";
	class Inner { // 此时定义了一个内部类
		public void print() { // 定义一个普通方法
			System.out.println(msg); // 调用msg属性
		}
	}
}

public class TestDemo {
	public static void main(String[] args) {
		// 声明内部类对象
		Outer.Inner in = new Outer().new Inner();
		in.print();
	}
}

之所以要先进行外部类对象实例化，主要的问题在于此时的外部类中存在有普通的属性，那么这些属性只有开辟了实例化对象之后才能够被访问。

如果现在一个内部类只想被外部类使用，即：不希望直接产生内部类的实例化对象，那么可以使用private定义。

class Outer { // 定义一个外部类
	private String msg = "Hello World！";
	private class Inner { // 此时定义了一个内部类
		public void print() { // 定义一个普通方法
			System.out.println(msg); // 调用msg属性
		}
	}
	public void fun() {
		Inner in = new Inner(); //内部类对象 
		in.print(); //内部类提供的print()方法
	}
}

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

在进行属性访问的时候都需要习惯性的加上this。所以如果要想在内部类中明确的使用this，那么语法形式：“外部类.this.属性”。

class Outer { // 定义一个外部类
	private String msg = "Hello World！";
	private class Inner { // 此时定义了一个内部类
		public void print() { // 定义一个普通方法
			System.out.println(Outer.this.msg); // 调用msg属性
		}
	}
	public void fun() {
		Inner in = new Inner(); //内部类对象 
		in.print(); //内部类提供的print()方法
	}
}

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

`static`定义内部类

内部类中如果使用了static进行定义，那么就表示其就是一个外部类的形式，但是这个“外部类”的名称就是“外部类.内部类”，同时该内部类只允许访问外部类中的static操作。

范例： 使用static定义内部类

class Outer { // 定义一个外部类
	private static String msg = "Hello World！";
	static class Inner { //内部类 = “外部类”
		public void print() {
			//此时只能够使用外部类中的static操作
			System.our.println(msg);
		}
	}
}

public class TestDemo {
	public static void main(String[] args) {
		new Outer.Inner().fun();
	}
}

那么如果要想操作这个外部类，就应该使用如下语法：

实例化对象：外部类.内部类内部类对象 = new 外部类.内部类();

在方法中定义内部类

理论上内部类可以定意义在类中的任意位置上，这就包括了：类中、方法中、代码块中。不过如果从实用的角度来讲，在方法中定义内部类的形式是最多的。

范例： 在方法中定义内部类

class Outer { // 定义一个外部类
	private static String msg = "Hello World！";
	public void fun(int num) {
		class Inner {
			public void print() {
				System.out.println("num = " + num);
				System.out.println("msg = " + msg);
			}
		}
		new Inner().print(); //产生了内部类对象并且调用方法
	}
}

public class TestDemo {
	public static void main(String[] args) {
		new Outer().fun(100);
	}
}