内部类你学着累不累
内部类概述
在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。
- 成员内部类
- 局部内部类
- 匿名内部类
成员内部类
如何直接访问内部类的成员。
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
class Outer {
private int num = 10;
class Inner {
public void show() {
System.out.println(num);
}
}
}
class InnerClassDemo {
public static void main(String[] args) {
// 访问Inner类的show()方法
//格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
而成员内部类的使用，一般来说，在实际开发中是不会这样直接使用的，因为一般内部类就是为了不让外界直接访问的
因此，对Inner的show()方法进行保护，使用private为了保证数据的安全性
class Outer {
private int num = 10;
class Inner {
private void show() {
System.out.println(num);
}
}
public void GetShow() {
Inner i = new Inner();
i.show();
}
}
class InnerClassDemo {
public static void main(String[] args) {
// 访问Inner类的show()方法
Outer o = new Outer();
o.GetShow();
}
}
使用static修饰让数据访问更加方便
- 被静态修饰的成员内部类只能访问外部类的静态成员
- 内部类被静态修饰后方法
- 静态方法
- 非静态方法
class Outer {
private int num = 10;
private static int num2 = 100;
//内部类用静态修饰是因为内部类可以看出是外部类的成员
public static class Inner {
public void show() {
System.out.println(num2);
}
public static void show2() {
System.out.println(num2);
}
}
}
class InnerClassDemo {
public static void main(String[] args) {
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();
System.out.println("----------");
//show2()的另一种调用方式
Outer.Inner.show2();
}
}
思考
问
填空，要求分别输出30，20，10
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public viod show() {
int num = 30;
System.out.println(?);
System.out.println(?);
System.out.println(?);
}
}
}
答
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public viod show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
}
}
}
class InnerClassDemo4 {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
注意：
- 内部类和外部类没有继承关系
- 通过外部类名限定
this对象，（Outer.this）
局部内部类
-
可以直接访问外部类的成员
-
在局部位置，可以创建内部类对象，通过对象调用内部类方法，来使用局部内部类功能
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 InnerClassDemo4 {
public static void main(String[] args) {
// 创建外部类对象，调用method()方法
Outer o = new Outer();
o.method();
}
}
思考
问
局部内部类如何访问局部变量？
答
class Outer {
private int num = 10;
public void method() {
final int num = 20;
class Inner {
public void show() {
// 从内部类中访问本地变量num; 需要被声明为最终类型
System.out.println(num);
}
}
Inner i = new Inner();
i.show();
}
}
class InnerClassDemo5 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
局部内部类访问局部变量必须用
final修饰
- 局部变量是随着方法的调用而调用，随着调用完毕而消失。
- 而堆内存的内容并不会立即消失。所以，我们加
final修饰。 - 加入
final修饰后，这个变量就成了常量。既然是常量。你消失了。 - 在内存中存储的是数据20，所以，我还是有数据在使用。
匿名内部类
匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类
前提
存在一个类或者接口
这里的类可以是具体类也可以是抽象类。
格式
new 类名或者接口名(){
重写方法;
}
本质
是一个继承了该类或者实现了该接口的子类匿名对象。
interface Inter {
public abstract void show();
}
class Outer {
public void method() {
// new 类名或者接口名(){}
new Inter() {
// 重写方法
public void show() {
System.out.println("show");
}
};
}
}
调用
因此既然new Inter(){};这一坨是一个对象，那么对象调用show()方法还不简单？
// 接口
interface Inter {
public abstract void show();
}
class Outer {
public void method() {
// new 类名或者接口名(){}
new Inter() {
// 重写方法
public void show() {
System.out.println("show");
}
}.show();
}
}
class InnerClassDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
如果Inter接口有两个方法，那如何调用？
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 InnerClassDemo {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
思考
问
如何使用PersonDemo调用study()方法？
interface Person {
public abstract void study();
}
class PersonDemo {
//接口名作为形式参数
//其实这里需要的不是接口，而是该接口的实现类的对象
public void method(Person p) {
p.study();
}
}
答
看到此，一般会想到使用具体类来实现接口，在实现类中重写study()方法即可
//实现类
class Student implements Person {
public void study() {
System.out.println("好好学习,天天向上");
}
}
class InnerClassTest {
public static void main(String[] args) {
//测试
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
}
}
这种方然固然可行，那么采用匿名内部类的方式来实现：
class InnerClassTest {
public static void main(String[] args) {
// 测试
PersonDemo pd = new PersonDemo();
// 匿名内部类的本质是继承类或者实现了接口的子类匿名对象
pd.method(new Person(){
public void study() {
System.out.println("好好学习,天天向上");
}
});
}
}
这种方式占内存较少，占用内存即可及时回收，一般在Android中使用的比较多，因为只使用一次，匿名回收，使用结束即回收
思考
问
按照要求，补齐代码
interface Inter {
void show();
}
class Outer {
//补齐代码
}
class OuterDemo {
public static void main(String[] args) {
Outer.method().show();
}
}
要求在控制台输出”HelloWorld”
答
- 首先从
Outer.method()直接通过类名访问方法，可以判断出是一个静态方法 Outer.method().show()后面还跟着调用show()方法，即可知道Outer.method()返回值是一个对象，对象为Inter
interface Inter {
void show();
}
class Outer {
// 返回对象为Inter的静态方法
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();
}
}
你学废了吗？