亲宝软件园·资讯

展开

Java的内部类

哈哈怪.... 人气:0

成员内部类

1.定义

成员内部类是直接定义在类中,不加任何修饰符的(特指不加static修饰的)的内部类,可以类比着成员变量来理解,如下面这个代码段中的Inn类就是一个成员内部类

public class Inner1 {
    private String o = "外部类属性";
    public class Inn{
        private String i = "成员内部类属性";
    }
}

2.成员内部类的使用规则

//成员内部类
public class Inner1 {
//    外部类的私有属性o
    private String o = "外部类属性";
    public class Inn{
//        内部类的私有属性i
        private String i = "成员内部类属性";
        private void Itest(){
//            内部类直接访问外部类的属性,包括私有属性
            System.out.println(o);
        }
    }
    public void Otest(){
//        外部类则要先创建内部类的对象再访问其成员变量,这里注意,也可以访问其私有属性
        Inn in = new Inn();
        in.Itest();
        System.out.println(in.i);
    }
    public static void main(String[] args) {
        Inner1 i1 = new Inner1();
        i1.Otest();
    }
}

 3.成员内部类对象的创建:

public class Inner1 {
    private String str1 = "外部类";
//    外部类内部创建内部类对象
    Inn i1 = new Inn();
    private class Inn{
        private String str2 = "内部类";
    }
}

如下图, 内部类为private,在外部类的外部无法创建该对象

修改内部类访问权限为public时正确创建 :

public class Inner1 {
    private String str1 = "外部类";
//    外部类内部创建内部类对象
    Inn i1 = new Inn();
    public class Inn{
        private String str2 = "内部类";
    }
}
class Test{
//    外部类的外部创建外部类的内部类对象
    Inner1.Inn i2 = new Inner1().new Inn();
}

4.内部类与静态域

public class Inner1 {
    private String str1 = "外部类";
//    外部类内部创建内部类对象
    Inn i1 = new Inn();
    public class Inn{
        private String str2 = "内部类";
    }
    public static void main(String[] args) {
//        main中创建
        Inner1.Inn inn = new Inner1().new Inn();
        System.out.println(inn.str2);
    }
}

静态内部类:

1.定义:

public class Inner2 {
    private String str1 = new String("外部");
//    静态内部类
    public static class Inn{
        private String str2 = new String("静态内部");
    }
}

2.静态内部类的使用规则:

静态内部类不能直接访问外部类的普通成员变量 (普通成员变量有对象才能访问,所以static不能访问普通的成员变量),当然,可以通过new一个外部类的对象来达到访问外部类成员变量的目的
public class Inner2 {
    private String str1 = new String("外部");
    private static String str3 = new String("外部静态属性");
//    静态内部类
    public static class Inn {
    private String str2 = new String("静态内部");
    public void fun(){
//        静态内部类不能直接访问外部类的普通成员变量
        System.out.println(str1);
//        但可以通过new一个外部类对象访问
        Inner2 i2 = new Inner2();
        System.out.println(i2.str1);
//        static家族互通
        System.out.println(str3);
    }
}
}

但是,静态内部类虽然不能直接访问外部类的成员变量,但是是可以拥有自己的普通成员变量 的

3.静态内部类对象的创建

public class Inner2 {
    private String str1 = new String("外部");
//    静态内部类
    public static class Inn{
        private String str2 = new String("静态内部");
    }
//    直接在类的内部创建静态内部类的对象
    Inn i = new Inn();
    public static void main(String[] args) {
//        外部类的静态方法中创建使用静态内部类的对象
        Inn inn = new Inn();
    }
}

外部类的外部:

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

public class Inner2 {
    private String str1 = new String("外部");
//    静态内部类
    public static class Inn {
    private String str2 = new String("静态内部");
}
}
class Test{
//    外部类的外部创建静态内部类的对象
    Inner2.Inn i = new Inner2.Inn();
}

 成员内部类 VS 静态内部类

方法内部类:

1.定义:

直接定义在方法内部,不允许使用任何修饰符修饰(包括访问权限修饰符,static等),对外部完全隐藏,出了这个方法,这个类就没有了,可以类比局部变量进行理解 

2.方法内部类的使用规则:

除了无法定义static域外,和成员内部类基本一样,这里不再赘述

3.注意形参的使用

方法内部类中若使用了方法的形参, 该形参为隐式的final声明(JDK8之前,必须手动显式定义为final ,但JDK8以后,直接隐式一定为final)

如下面这个例子:

public class Inner3 {
    public void fun(int num){
//        方法内部类
        class Inn{
            public void test(){
//                将下面这行代码注释掉,num正常可作运算
//                System.out.println(num);
            }
        }
        num ++;
        System.out.println(num);
    }
    public static void main(String[] args) {
        Inner3 i3 = new Inner3();
        i3.fun(3);
    }
}

 但如果我们的方法内部类使用了方法的形参,编译报错

 

匿名内部类(函数式编程)

如之前我们写的接口传参:

public class Inner4 {
    public static void fun(MessageImpl m) {
        m.printMessage();
    }
    public static void main(String[] args) {
        MessageImpl l = new MessageImpl();
        fun(l);
    }
}
interface IMessage {
    void printMessage();
}
class MessageImpl implements IMessage {
    public void printMessage() {
        System.out.println("aaa");
    }
}

 使用匿名内部类可以这样写:

public class Inner4 {
    public static void fun(IMessage m ){
        m.printMessage();
    }
    public static void main(String[] args) {
//        匿名内部类
        fun(new IMessage() {
            @Override
            public void printMessage() {
                System.out.println("aaa");
            }
        });
    }
}
interface IMessage {
    void printMessage();
}

 最后,重点掌握成员内部类与静态内部类,以及二者使用区别。

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!

加载全部内容

相关教程
猜你喜欢
用户评论