ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

java中的内部类

2019-09-15 09:00:35  阅读：151  来源： 互联网

标签：java 内部 show void class new public


概述

将一个类定义在另一个类的里面，里面的那个类就称为内部类（内置类，嵌套类）

分析事物A时，发现该事物A描述中还有事物B，而且这个事物B还在访问被描述事物A的内容，将事物B定义成内部类来描述。

特点

  1. 内部类可以直接访问外部类中的成员；
  2. 外部类要访问内部类，必须建立内部类的对象；

举例：

package innerdemo;

public class InnerDemo1 {
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner(); // 直接访问内部类的方法
        in.show();

        Outer o = new Outer();//
        o.method();
    }
}
class Outer{

    private int num = 3;
    // 内部类
    class Inner{
        void show(){
            num = 100;
            System.out.println("内部类run..."+num);
        }
    }

    public void method(){
        Inner in = new Inner(); //外部类要访问内部类，必须建立内部类的对象；
        in.show();
    }
}

修饰符

  1. 直接访问外部类中的内部类中的成员：（不多见）

    外部类名.内部类名 变量名 = new 外部类名(). new 内部类名();

    Outer.Inner in = new Outer().new Inner();

    in.show();

  2. 内部类是静态的类，相当于一个外部类。外部类只要一加载，内部类就存在了，所以直接new一个内部类对象出来；

    Outer.Inner in1 = new Outer.Inner();

    public class InnerClassDemo {
    public static void main(String[] args) {
        // 内部类是静态的。相当于一个外部类
        Outer.Inner in1 = new Outer.Inner();
        in1.show();
    }
}
class Outer{
    private static int num = 3;
    // 内部类
    static class Inner{
        void show(){
            System.out.println("内部类run..."+num);
        }
    }
}

  3. 如果内部类是静态的，成员是静态的，就不需要对象了。如果内部类中定义了静态成员，该内部类也必须是静态的。

    package java_demo_2;

public class InnerClassDemo {
    public static void main(String[] args) {
        Outer.Inner.function();
    }
}
class Outer{
    private static int num = 3;
    // 内部类
    static class Inner{
        void show(){
            System.out.println("内部类run..."+num);
        }
        public static void function(){
            System.out.println("内部类是静态的，成员也是静态的，不需要创建对象"+num);
        }
    }
}

细节

package java_demo_2;

public class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().method();
    }

class Outer{
    int num = 3;
    // 内部类
    class Inner{
        int num = 4;
        void show(){
            int num = 5;
            System.out.println(num); // num 5
            System.out.println(this.num); // 4 局部和成员变量重名
            System.out.println(Outer.this.num); // 3
        }
    }
    void method(){
        new Inner().show();
    }
}

为什么内部类能直接访问外部类中成员呢？

那是因为内部类持有了外部类的引用。外部类名.this

局部内部类

内部类可以存放在局部位置上，可以放在方法中，放在代码块中。

class Outer1{

    int num = 3;

    void method(){
        // 内部类在方法中

        class Inner{
            void show(){
                System.out.println("方法中的内部类:"+num);
            }
        }
        // 创建对象
        Inner in = new Inner();
        in.show();
    }

    {
        // 内部类在代码块中
        class Inner2{
            void show(){
                System.out.println("代码块中的内部类：" + num);
            }
        }
        Inner2 in2 = new Inner2();
        in2.show();
    }
}

内部类在局部位置上只能访问局部中被final修饰的局部变量；

class Outer{
    int num = 3;
    void method(){

        final int x  = 9; // 这个好像都行 int x = 9 不报错；
        class Inner{
            void show(){
                System.out.println("show..."+x); // 内部类在局部位置上只能访问局部中被final修饰的局部变量；
            }
        }
        // 创建对象
        Inner in = new Inner();
        in.show();
    }
}

匿名内部类

概述

内部类的简写格式。要简写，必须和外部类有关系。必须有前提：内部类必须继承或者实现一个外部类或者接口。

格式： new 父类or接口（）{子类内容}；

匿名内部类，其实就是一个匿名子类对象；这个对象比较胖。

按道理要先继承父类，重构方法，再创建对象调用方法如：

class Inner extends InnerDemo{
    void show() {
        System.out.println("内部类run..." + num);
    }
}
public void method() {
   new Inner().show();
}

现在直接在方法里，进行new 父类（）{重构方法；}

new InnerDemo(){ // 匿名内部类，new 他爹(){把方法重写；}
    void show(){
        System.out.println("show..."+num);
    }
}

具体代码如下：

public class InnerClassDemo {
    public static void main(String[] args) {
        new Outer().method();
    }
}

// 抽象类
abstract class InnerDemo{
    abstract void show();
}
class Outer {

    private int num = 3;

    // 内部类
//    class Inner {
//        void show() {
//            System.out.println("内部类run..." + num);
//        }
//
//    }

    public void method() {
//        new Inner().show();
        new InnerDemo(){ // 匿名内部类，new 他爹(){把方法重写；}
            void show(){
                System.out.println("show..."+num);
            }
        }.show();
    }
}

