Java基础教程——内部类

于 2019-07-14 00:43:00 发布
阅读量79 收藏 1
点赞数
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/tigerlion/p/11182838.html
本文介绍了内部类的概念和好处，包括封装性好、可访问外围类私有数据。详细阐述了成员内部类、静态内部类、局部内部类和匿名内部类的特点、创建方式及访问规则。最后给出了相关面试题，如静态与成员内部类的区别等。

内部类

内部类（inner class）是定义在另一个类中的类
内部类的好处：
|--1.隐藏机制:内部类封装性更好，隐藏在一个类之中，同一包中的其他类也不能访问
|--2.内部类可以访问外围类的私有数据

成员内部类

member inner class

成员内部类.png

可以访问外部类的所有成员变量和方法（无论静态、非静态)
自身没有静态成员
|--外部类里面创建成员内部类的实例：this.new Innerclass();
|--在外部类之外创建内部类的实例：new Outerclass().new Innerclass();
|--在内部类里访问外部类的成员：Outerclass.this.member

class Hero {
    void callHorse() {
        // 自己使用自己的成员内部类
        System.out.print("吕布");
        this.new Horse().show();
    }
    // 成员内部类
    class Horse {
        public void show() {
            System.out.println("---赤兔---");
        }
    }
}
public class InnerClassMember {
    public static void main(String[] args) {
        Hero h = new Hero();
        h.callHorse();
        // 创建一个类的内部类
        Hero.Horse horse = new Hero().new Horse();
        horse.show();
    }
}
吕布---赤兔---
---赤兔---

静态内部类

static inner class (nested class)

使用内部类只是为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围对象，可以将内部类声明为static。

生成静态内部类对象的方式为：

OuterClass.InnerClass inner = new OuterClass.InnerClass();// 里面的类不用new

|--成员内部类没有静态成员；
|--静态内部类只能访问外围类的静态成员

局部内部类

local inner class

在方法中定义、使用
不能被public, protected, private和static修饰(像局部变量一样)
只能访问方法中定义的final类型的局部变量(初始化之后便不能更改)

1648799-20190714004118380-1225561561.png

import java.util.*;
// 以集合排序需要实现Comparator接口为例
public class TestInnerClassLocal {
    public static void main(String[] args) {
        class InnerComparator implements Comparator<Integer> {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        }
        // 需要先定义局部内部类，再使用
        InnerComparator com = new InnerComparator();
        List<Integer> lst = new ArrayList<>();
        Collections.addAll(lst, 2, 3, 5, 1, 4);
        Collections.sort(lst, com);
        System.out.println(lst);
    }
}
[5, 4, 3, 2, 1]

匿名内部类

anonymous inner class

没有名字的局部内部类。
用于只创建这个类的一个对象的场合（不必命名），通常是作为方法的参数
隐式地继承了一个父类或者实现了一个接口
限制：由于构造方法的名字与类名相同，而匿名类没有类名，所以，匿名类不能有构造方法。

1648799-20190714004138306-325794076.png

综合代码：

import java.util.Date;
class OutClass {
    private static String field_Static = "外围类：静态变量";
    private String field_Common = "外围类：普通变量";
    private static void methodStatic() {
        System.out.println("外围类：静态方法");
    }
    private void methodCommon() {
        System.out.println("外围类：普通方法");
    }
    // 成员内部类
    class InnerClassMember {
        // Err:
        // private static String inner_fieldStatic = "内部类：静态变量";
        private String inner_fieldCommon = "|---内部类：普通变量";
        // Err:
        // private static void innerMethodStatic() {}
        private void innerMethodCommon() {
            System.out.println("|---内部类：普通方法");
        }
        public void methodInner() {
            // 变量·外
            System.out.println(OutClass.this.field_Common);
            System.out.println(field_Static);
            // 变量·内
            System.out.println(inner_fieldCommon);
            // 方法·外
            methodStatic();
            OutClass.this.methodCommon();
            // 方法·内
            innerMethodCommon();
        }
    }
    // 静态内部类
    static class InnerClassStatic {
        private static String inner_fieldStatic = "|---静态内部类：静态变量";
        private String inner_fieldCommon = "|---静态内部类：普通变量";
        private static void innerMethodStatic() {
            System.out.println("|---静态内部类：静态方法");
        }
        private void innerMethodCommon() {
            System.out.println("|---静态内部类：普通方法");
        }
        public void methodInner() {
            // 变量·外
            System.out.println(OutClass.field_Static);
            // 变量·内
            System.out.println(inner_fieldCommon);
            System.out.println(inner_fieldStatic);
            // 方法·外
            OutClass.methodStatic();
            // 方法·内
            innerMethodStatic();
            innerMethodCommon();
        }
    }
    // 局部內部類
    public void method4InnerClassLocal() {
        String localField = "局部变量";
        final String localFieldFinal = "局部变量(final)";
        // ↑Java 8中不用加final，但局部内部类中不能修改其值
        // 局部内部类
        class InnerClassLocal {
            public void localClassM() {
                // Err: System.out.println(localField);
                System.out.println(localFieldFinal);
                System.out.println(field_Common);
                System.out.println(field_Static);
                methodCommon();
                methodStatic();
            }
        }
        InnerClassLocal _local_in_c = new InnerClassLocal();
        _local_in_c.localClassM();
    }
    // --------------------
    public void testAnonymousClass() {
        // 匿名内部类
        PrintDate(new Date() {
            public long getTime() {
                System.out.println(field_Common);
                System.out.println(field_Static);
                methodCommon();
                methodStatic();
                return 10086;
            }
        });
    }
    private void PrintDate(Date dt) {
        System.out.println(dt.getTime());
    }
}
public class InnerClassTest1 {
    public static void main(String[] args) {
        System.out.println("===↓↓↓成员内部类===================");
        OutClass.InnerClassMember ic = new OutClass().new InnerClassMember();
        ic.methodInner();
        System.out.println("===↓↓↓静态内部类===================");
        OutClass.InnerClassStatic ics = new OutClass.InnerClassStatic();
        ics.methodInner();
        System.out.println("===↓↓↓局部内部类===================");
        OutClass oc = new OutClass();
        oc.method4InnerClassLocal();
        System.out.println("===↓↓↓匿名内部类===================");
        oc.testAnonymousClass();
    }
}
===↓↓↓成员内部类===================
外围类：普通变量
外围类：静态变量
|---内部类：普通变量
外围类：静态方法
外围类：普通方法
|---内部类：普通方法
===↓↓↓静态内部类===================
外围类：静态变量
|---静态内部类：普通变量
|---静态内部类：静态变量
外围类：静态方法
|---静态内部类：静态方法
|---静态内部类：普通方法
===↓↓↓局部内部类===================
局部变量(final)
外围类：普通变量
外围类：静态变量
外围类：普通方法
外围类：静态方法
===↓↓↓匿名内部类===================
外围类：普通变量
外围类：静态变量
外围类：普通方法
外围类：静态方法
10086

对比和总结

1648799-20190714004224785-1624516075.png

1648799-20190714004248561-1374479636.png

1648799-20190714004309185-1610125715.png

面试题

面试题：
1、静态内部类和成员内部类有什么不同？（美团）
2、Anonymous Inner Class (匿名内部类)是否可以继承其它类，是否可以implements(实现)interface(接口)?
3、补全代码：

interface Inter {
    public void show();
}
class Outer {
    public static Inter method() {// 返回值是接口的方法
        // 补全代码↓↓↓
        return 
        // 补全代码↑↑↑
    }
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
    }
}

转载于:https://www.cnblogs.com/tigerlion/p/11182838.html

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值