Java内部类详解

林的快手

已于 2024-06-22 10:19:00 修改

阅读量573

点赞数 21

分类专栏： JAVA 文章标签： java 开发语言

于 2024-06-21 23:58:00 首次发布

本文链接：https://blog.csdn.net/weixin_65752158/article/details/139859783

版权

JAVA 专栏收录该内容

37 篇文章 0 订阅

订阅专栏

概述

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。可以把内部类理解成寄生，外部类理解成宿主。

public class Car {
     String carname;
     int carAge;
     String carColor;
    public void show(Car this){
        //打印的是调用者车的名字:宾利
        System.out.println(this.carname);
        Engine e = new Engine();
        e.engineAge=1;
        e.engineName="保时捷";
        System.out.println(e.engineAge);
    }
    class Engine {
        String engineName;
        int engineAge;

        public void show() {
            System.out.println(engineName);
            System.out.println(carColor);
        }
    }
}

package NBN.nbndemo01;

public class Test {
    public static void main(String[] args) {
        Car c = new Car();
        c.carname = "宾利";
        c.carAge = 1;
        c.carColor = "黑";
        c.show();
    }

}

什么时候使用内部类

一个事物内部还有一个独立的事物，内部的事物脱离外部的事物无法独立使用

人里面有一颗心脏。

汽车内部有一个发动机。

为了实现更好的封装性。

内部类的分类

按定义的位置来分

成员内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)

静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)

局部内部类，类定义在方法内

匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

成员内部类

成员内部类特点：

无static修饰的内部类，属于外部类对象的。

宿主：外部类对象。

内部类的使用格式：

外部类.内部类。 // 访问内部类的类型都是用外部类.内部类

获取成员内部类对象的两种方式：

方式一：外部直接创建成员内部类的对象

外部类.内部类变量 = new 外部类（）.new 内部类（）;

方式二：在外部类中定义一个方法提供内部类的对象

案例演示

方法1

方式一：
public class Test {
    public static void main(String[] args) {
        // 创建内部类对象。
        Outer.Inner oi = new Outer().new Inner();
        oi.method();
    }
}

class Outer {
    // 成员内部类，属于外部类对象的。
    // 拓展：成员内部类不能定义静态成员。
    public class Inner{
        // 这里面的东西与类是完全一样的。
        public void method(){
            System.out.println("内部类中的方法被调用了");
        }
    }
}

方式二：
public class Outer {
    String name;
    private class Inner{
        static int a = 10;
    }
    public Inner getInstance(){
        return new Inner();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer o = new Outer();
        System.out.println(o.getInstance());


    }
}

成员内部类的细节

编写成员内部类的注意点：

成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等

在成员内部类里面，JDK16之前不能定义静态变量，JDK16开始才可以定义静态变量。

创建内部类对象时，对象中有一个隐含的Outer.this记录外部类对象的地址值。（请参见3.6节的内存图）

详解：

内部类被private修饰，外界无法直接获取内部类的对象，只能通过3.3节中的方式二获取内部类的对象

被其他权限修饰符修饰的内部类一般用3.3节中的方式一直接获取内部类的对象

内部类被static修饰是成员内部类中的特殊情况，叫做静态内部类下面单独学习。

内部类如果想要访问外部类的成员变量，外部类的变量必须用final修饰，JDK8以前必须手动写final，JDK8之后不需要手动写，JDK默认加上。

public class Outer {
    private int a = 10;

    class Inter {
        private int a = 20;

        public void show() {
            int a = 30;
            //System.out.println(??);10
            // System.out.println(??);20
            // System.out.println(??);30
            System.out.println(Outer.this.a);//获取外部类a的值
            System.out.println(Inter.this.a);
            System.out.println(a);
        }
    }
}

package NBN.nbndemo02;

public class Test {
    public static void main(String[] args) {
        //创建内部类的对象oi,并调用show方法
       Outer.Inter oi=new Outer().new Inter();
       oi.show();


    }
}

package NBN.nbndemo03;

public class Outer {
    int a=10;
      class  Inter{
        int a=20;
    }
}

public class Test {
    public static void main(String[] args) {
        //方法1 当内部类没有被private修饰的时候直接创建对象
        Outer.Inter oi=new Outer().new Inter();
        System.out.println(oi.a);
    }
}

方法2

public class Outer {
    String name;
    private class  Inter{
        int age=10;
    }
    public  int  getInter(){
        return new Inter().age;
    }
}

public class Test {
    public static void main(String[] args) {
        //方法2:当内部类被private修饰的时候
        //在对外类编写方法,对外提供内部类对象
        Outer o=new Outer();
        System.out.println(o.getInter());
    }
}

静态内部类

静态内部类特点：

静态内部类是一种特殊的成员内部类。

有static修饰，属于外部类本身的。

总结：静态内部类与其他类的用法完全一样。只是访问的时候需要加上外部类.内部类。

拓展1:静态内部类可以直接访问外部类的静态成员。

拓展2:静态内部类不可以直接访问外部类的非静态成员，如果要访问需要创建外部类的对象。

拓展3:静态内部类中没有Outer.this。

