Java小白一文视图教废CSDN大佬成员内部类和静态内部类

已于 2024-08-16 20:59:53 修改
阅读量325 收藏 7
点赞数 4
分类专栏： JavaSE 文章标签： java 开发语言
于 2024-08-13 23:53:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kerwin_D/article/details/141176676
版权

这篇文章是接之前发的局部内部类和匿名内部类那篇文章来作收尾的，非常感谢诸位对上一篇文章的耐心阅读及点赞收藏，至此有关内部类的知识也到此为止了，Kerwin也要踏上后续Java知识的学习之路了，话不多说，开始吧！！！

成员内部类

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰的

  • 可以直接访问外部类的所有成员，包含私有的
//演示成员内部类
//1.注意：成员内部类，是定义在外部类的成员位置，这是其特点，不同于之前的局部内部类和匿名内部类
public class Journey {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();
    }
}

//外部类
class Outer{
    //属性
    private int youth=  656;
    public String essence = "多巴胺";
    //成员内部类，不同于局部内部类和匿名内部类，其没有写在方法中，
    //而是放在Outer类中成员的位置，所以称之为成员内部类
    class MemberInner {
        public void say(){
            //可以直接访问外部类中的所有成员，包含私有的
            System.out.println("Outer的youth=\t"+ youth+  " Outer的essence=\t"+essence);
        }
    }
    //写个方法m1,用于使用成员内部类Inner
    public void m1(){
        MemberInner inner = new MemberInner();
        inner.say();
    }
}
  • 可以添加任意访问修饰符（public protected 默认 private ），因为它的地位就是一个成员
//演示成员内部类
//注意：
//1.成员内部类，是定义在外部类的成员位置，这是其特点，不同于之前的局部内部类和匿名内部类
//2.成员内部类可以添加任意的访问修饰符public 、 private 、 默认（什么也不写）、protected
public class Journey {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();
    }
}

//外部类
class Outer{
    //属性
    private int youth=  656;
    public String essence = "多巴胺";
  //以下四种都可以哈，不会报错
//    class MemberInner {                   默认
//    public class MemberInner {            公开
//    protected class MemberInner {         受保护的
//    private class MemberInner {           私有的
     class MemberInner {

        public void say(){
            //可以直接访问外部类中的所有成员，包含私有的
            System.out.println("Outer的youth=\t"+ youth+  " Outer的essence=\t"+essence);
        }
    }
    //写个方法m1,用于使用成员内部类Inner
    public void m1(){
        MemberInner inner = new MemberInner();
        inner.say();
    }
}

  • 作用域和外部类的其他成员一样，为整个类体；

    比如上面案例中，在外部类的成员方法中创建成员内部类对象，再调用方法，MemberInner类的作用域是Outer整个类体

  • 成员内部类—访问—外部类成员（比如：属性）【访问方式：直接访问】

//省略主方法
class Outer{
    //属性
    private int youth=  656;
    public String essence = "多巴胺";
    private void hi(){
        System.out.println("Private method hi in Outer ");
    }
     class MemberInner {

        public void say(){
            //可以直接访问外部类中的所有成员，包含私有的
            System.out.println("Outer的youth=\t"+ youth+  " Outer的essence=\t"+essence);
            //访问私有方法，也是可以直接访问的
            hi();
        }
    }
    //写个方法m1,用于使用成员内部类Inner
    public void m1(){
        MemberInner inner = new MemberInner();
        inner.say();
    }

}
  • 外部类—访问—成员内部类【访问方式：创建对象，再访问】
public class Journey {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();
    }
}
//外部类
class Outer{
    //属性
    private int youth=  656;
    public String essence = "多巴胺";
    private void hi(){
        System.out.println("Private method hi in Outer ");
    }
     class MemberInner {
        public double sal = 999.9;

        public void say(){
            //可以直接访问外部类中的所有成员，包含私有的
            System.out.println("Outer的youth=\t"+ youth+  " Outer的essence=\t"+essence);
            //访问私有方法
            hi();
        }
    }
    
    //写个方法m1,用于访问成员内部类Inner
    public void m1(){
        //创建成员内部类的对象，然后使用相关的方法
        MemberInner inner = new MemberInner();
        inner.say();
        //访问成员内部类中的属性（私有、公开都可以的）
        System.out.println(inner.sal);
    }
    
    //上面的m1方法不能直接写成下面这个样子，因为Java中的类体主要用于定义成员变量和方法，而不是直接写执行语句的哈
    //写成m1方法是为了代码的结构性和可读性，
    //当然你也可以把创建对象的语句单独放到类体，把上下的两句执行语句封装成一个方法
        /*MemberInner inner = new MemberInner();
    	inner.say();
    	System.out.ptintln(inner.sal);*/

}
  • 外部其他类—访问----成员内部类 一共有两种方式来实现，要记住哟
public class Journey {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();

        //外部其他类，使用成员内部类的两种方式
        //第一种方式：
        //1.解读：outer.new MemberInner();相当于把new MemberInner()看作outer的成员
        //语法：   外部类.成员内部类  引用 = 外部类对象引用.new  成员内部类();
        Outer.MemberInner inner = outer.new MemberInner();
        //然后直接用引用去访问成员内部类的成员即可
        inner.say();//Outer的youth=	656 Outer的essence=	多巴胺
                    //Private method hi in Outer