应用

注释部分：普通内部类继承外部接口时代码：

interface Inter{
    void show1();
    void show2();
}
class Outer {
    private int num = 3;

    // 内部类
    /*
    class Inner implements Inter {
        public void show1(){

        }
        public void show2(){

        }
    }
    */
    public void method(){

//        Inner in = new Inner();
//        in.show1();
//        in.show2();
        Inter in = new Inter(){
            public void show1(){

            }
            public void show2(){

            }

        };
        in.show1();
        in.show2();
    }
}

通常的使用场景之一：当函数参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递。

// 正常写
public class InnerClassDemo {
    public static void main(String[] args) {
    
    show(new InterImpl());
}
    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}
interface Inter{
    void show1();
    void show2();
}

class InterImpl implements Inter{
    public void show1(){}
    public void show2(){}
}

// 简写，将匿名内作为实际参数传递
public class InnerClassDemo {
    public static void main(String[] args) {
    
    show(new Inter(){
        public void show1(){}
        public void show2(){}
    });
}   
    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}
//接口
interface Inter{
    void show1();
    void show2();
}

分类

  • 成员内部类（静态内部类和非静态内部类）
  • 局部内部类
  • 匿名内部类

成员内部类

  • 静态内部类：直接通过外部类调用静态内部类的构造器
  • 非静态内部类：先创建外部类的对象，再通过外部类的对象调用内部类的构造器或者
    外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
package innerdemo;

/**
 * @ClassName: InnerClassDemo
 * @author: benjamin
 * @version: 1.0
 * @description: TODO
 * @createTime: 2019/06/11/10:11
 */

public class InnerClassDemo {
    public static void main(String[] args) {
        // 创建静态内部类的对象
        Person.Dog d = new Person.Dog();// 直接通过外部类调用静态内部类的构造器
        //创建非静态内部类的对象
//        Person.Bird b = new Person().new Bird();
        Person p = new Person();
        Person.Bird b = p.new Bird();// 通过外部类的对象调用内部类的构造器
        b.info();

    }
}

class Person{

    String name;
    int age;

    // 非静态成员内部类
    class Bird{
        String name;
        int id;
        public Bird(){

        }

        public void setName(String name){
            this.name = name;
        }
        public void info(){
            show();
        }
    }

    // 静态成员内部类
    static class Dog{
        String name;
        int id;
        public Dog(){

        }

        public void setName(String name){
            this.name = name;
        }
        public void info(){

        }
    }


    // 外部类的成员方法
    public void show(){
        System.out.println("我是外部类的show()方法");
    }
}

局部内部类：常常使用一个方法，使其返回值为某个类或接口的对象，而这个类或接口在方法内部创建。举例：

匿名内部类：

举例：

class OuterJu{

    // 局部内部类的使用
    public Comparable getComparable(){
        //1.创建一个实现Comparable接口的类：局部内部类
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        }
        // 2. 返回一个实现类的对象
        return new MyComparable();
    }

    // 匿名内部类的使用
    public Comparable getComparable1(){
        //返回一个实现Comparable接口的匿名内部类的对象
        return new Comparable() {
            @Override
            public int compareTo(Object o) {
                return 0;
            }
        };
    }
}

细节

细节1

主函数会报错，因为无法访问非静态类，而且由于是静态不能采用this.new Inner()

方法：需要将Inner定义成静态类；

package java_demo_2;

/**
 * @ClassName: InnerClassDemo5
 * @author: benjamin
 * @version: 1.0
 * @description: TODO
 * @createTime: 2019/04/13/22:28
 */

public class InnerClassDemo5 {
    class Inner{// 如果不定义成静态，主函数会报错；

    }

    public static void main(String[] args) {

        new Inner(); //无法从静态上下文中引用非静态 变量 this
        // 因为主函数是静态的；
    }

    public void method(){
        
        new Inner(); // 正确
    }

    public static void show(Inter in){
        in.show1();
        in.show2();
    }
}

interface Inter{
    void show1();
    void show2();
}

细节2：

// 正确的
package java_demo_2;

public class InnerClassDemo6 {
    public static void main(String[] args) {

        new Outer6().method();
    }

}

class Outer6{

    // 创建的匿名内部类相当于
//    class Inner6 extends Object{
//        public void show(){
//            System.out.println("show run");
//        }
//    }
//    new Inner6.show();
    void method(){

        new Object(){
            public void show(){
                System.out.println("show run");
            }
        }.show();
    }
}

编译看左边

package java_demo_2;

public class InnerClassDemo6 {
    public static void main(String[] args) {

        new Outer6().method();
    }
}

class Outer6{

    void method(){

         Object obj = new Object(){
            public void show(){
                System.out.println("show run");
            }
         };
         obj.show();
//         Error:(35, 13) java: 找不到符号
        // 因为匿名内部类这个子类对象被向上转型为Object类型，
        // 这样就不再使用子类特有的方法了；
    }
}

标签：java,内部,show,void,class,new,public
来源： https://www.cnblogs.com/benjieqiang/p/11512813.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有