为了账号安全,请及时绑定邮箱和手机立即绑定

丽星邮轮注册,金叶足球博彩网

2017.05.12 01:37 10233浏览

本文地址:http://www.bgel.cn/article/17959
文章摘要:丽星邮轮注册,金叶足球博彩网,未来娱乐系统,扎金花棋牌游戏官网

Java 内部类有许多需要注意的地方 ,相信大家平时都在用,但是有些地方是需要注意的,在这里给大家总结一下。

内部类的位置
public class A {
    class B {

    }

    public void pint() {
        class C {
        }
        new C();
    }

    public void pint(boolean b) {
        if (b) {
            class D {
            }
            new D();
        }
    }
}

从代码中可以看出,内部类可以定义到很多地方,常用的是成员变量中(B),方法中也叫局部内部类(C),作用域中(D)

从上面来看似乎没有用到过在方法中和作用域中的情况啊,这就错了;再来看看这个:

public interface AInterface {
    void show();
}
public class B {

    public void show() {
        class Man implements AInterface {
            @Override
            public void show() {

            }

        }
        Man man = new Man();
        man.show();
    }

}

其中我们定义了两个文件,一个文件是一个接口类,一个是B文件;在B类中,的show()方法中我们使用了局部内部类的方式创建了类ManMan class继承接口并实现方法,随后使用该类。

内部类的权限

为什么要有内部类的存在?

在我看来类主要的就是封装、继承、多态;当然其中的回调思想我认为是很重要的;而内部类的出现就是为了简化多重继承的问题;一个A类,并不能继承多个其他类,但是在使用中又需要使用到其他类的方法,这个时候内部类就发挥作用了;典型的就是事件点击的回调实现。

那么内部类的权限究竟有多大?

至于答案是什么,代码上看看就知道了。

public class C {
    int a = 1;
    private int b = 2;
    protected int c = 3;
    public int d = 4;

    void a() {
        System.out.println("A:" + a);
    }

    private void b() {
        System.out.println("B:" + b);
    }

    protected void c() {
        System.out.println("C:" + c);
    }

    public void d() {
        System.out.println("D:" + d);
    }

    class D {

        void show() {
            int max = a + b + c + d;
            a();
            b();
            c();
            d();
            System.out.println("Max:" + max);
        }
    }

    public static void main(String[] args) {
        D d = new C().new D();
        d.show();
    }
}

运行结果:

img
可以看出,内部类 D 对类 C 具有完整的访问权限,等于全身脱光了给你看。

那要是反过来呢?

public class C {
    class D {
        private int a = 20;
        private void a(){
            System.out.println("D.A:" + a);
        }
    }

    void show(){
        D d = new D();
        d.a();

        System.out.println("D.A:" + d.a);
    }

    public static void main(String[] args) {
        new C().show();
    }
}

运行结果:

img
可见也是完全可行的,也能直接访问私有属性 私有方法,在这里似乎私有的限制已经失效了一般,这个让我想起了以前看见过一个面试:在 Java 中 private 修饰何时会失效。

这完全是两个人互相脱光光了啊~

匿名内部类

这个非常常见,特别是在按钮点击事件绑定中。

public class D {
    void initButton() {
        Button b1 = new Button();
        b1.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(Button v) {

            }
        });

        Button b2 = new Button();
        b2.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(Button v) {

            }
        });
    }

}

其中的:

    new OnClickListener() {

            @Override
            public void onClick(Button v) {

            }
        }

就是匿名内部类的使用方式,OnClickListener 是一个接口类,接口类是无法直接new 一个实例的;这里也并不是那样,而是new 了一个其他的类,该类是匿名的,也就是没有名字,只不过该类实现了 OnClickListener接口类中的方法。

上面的添加回调部分可等同于:

public class D {
    void initButton1() {
        Button b1 = new Button();
        b1.setOnClickListener(new Listener1());

        Button b2 = new Button();
        b2.setOnClickListener(new Listener2());
    }

    class Listener1 implements OnClickListener {

        @Override
        public void onClick(Button v) {

        }
    }