        //第二种方式
        //在外部类中写一个方法，返回MemberInner类的实例   ---注意是在外部类中哈
        /**
         * 写在外部类中的哈，别打马虎眼
         * public MemberInner getMemberInnerInstance(){
         *         return new MemberInner();
         *     }
         */
        //然后外部类对象引用去获取下成员内部类实例
        Outer.MemberInner memberInnerInstance = outer.getMemberInnerInstance();
        //接下来，成员内部类实例就可以访问成员内部类的各个成员了
        memberInnerInstance.say();//Outer的youth=	656 Outer的essence=	多巴胺
                                  //Private method hi in Outer
        System.out.println(memberInnerInstance.sal);//999.9


    }
}

//外部类
class Outer{
    //属性
    private int youth=  656;
    public String essence = "多巴胺";
    private void hi(){
        System.out.println("Private method hi in Outer ");
    }
     class MemberInner {
        public double sal = 999.9;

        public void say(){
            //可以直接访问外部类中的所有成员，包含私有的
            System.out.println("Outer的youth=\t"+ youth+  " Outer的essence=\t"+essence);
            //访问私有方法
            hi();
        }
    }
    //写个方法m1,用于使用成员内部类Inner

    public void m1(){
        //创建成员内部类的对象，然后使用相关的方法
        MemberInner inner = new MemberInner();
        inner.say();
        //访问成员内部类中的属性（私有、公开都可以的）
        System.out.println(inner.sal);
    }


    /**
     在外部类中写一个方法，返回MemberInner的实例
     */
    public MemberInner getMemberInnerInstance(){
        return new MemberInner();
    }
}
  • 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问
public class Journey {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();
        
    }
}

//外部类
class Outer{
    //属性
    private int youth=  656;
    public String essence = "多巴胺";
    private void hi(){
        System.out.println("Private method hi in Outer ");
    }
     class MemberInner {
        public double sal = 999.9;
         //故意初始化一个与外部类成员重名的属性youth
        private int youth = 1110;

        public void say(){
            //如果成员内部类的成员和外部类的成员重名，会遵守就近原则
            //此时此刻，youth访问的不是外部类中的656了，而是1110,如果要访问外部类的同名成员就要采用 外部类.this.成员来访问
            System.out.println("成员内部类的youth=\t"+ youth+  " 外部类Outer的youth=\t"+Outer.this.youth);
            //访问私有方法
            hi();
        }
    }
    //写个方法m1,用于使用成员内部类Inner

    public void m1(){
        //创建成员内部类的对象，然后使用相关的方法
        MemberInner inner = new MemberInner();
        inner.say();
        //访问成员内部类中的属性（私有、公开都可以的）
        System.out.println(inner.sal);
    }
    
}

//输出结果
成员内部类的youth=	1110 外部类Outer的youth=	656
Private method hi in Outer 
999.9

静态内部类

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

  • 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
public class Journey {
    public static void main(String[] args) {

    }
}
class Outer{//外部类
    private int youth = 656;
    private static String essence = "多巴胺戒断";
    //StaticInner就是静态内部类
//    1.放在外部类的成员位置
//    2.使用static修饰
//    3.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    

    static class StaticInner{
        public void say(){
            //无法访问非静态的成员
//            System.out.println(youth);
            //访问静态成员是允许的
            System.out.println(essence);
        }

    }

}
  • 可以添加任意访问修饰符，因为它的地位就是一个成员
public class Journey {
    public static void main(String[] args) {

    }
}
class Outer{//外部类
    private int youth = 656;
    private static String essence = "多巴胺戒断";
    //StaticInner就是静态内部类
//    1.放在外部类的成员位置
//    2.使用static修饰
//    3.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
//    4.可以添加任意访问修饰符，因为它的地位就是一个成员,以下四种均不会报错


//     public static class StaticInner{                public
//     private static class StaticInner{			  private
//     protected static class StaticInner{			  protected
     static class StaticInner{//                       默认什么也不写
        public void say(){
            //无法访问非静态的成员
//            System.out.println(youth);
            //访问静态成员是允许的
            System.out.println(essence);
        }

    }

}
  • 作用域： 同其他的成员，为整个类体；即StaticInner静态内部类的作用域为整个外部类Outer
public class Journey {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();
    }
}
class Outer{//外部类
    private int youth = 656;
    private static String essence = "多巴胺戒断";
    //StaticInner就是静态内部类
//    5.作用域为整个类体
//       在外部类中创建一个m1(),来方便调用静态内部类，之后就可以直接在main方法中调用静态内部类中的成员
     static class StaticInner{
        public void say(){
            //无法访问非静态的成员
//            System.out.println(youth);
            //访问静态成员是允许的
            System.out.println(essence);
        }

    }
//方法m1来便于使用静态内部类
    public void m1(){
        //创建静态内部类的对象，然后调用其内部的say方法
        StaticInner staticInner = new StaticInner();
        staticInner.say();
    }

}
  • 静态内部类—访问—>外部类（比如：静态属性）【访问方式：直接访问所有静态成员】
