JAVA-内部类

最新推荐文章于 2024-05-24 02:08:26 发布

阿潇·

最新推荐文章于 2024-05-24 02:08:26 发布

阅读量157

点赞数

文章标签： java 类 javaee

本文链接：https://blog.csdn.net/qq_38340581/article/details/106952278

版权

1. 内部类

1.1 概述

把类定义在另一个类的内部，该类就被称为内部类。

举例：把类B定义在类A中，类B就被称为内部类。

1.2 访问规则

可以直接访问外部类的成员，包括私有。
外部类要想访问内部类成员，必须创建对象。

class Outer {
    private int num = 10;
    class Inner {
        public void show() {
            //可直接访问外部类的成员，包括私有
            System.out.println(num);
        }
    }
    
    public void method() {
        //若要访问Inner类中的方法，需创建其对象
        Inner i = new Inner();
        i.show();
    }
}

1.3 分类

成员位置：在成员位置定义的类，被称为成员内部类。
局部位置：在局部位置定义的类，被称为局部内部类。

class Outer {
    private int num = 10;
	// 成员位置
	class Inner {...}
	
    public void method() {
        //局部位置
        class Inner {...}
    }
}

2. 成员内部类

2.1 成员内部类的修饰符

public：正常修饰符
private：为了数据的安全性

//案例：人有身体，身体内有心脏。即Body类内有私有的成员内部类Heart()。
//只有医生才可调用心脏的operator()方法
class Body {
	private class Heart {
		public void operator() {
			System.out.println("心脏手术");
		}
	}

	public void method(String role) {
		if ("医生".equals(role)) {
			Heart h = new Heart();
			h.operator();
		}
	}
}

//调用方式
Body b =  new Body();
b.method("医生");

static：为了访问的方便性

注意：静态内部类访问的外部类数据必须用静态修饰。

class Outer {
	private int num = 10;
	private static int num2 = 100;

	public static class Inner {
		public void show() {
            // 静态内部类不可访问外部类的非静态成员变量
			// System.out.println(num);
			System.out.println(num2);
		}
	}
}

2.2 成员内部类的访问

2.2.1 成员内部类不是静态的

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

如：Outer.Inner oi = new Outer().new Inner();

class Outer {
	private int num = 10;

	// 成员内部类不是静态的
	class Inner {
		public void show() {
			System.out.println(num);
		}
	}
}

class Demo {
	public static void main(String[] args) {
		// 需求：我要访问非静态Inner类的show()方法
		// 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
		Outer.Inner oi = new Outer().new Inner();
		oi.show();
	}
}

2.2.2 成员内部类是静态的

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

如：Outer.Inner oi = new Outer.Inner();

class Outer {
	private int num = 10;
	private static int num2 = 100;
	// 成员内部类是静态的
	public static class Inner {
		public void show1() {
			System.out.println(num2);
		}
		
		public static void show2() {
			System.out.println(num2);
		}
	}

}

class InnerClassDemo3 {
	public static void main(String[] args) {
		// 需求：我要访问静态Inner类的show()、show2()方法
		// 格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
		Outer.Inner oi = new Outer.Inner();
		oi.show1();
		oi.show2();// 静态类也可直接对象调用
		// show2()的另一种调用方式，即通过类名调用。
		Outer.Inner.show2();
	}
}

2.3 成员内部类的应用面试题

要求：填入代码，分别输出30，20，10。

注意：

1:内部类和外部类没有继承关系。

2:通过外部类名限定this对象。如：Outer.this

class Outer {
	public int num = 10;

	class Inner {
		public int num = 20;

		public void show() {
			int num = 30;
			System.out.println("请填入代码，输出 30");
			System.out.println("请填入代码，输出 20");
			System.out.println("请填入代码，输出 10");
		}
	}
}

程序如下：

class Outer {
	public int num = 10;

	class Inner {
		public int num = 20;
	
		public void show() {
			int num = 30;
			System.out.println(num); // 输出30
			System.out.println(this.num); // 输出20
			System.out.println(new Outer().num); // 输出10
			System.out.println(Outer.this.num); // 输出10
		}
	}
}

3. 局部内部类

3.1 局部内部类的访问

局部内部类可以直接访问外部类的成员。
在局部位置可以创建内部类对象，通过对象调用内部类方法使用局部内部类功能。

class Outer {
	private int num = 10;

