内部类和外部类

最新推荐文章于 2024-05-09 10:57:32 发布

DC10086

最新推荐文章于 2024-05-09 10:57:32 发布

阅读量578

点赞数

分类专栏： Java入门

Java入门专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.成员内部类：外部类是不能直接使用内部类的成员和方法。必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类对象名 = 外部类对象.new 内部类( );默认 public 修改无效。
2.静态内部类：外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员创建静态内部类的对象时，不需要外部类的对象，可以直接创建内部类对象名= new 内部类()。
3. 方法内部类：方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问控制符和 static 修饰符。
4.匿名内部类：父类或者接口名父类引用=new 父类或者接口名（）{
实现父类抽象方法或者接口方法；
}

一、内部类的主要作用如下：

1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

3. 内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。

二、内部类可分为以下几种：

成员内部类
静态内部类
方法内部类
匿名内部类。

三、1，定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类对象名 = 外部类对象.new 内部类( );

2，外部类是不能直接使用内部类的成员和方法滴，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。

3，可先创建内部类的对象，然后通过内部类的对象来访问其成员变量和方法。HelloWorld.this.name

四、Java回调

回调用于层间协作，例如作为一个驱动，是一个底层，他在收到一个数据时，除了完成本层的处理工作外，还将进行回调，将这个数据交给上层应用层来做进一步处理，这在分层的数据通信中很普遍。
其实回调和API非常接近，他们的共性都是跨层调用的函数。但区别是API是低层提供给高层的调用，一般这个函数对高层都是已知的；而回调正好相反，他是高层提供给底层的调用，对于低层他是未知的，必须由高层进行安装，这个安装函数其实就是一个低层提供的API，安装后低层不知道这个回调的名字，但它通过一个函数指针来保存这个回调，在需要调用时，只需引用这个函数指针和相关的参数指针。
其实：回调就是该函数写在高层，低层通过一个函数指针保存这个函数，在某个事件的触发下，低层通过该函数指针调用高层那个函数。

关于回调的总结：
在Java中，通常就是编写另外一个类或类库的人规定一个接口，然后你来实现这个接口，然后把这个接口的一个对象作为参数传给别人的程序，别人的程序必要时就会通过那个接口来调用你编写的函数。

下面是一个内部类例子

//外部类HelloWorld
public class HelloWorld {

    // 内部类Inner，类Inner在类HelloWorld的内部
    public class Inner {

        // 内部类的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }

    public static void main(String[] args) {

        // 创建外部类对象
        HelloWorld hello = new HelloWorld();
        // 创建内部类对象
        Inner i = hello.new Inner();
        // 调用内部类对象的方法
        i.show();
    }
}

匿名内部类:
是不能有名称的类，所以没办法引用它们。必须在创建时，作为new语句的一部分来声明它们。这就要采用另一种形式的new语句，如下所示： new <类或接口> <类的主体>
作用是：
1.和内部类一样，可以对外部类进行扩展，重写或新增加方法。
2.用于实现接口
3.没有类名

//新建一个接口
public interface Animal {
    void eat();

    void sleep();
}

//新建一个类，在类里面使用 内部类和内部匿名类去实现接口
public class Zoo {
    private class Tiger implements Animal {
        public void eat() {
            System.out.println("tiger eat");
        }

        public void sleep() {
            System.out.println("tiger sleep");
        }
    }

    /**
     *  这里不明白，Animal不是接口么，怎么可以定义方法？
     *  ---答案 接口可以作为返回类型,指定返回的类型必须是实现当前接口的类.
     * @return
     */

    /**
     * // 由于接口不是不能实例化的，所以必须通过类来实现，这里使用返回一个（已实现该接口的对象）
     * 具体写法有两种，写法2容易理解
     * @return
     */
    //---------------------------写法1-----匿名内部类--------------------------------
    Animal getAnimal1(){
        return new Animal(){
            public void eat() {
                System.out.println("---1---animal eat");
            }

            public void sleep() {
                System.out.println("---1---animal sleep");
            }
        };
    }


    //---------------------------写法2------内部类--------------------------
    Animal getAnimal2(){
        return new TempAnimal();
    }

    class TempAnimal implements Animal{
        int a = 0;
        public void eat() {
            System.out.println("---2---animal eat");
        }

        public void sleep() {
            System.out.println("---2---animal sleep");
        }   
    }

}

//新建一个测试类
public class Test {
    public static void main(String[] args) {
        Zoo z = new Zoo();
        Animal an = z.getAnimal1();
        an.eat();
        an.sleep();


        Animal one = z.getAnimal2();
        one.eat();
        one.sleep();
    }
}

匿名内部类是内部类的一种简化写法：return new Wrapper{...};等价于：Wrapped extends Wrapper{...}return new Wrapped();难道匿名内部类就只这一点作用吗？考虑一下这样的case:

interface ICount {
    int count();
}

class Parent {
    int i = 0;

    int count() {
        return i++;
    }
}
有一个类Child，它既想继承Parent的count()方法，又想实现ICount接口中的count方法，这个时候怎么办呢？内部类就可以大显身手了：

class Child extends Parent {
    ICount getCount() {
        return new ICount {
            int i = 0;

        int count() {
            return (i *= 2);
        }
    }
}

DC10086

关注

0
点赞
踩
1

收藏

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

1.成员内部类：外部类是不能直接使用内部类的成员和方法。必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类对象名 = 外部类对象.new 内部类( );默认 public 修改无效。2.静态内部类：外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调...
复制链接

扫一扫