//上面已经提过了，即静态内部类中，直接访问外部类中的静态属性essence是OK的
class Outer{//外部类
    private int youth = 656;
    private static String essence = "多巴胺戒断";
    private static void cry(){
        System.out.println("Don't cry!!!    外部类静态方法");
    }
    //StaticInner就是静态内部类
     static class StaticInner{
        public void say(){
            //无法访问非静态的成员
//            System.out.println(youth);
            //访问静态成员是允许的
            System.out.println(essence);//静态属性
            cry();//静态方法
        }

    }
}
  • 外部类—访问—>静态内部类【访问方式：创建对象，再访问】
//之前提到的m1()就是外部类中的方法，可以去访问静态内部类，其逻辑也是先创建对象，然后访问
public class Journey {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();
    }
}
class Outer{//外部类
    private int youth = 656;
    private static String essence = "多巴胺戒断";

//       在外部类中创建一个m1(),来方便调用静态内部类，之后就可以直接在main方法中调用静态内部类中的成员
     static class StaticInner{
        public void say(){
            //无法访问非静态的成员
//            System.out.println(youth);
            //访问静态成员是允许的
            System.out.println(essence);
        }

    }
//方法m1来便于使用静态内部类     		这里就很好地解释了这一点
    public void m1(){
        //先创建静态内部类的对象，然后访问其内部的say方法
        StaticInner staticInner = new StaticInner();
        staticInner.say();
    }
}
  • 外部其他类—访问---->静态内部类
public class Journey {//外部其他类
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();//输出-->多巴胺戒断
//输出-->        Don't cry!!!    外部类静态方法

        //外部其他类访问静态内部类
        //第一种方式
        //直接new 外部类.静态内部类就可以快捷生成
        //语法： 外部类.静态内部类  引用 = new 外部类.静态内部类();
        //分析：因为静态内部类，是可以通过类名直接访问的（前提是满足访问权限哈，即不要在静态内部类前加个private然后来怀疑自己是不是记错了hhh）
        Outer.StaticInner staticInner = new Outer.StaticInner();
        staticInner.say();//输出-->多巴胺戒断
// 输出-->       Don't cry!!!    外部类静态方法


        
        //第二种方式
//        外部类中编写一个方法，可以返回静态内部类的对象实例
        /**
         *     //在外部类中编写方法，获取到静态内部类的对象实例
         *     public StaticInner getStaticInnerInstance(){
         *         return new StaticInner();
         *     }
         */
        //初始化静态内部类对象实例
        Outer.StaticInner staticInnerInstance = outer.getStaticInnerInstance();

        staticInnerInstance.say();//输出-->多巴胺戒断
// 输出-->       Don't cry!!!    外部类静态方法


        
        
        //第三种方式
//        外部类中编写静态的获取静态内部类实例的方法
        /**
         //第三种方式,编写静态方法，这样就可以之后在main方法中直接访问静态内部类成员了
         public static StaticInner getStaticInnerInstance2(){
         return new StaticInner();
         }
         *
         */
//        这样就比第二种方式要略微简单些，可以直接  外部类.get静态内部类()来快捷生成了
        //相比于第二种，这种方式连outer这个外部类对象都不用在main方法中创建，就可以返回一个静态内部类的对象
        Outer.StaticInner staticInnerInstance2 = Outer.getStaticInnerInstance2();

        staticInnerInstance2.say();//输出-->多巴胺戒断
// 输出-->       Don't cry!!!    外部类静态方法



    }
}
class Outer{//外部类
    private int youth = 656;
    private static String essence = "多巴胺戒断";
    private static void cry(){
        System.out.println("Don't cry!!!    外部类静态方法");
    }
    //StaticInner就是静态内部类
     static class StaticInner{
        public void say(){
            //无法访问非静态的成员
//            System.out.println(youth);
            //访问静态成员是允许的
            System.out.println(essence);
            cry();
        }

    }

    public void m1(){
        StaticInner staticInner = new StaticInner();
        staticInner.say();
    }

    //第二种方式，编写方法，获取到静态内部类的对象实例
    public StaticInner getStaticInnerInstance(){
        return new StaticInner();
    }

    //第三种方式,编写静态方法，这样就可以之后在main方法中直接访问静态内部类成员了
    public static StaticInner getStaticInnerInstance2(){
        return new StaticInner();
    }

}
  • 如果外部类和静态内部类的成员重名的话，静态内部类访问时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.成员）去访问
     static class StaticInner{
        //故意写个与外部类属性重名的essence
        private static  String essence = "内啡肽调节";
        public void say(){
//          此时访问的essence不是外部类的了，而是静态内部类的"内啡肽调节"
            System.out.println(essence);
//            如果我们此时想访问外部类的同名属性essence,则按照 外部类.成员 的方式即可实现
            System.out.println(Outer.essence);
            cry();
        }

    }

谢谢看到这儿的小伙伴，欢迎诸位看完后指出其中的问题或私信提出文章的改进建议，明天见，铁子们，拜~~

Kerwin要坚持日更
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值