只要是静态的东西,都可以提供类名点直接获取

创建静态内部类对象来调用内部类的成员变量也就是调用非静态的变量

调用非静态方法的格式

先创建外部类的对象,然后用外部类去调用

调用静态方法的格式:外部类.内部类名.方法名();

public class Outer {
    // static int age=10;
    static class Inner {
        public void show1() {
            System.out.println("非静态的方法被调用了");
        }

        public static void show2() {
            System.out.println("静态的方法被调用了");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //System.out.println(Outer.age);//静态的直接提供类名去访问
        Outer.Inner oi = new Outer.Inner();
        oi.show1();//调用非静态区的方法
        Outer.Inner.show2();//用类名直接调用静态区的方法
    }
}

局部内部类

局部内部类 ：定义在方法中的类。
定义格式:
class 外部类名 {
   数据类型变量名;

   修饰符返回值类型方法名(参数列表) {
       // …
       class 内部类 {
           // 成员变量
           // 成员方法
       }
   }
}

外界是无法直接使用局部内部类，需要在方法里面创建对象并使用的

该类可以直接访问外部类的成员，也可以访问方法内的局部变量

匿名内部类【重点】

匿名内部类 ：是内部类的简化写法。他是一个隐含了名字的内部类。开发中，最常用到的内部类就是匿名内部类了。

格式

new 类名或者接口名() {
重写方法;
};

包含了：

继承或者实现关系

方法重写

创建对象

所以从语法上来讲，这个整体其实是匿名内部类对象

什么时候用到匿名内部类

实际上，如果我们希望定义一个只要使用一次的类，就可考虑使用匿名内部类。匿名内部类的本质作用是为了简化代码。

之前我们使用接口时，似乎得做如下几步操作：

定义子类

重写接口中的方法

创建子类对象

调用重写后的方法

public class Test {
    public static void main(String[] args) {
        //编写匿名内部类的代码
        new  Swim(){

            @Override
            public void swim() {
                System.out.println("重写了游泳方法");
            }
        };
    }
}

没有名字的类是实现了Swim接口,需要在自己的类中重写的抽象方法,new不是接口,new的是后面没有名字类的对象

没有名字的类就是继承了Animal,继承就要重写,new出来的就是没有名字类的对象,匿名内部类

以前写的常规方法

现在写的匿名内部类

method括号里面的当做参数传递给Animal a,而括号里面的,没有名字的类又是继承了Animal,new出来的就是没有名字类的对象 ,就相当于把Animal的子类对象传递给了参数Animal a

public class Test2 {
    public static void main(String[] args) {
        //整体我们可以理解为Swim接口的实现类对象
        //接口多态
      Swim s= new Swim(){

           @Override
           public void swim() {
               System.out.println("重新之后的游泳方法");
           }
       };
      //编译看左边,运行看右边
        s.swim();//首先看父类Swim有没有swim这个方法,如果没问题,运行就看没有名字的子类,也就是实现了Swim的接口的对象
        //就打印重新之后的游泳方法
    }
}

 new Swim(){

            @Override
            public void swim() {
                System.out.println("重新之后的游泳方法");
            }
        }.swim();//整体我们可以理解为Swim接口的实现类对象调用自己类的方法

Inter i=new Interlmpl（）

就是用父类i引用了子类 Interlmpl的对象

编译就看父类Inter 有没有这个变量或者方法实现看子类Interlmpl的方法或者变量

//整体我们可以理解为Swim接口的实现类对象或者是继承类的对象

public class Test {
    public static void main(String[] args) {
        //编写匿名内部类的代码
        new  Animal(){

            @Override
            public void eat() {
                System.out.println("动物在出东西");
            }
        };




        //在测试类中如何调用method方法
        //以前是自己写一个子类继承父类Anmial类
        //在创建子类的对象，把对象传递给method类的参数Anmial
        /*
        Dog d=new Dog
        method(d) //如果子类我只用一次就太麻烦了
         */
        method(
                new Animal() {
                    @Override
                    public void eat() {
                        System.out.println("狗出骨头");
                    }
                }
        );


    }
    public static void method(Animal a){Animal的子类对象传递给父类 Animal  ---多态
//Animial a 子类 多态
        a.eat();、、编译看左边，运行看右边
    }
}

结果就是狗出骨头

整体是一个对象,这个对象就是括号{}里的没有名字类创建出来的对象,没有名字类又是实现Swim接口,所以整体可以理解为实现Swim接口的实现类对象

林的快手

关注

21
点赞
踩
21

收藏

觉得还不错? 一键收藏
0
评论
Java内部类详解

内部类的使用格式：获取成员内部类对象的两种方式：案例演示方法1成员内部类的细节方法2创建静态内部类对象来调用内部类的成员变量也就是调用非静态的变量调用非静态方法的格式先创建外部类的对象,然后用外部类去调用调用静态方法的格式:外部类.内部类名.方法名();局部内部类：定义在方法中的类。定义格式:外界是无法直接使用局部内部类，需要在方法里面创建对象并使用的该类可以直接访问外部类的成员，也可以访问方法内的局部变量
复制链接

扫一扫