    class Listener2 implements OnClickListener {

        @Override
        public void onClick(Button v) {

        }
    }

}

这里就是先建立类,继承自接口;而后赋值到 Button 中。

要说两者的区别与好处,这个其实看具体的使用情况吧;如果你的按钮很多,但是为了避免建立太多类;那么可以建立一个回调类,然后都赋值给所有的按钮,不过最后就是需要在 onClick方法中进行判断是那个按钮进行的点击。
匿名内部类的使用地方很多;具体的使用应视使用情况而定~

静态内部类/静态嵌套类

这个其实并不应该叫做内部类了,因为其并不具备内部类的完全权限,在使用上与一般的类基本一样;那为什么会有这个的存在?

在我看来这个类的存在是为其包括类服务;意思是可以单独服务,不被外面的类所知晓;如这样:

public class E {
    private void show(){
        new A();
    }

    private static class A{

    }
}

其中类 A 使用了 static ,所以是静态嵌套类,在这里使用private 修饰;那么该类只能在 E类中进行实例化;无法在 其他文件中实例化。

这样的情况使用外面的类能行么?不行吧?也许你会说在 E.java 文件夹中建立 A.java ,并使用protected修饰;但是在同样的包下,或者继承的类中同样能访问了;这也只是其中一个较为特殊的情况。

我们来看看权限

public class E {
    int a1 = 0;
    private int a2 = 0;
    protected int a3 = 0;
    public int a4 = 0;

    private void show(){
        A a =new A();
        System.out.print("b1:"+a.b1);
        System.out.print("b2:"+a.b2);
        System.out.print("b3:"+a.b3);
        System.out.print("b4:"+a.b4);

    }

    private static class A{
        int b1 = 0;
        private int b2 = 0;
        protected int b3 = 0;
        public int b4 = 0;

        private void print(){
            System.out.print("a1:"+a1);
            System.out.print("a2:"+a2);
            System.out.print("a3:"+a3);
            System.out.print("a4:"+a4);

        }
    }
}

在这个中的结果是怎样?

img
从图片中可以看出,其权限级别是单方向的;静态嵌套类 A 对其包含类 E 完全透明;但 E 并不对 A 透明。

再来看看方法:

img
可以看出同样的情况;这个是为什么呢?为什么就是多一个 static 的修饰就这么完全不同?其是很好理解,两个独立的类;本来就无法直接使用,必须有引用才能调用其属性与方法。

我们或许可以这么调整一下就OK:

public class E {
    int a1 = 0;
    private int a2 = 0;
    protected int a3 = 0;
    public int a4 = 0;

    private void show() {
        A a = new A();
        System.out.print("b1:" + a.b1);
        System.out.print("b2:" + a.b2);
        System.out.print("b3:" + a.b3);
        System.out.print("b4:" + a.b4);

        a.b1();
        a.b2();
        a.b3();
        a.b4();
    }

    void a1() {

    }

    private void a2() {

    }

    protected void a3() {

    }

    public void a4() {

    }

    private static class A {
        int b1 = 0;
        private int b2 = 0;
        protected int b3 = 0;
        public int b4 = 0;

        void b1() {

        }

        private void b2() {

        }

        protected void b3() {

        }

        public void b4() {

        }

        private void print(E e) {
            System.out.print("a1:" + e.a1);
            System.out.print("a2:" + e.a2);
            System.out.print("a3:" + e.a3);
            System.out.print("a4:" + e.a4);

            e.a1();
            e.a2();
            e.a3();
            e.a4();
        }
    }
}

在其静态类中传递一个 E 的引用进去就能解决问题了:

img
可以看出其中现在并没有报错了;能正常运行。

两者之间的隐藏区别

但是最开始上面的内部类是怎么回事?难道是闹鬼了?上面的内部类没有传递引用的啊;为啥加上一个 static 就不行了?

在这里我们需要看看字节码,我们先建立一个简单的内部类:

public class F {

    class A{

    }
}

这个够简单吧?别说这个都难了;汗~