	public void method() {
		class Inner {
			public void show() {
				// 局部内部类可直接访问内部类成员变量
				System.out.println(num);
			}
		}
		// 在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
		Inner i = new Inner();
		i.show();
	}

}

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

3.2 局部内部类访问局部变量的注意事项

局部内部类访问局部变量，局部变量必须用final修饰

原因：局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。

class Outer {
	public void method() {
        int num = 10;
		final int num2 = 20;
		class Inner {
			public void show() {
				// 从内部类中访问本地变量num，报错。需要被声明为final类型
                
                //声明为final后，num2是常量，内存中此处已不是num2，而直接替换为20
				System.out.println(num);
			}
		}
		Inner i = new Inner();
		i.show();
	}
}

如果是变量20，那么是随着方法调用而存在，随方法调用结束而消失。

但是创建对象是在堆内存，而不是方法调用的栈内存。

method()方法调用结束之后，对象 i 并没有消失，所以必须是常量，所以必须用final修饰。

而因为是常量，所以输出语句：System.out.println(num2)中的num2已经自动替换成了20，而不再是num2。

3. 匿名内部类

是局部内部类的简化形式

3.1 匿名内部类介绍

3.1.2 前提

存在一个类或者接口，这里的类可以是具体类也可以是抽象类。

3.1.3 格式

new 类名或者接口名() {

重写方法;

};

不要忘记最后的分号

interface Inter {
	public abstract void show();
}

class Outer {
	public void method() {
	   new Inter() {
		   public void show() {
			   System.out.println("show");
		   }
	   };
	}
}

3.1.3 本质

是继承该类或者实现接口的子类匿名对象

3.2 调用匿名内部类

interface Inter {
	public abstract void show();
}

class Outer {
	public void method() {
		new Inter() {
			public void show() {
				System.out.println("show");
			}
		}.show();
	}
}

而上面这种方法如果show()方法太多，会很繁琐，利用多态调用。

interface Inter {
	public abstract void show();

	public abstract void show2();

}

class Outer {
	public void method() {
		Inter i = new Inter() { // 多态
			public void show() {
				System.out.println("show");
			}

			public void show2() {
				System.out.println("show2");
			}
		}; // 此处别忘了分号
		i.show();
		i.show2();
	}

}

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

3.3 匿名内部类在开发中的使用

在开发的时候，会看到抽象类，或者接口作为参数。而这个时候，我们知道实际需要的是一个子类对象。如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。

interface Person {
	public abstract void study();
}

class PersonDemo {
	public void method(Person p) {
		p.study();
	}
}

class PersonTest {
	public static void main(String[] args) {
		PersonDemo pd = new PersonDemo();
		pd.method(new Person() {
			public void study() {
				System.out.println("好好学习，天天向上");
			}
		});
	}
}

3.4 匿名内部类的面试题

按照要求，补齐代码，要求在控制台输出“HelloWorld”

interface Inter { void show(); }
class Outer { //补齐代码 }
class OuterDemo {
	public static void main(String[] args) {
		  Outer.method().show();
	  }
}

分析：

1:Outer.method()可以看出method()应该是Outer中的一个静态方法。

2:Outer.method().show()可以看出method()方法的返回值是一个对象。由于接口Inter中有一个show()方法,所以我认为method()方法的返回值类型是一个接口，即接口的子类对象。

3:并没有给出接口的子类，所以这里需要一个接口的子类匿名对象。

代码实现：

interface Inter {
	void show(); // 修饰符为public abstract，重写时要注意
}

class Outer {
	// 补齐代码
	public static Inter method() {
		// 子类对象 -- 子类匿名对象
		return new Inter() {
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}

class OuterDemo {
	public static void main(String[] args) {
		Outer.method().show();
	}
}

阿潇·

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA-内部类

文章目录1. 内部类1.1 概述1.2 访问规则1.3 分类2. 成员内部类2.1 成员内部类的修饰符2.2 成员内部类的访问2.2.1 成员内部类不是静态的2.2.2 成员内部类是静态的2.3 成员内部类的应用面试题3. 局部内部类3.1 局部内部类的访问3.2 局部内部类访问局部变量的注意事项3. 匿名内部类3.1 匿名内部类介绍3.1.2 前提3.1.3 格式3.1.3 本质3.2 调用匿名内部类3.3 匿名内部类在开发中的使用3.4 匿名内部类的面试题1. 内部类1.1 概述1.2 访问规则1.3
复制链接

扫一扫