然后我们找到 class 文件,然后查看字节码:

img

在这里分别查看了 F 类的字节码和 F$A 类的字节码。

其中有这样的一句: final F this$0; 这句是很重要的一句,这句出现的地方在其内部类中,意思是当你 new 一个内部类的时候就同时传递了当前类进去;所以在内部类中能具有当前类的完全权限,能直接使用所有的东西;就是因为在隐藏情况下已经传递了当前类进去。

那么我们再看看一个简单的静态内部类:

public class G {
    static class A {

    }
}

与上面的区别唯一就是在于添加了一个 static 。此时我们看看字节码:

img

可以看出其中无论是 G 类,还是 G$A 类的初始化中都没有其他多余的部分,也没有进行隐藏的传递进去当前类;所以这样的情况下并不具备访问权限,需要我们传递引用进去,可以通过接口也可以完全传递进去,具体取决于个人。所以加了static类的内部类除了在权限上比一般的类更加开放(与其包含类)外,与一般的类在使用上是一样的;所以准确的说应该叫做静态嵌套类。

初始化的区别

一个类中,同时包含了内部类与静态内部类,那么其初始化应该是怎么样的呢?

都是直接 new ?还是看看代码:

public class H {
    int a = 1;

    public class A {
        public void Show() {
            System.out.print("a:" + a);
        }
    }

    public static class B {
        public void Show(H h) {
            System.out.print("a:" + h.a);
        }
    }

    public static void main(String[] args) {
        H h = new H();
        //A a = new A();
        A a1 = h.new A();
        B b = new B();
        //B b1 = h.new B();
        B b3 = new H.B();
    }
}

其中注释了的两种方式是不允许的方式,也就是无法正常运行。

A 因为有一个隐藏的引用,所以必须是H 的实例才能进行初始化出A 类;而B 类则是因为是在H 类中以静态方式存在的类,所以需要 new H.B();之所以能直接使用new B(),与该 main 方法在 H 类中有关,因为本来就在 H类中,所以直接使用 H类的静态属性或者方法可以不加上:“H.” 在前面。

内部类的继承

直接继承的情况:

img

可以看出报错了,为什么?因为需要传递一个 H 类进去,所以我们在继承的时候需要显示的指明:

public class I extends H.A{
    public I(H h){
        h.super();
    }
}

也就是在构造方法中,传递一个 H 的引用进去,并调用 H 实例的 super() 方法,才能进行实例化。

使用的话应该这样:

    public static void main(String[] args) {
        H h = new H();
        I i = new I(h);
    }

而,如果是继承其静态嵌套类,则不需要这样:

public class J extends H.B{

}

就这样就OK。

哎,差不多了~~整个内部类的东西差不多就是这些了,希望对大家有所帮助。

点击查看更多内容

本文原创发布于慕课网 ,转载请注明出处,谢谢合作

100人点赞

若觉得本文不错,就分享一下吧!

评论

相关文章推荐

正在加载中
意见反馈 去赚学费 帮助中心 APP下载
官方微信
扎金花棋牌游戏官网

举报

0/150
提交
取消
网站地图 顶级娱乐注册就送39元 足球大赢家电子版 凯发k8官网 豪博娱乐官方网
bodog备用网址 多宝平台客户端下载 棋牌游戏
娱乐电玩城注册送分 亚博体育注册 金世豪客户端下载 足球星榜
大都会娱乐线路检测 网上娱乐平台 妻子的秘密谢文苏蓝 橙天嘉禾娱乐
愽天堂 天天正版娱乐 新天地电子娱乐城 明发国际娱乐网址
诺亚娱乐 权威认证彩票平台 汇丰在线评估 丰尚娱乐直属 9号彩票注册
BA娱乐 新生娱乐平台官网 重庆时时计划 极彩 拉菲彩票平台
满堂彩平台 金沙彩票 财富彩票 世界彩票 菜鸟娱乐平台q
亿游国际娱乐 彩吧2娱乐 亚上彩是真的吗 聚彩彩票网 富博娱乐时时彩平台