精华内容
下载资源
问答
  • 2021-11-20 17:06:25

    🍅 作者简介:哪吒,CSDN2021博客之星亚军🏆、新星计划导师✌、博客专家💪

    🍅 哪吒多年工作总结:Java学习路线总结,搬砖工逆袭Java架构师

    🍅 关注公众号【哪吒编程】,回复1024,获取Java学习路线思维导图、大厂面试真题、加入万粉计划交流群、一起学习进步

    更多相关内容
  • Java内部类以及使用场景

    千次阅读 2020-12-15 19:14:36
    那么,为什么会有内部类这个概念,他的使用场景又是什么呢?首先,来看一下内部类的特点: 1. 它体现了一种代码的隐藏机制和访问控制机制,内部类与所在外部有一定的关系,往往只有该外部调用此内部类,所以没有...

    所谓内部类,即定义在另一个类中的类。那么,为什么会有内部类这个概念,他的使用场景又是什么呢?首先,来看一下内部类的特点:
    1. 它体现了一种代码的隐藏机制和访问控制机制,内部类与所在外部类有一定的关系,往往只有该外部类调用此内部类,所以没有必要专门用一个Java文件存放这个类。

        public class Outer {
      private int num; 
      private class Inner {
        private int num;
      }
    }
    
    一般的类是不允许用private修饰符的,但是内部类却可以,该实例中,类Inner只对Outer可见,其他的类无法访问的到Inner类。
    
    
    注意,这里有个例外,如果内部类的访问修饰符被设定为public,那么它是可以被其他类使用的,但是必须经由外部类来实例化内部类。
    
    
       public class Outer {
       private int num = 1;
    
       public class Inner {
           private int num = 2;
       }
    
       public static void main(String[] args) {
           Outer outer = new Outer();
           Inner inner = outer.new Inner();
           System.out.println(inner.num);
       }
    }
    
    1. 它包含有一个对外部类的this指针,从而可以访问外部类的所有元素,包括所有public/private的成员和方法:
        public class Outer {
        private int num = 1;
    
        public class Inner {
            private int num = 2;
            private void func () {
                System.out.println(Outer.this.num);
            }
        }
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            Inner inner = outer.new Inner();
            inner.func();
        }
    }
    
    1. 另一方面,反向的,外部类对内部类的所有元素也都有访问权,包括内部类的私有成员和方法:
        public class Outer {
        private int num = 1;
    
        public class Inner {
            private int num = 2;
        }
    
        public void func () {
            Inner inner = new Inner();
            System.out.println(inner.num);
        }
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.func();    // 2
        }
    }
    

    分类:

    一、成员内部类

    当某个类除了他的外部类,不会被其他类使用时,使用成员内部类。这种情况下,内部类依附于外部类而存在,原因可能有: 1. 不可能有其他类使用该内部类。 2. 该内部类不能被其他类使用,可能会导致错误。这是内部类使用比较多的一个场景。
    1) 外部类可以直接访问内部类的成员和方法,但是必须先创建一个内部类的对象,再通过该对象使用其成员和方法。
    2) 内部类可以访问外部类的成员和方法,但是要注意,当内部类拥有和外部类相同的成员或方法时,会发生隐藏现象,默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员,需要以下面的形式访问:外部类.this.成员变量/方法
    3) 内部类只是一个编译时的概念,一旦编译成功,就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部定义的名为Inner的内部类,编译完后会生成Outer.class和Outer$Inner.class两个类
    4) 成员内部类与普通的成员没什么区别,可以与普通成员一样进行修饰和限制
    
    
        public class Outer {
        private int num = 1;
        private int num1 = 10;
    
        public class Inner {
            private int num = 2;
            public void func () {
                System.out.println(Outer.this.num);
                System.out.println(num1);
            }
        }
    
        public static void main(String[] args) {
            Outer outer = new Outer();
            Inner inner = outer.new Inner();
            inner.func();
        }
    }
    
    

    二、局部内部类

     局部内部类是定义在一个方法或者一个作用域里面的类,它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。局部内部类就像方法里面的局部变量一样,是不能有public、protected、private及static修饰符的。
    
      public class Outer {
      private int num = 1;
      private int num1 = 10;
    
      public void func () {
          class Inner {
              private int num = 2;
          }
          Inner inner = new Inner();
          System.out.println(inner.num);
      }
    
    
      public static void main(String[] args) {
          Outer outer = new Outer();
          outer.func();
      }
    }
    

    三、静态内部类

    静态内部类也是定义在另一个类里面的类,只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的,它不持有指向外部类对象的引用this,并且它不能使用外部类的非static成员或方法,这点很好理解,因为在没有外部类的对象的情况下,可以创建静态内部类的对象,如果允许访问外部类的非static成员就会产生矛盾,因为外部类的非static成员必须依附于具体对象。它唯一的作用就是随着类的加载(而不是随着对象的产生)而产生。
    
        public class Outer {
    
        static class Inner {
            public Inner () {
    
            }
        }
    
        public static void main(String[] args) {
            Outer.Inner innner = new Outer.Inner();
        }
    }
    

    四、匿名内部类

    匿名内部类应该是平时我们编写代码时用的最多的,在编写事件监听的代码时匿名内部类不但方便,而且使代码更加容易维护。匿名内部类是唯一一种没有构造器的类。正因为其没有构造器,所以匿名内部类的使用范围非常有限,大部分匿名内部类用于接口回调。匿名内部类在编译的时候由系统自动起名为Outer$1.class。一般来说,匿名内部类用于集成其他类或者实现接口,并不需要增加额外的方法,只是对集成方法的实现或是重写。
    
       public class Outer {
    
       public void func () {
           System.out.println("1");
       }
    
    
       public static void main(String[] args) {
           Outer inner = new Outer() {
               public void func () {
                   System.out.println("2");
               }
           };
           inner.func();
       }
    }
    
    总结:
    1. 每个内部类都能独立的集成一个接口的实现,所以无论外部类是否已经集成了某个(接口)实现,对于内部类都没有影响。内部类使得多重集成的解决方案变得完整。
    2. 方便将存在一定逻辑关系的类组织在一起,又可以对外界隐藏。
    3. 方便编写时间驱动程序。
    4. 方便编写线程代码。
    

    转载至:cnblogs.com/firefrost/p/5064210.html

    展开全文
  • java内部类使用场景

    千次阅读 2017-03-17 23:48:52
    说明:内部类和外部的关系:内部类(除去用static修饰的)可以直接使用其外部的成员变量以及成员函数,达到一个继承的效果,再加上自身继承基类来达到一个多重继承的效果.如下代码。public class OuterClass {

    参考:http://blog.csdn.net/historyasamirror/article/details/6049073

    使用场景:

    1..达到一个多重继承的效果.
    说明:内部类和外部类的关系:内部类(除去用static修饰的)可以直接使用其外部类的成员变量以及成员函数,达到一个继承的效果,再加上自身继承基类来达到一个多重继承的效果.如下代码。

    public class OuterClass {
        //内部类
        class InnerClass extends CommonClass{
    
            public void enhanceMethod1(){
                 System.out.println("before");
                 super.method1();//调用父类commonClass的函数
                 method();//调用外部类outerClass的函数
                 System.out.println("after");
            };
        }
     /***********************************************************************/   
        public void  method(){
            System.out.println("method函数");
        }
    }

    2.访问控制,只能通过其外部类来调用

    //1.在其他类中 **需要**  通过outerCLass来创建和调用内部类innerClass
     InnerClass innerClass = new OuterClass().new InnerClass();

    3.事件驱动
    直接参考参考:http://blog.csdn.net/historyasamirror/article/details/6049073
    一文中最后的代码。

    展开全文
  • java中的内部类使用场景

    千次阅读 2022-04-01 22:48:12
    java内部类分为:成员内部、静态内部、局部内部、匿名内部使用场景: 成员内部:不想被其他公开使用,因为外部只能定义为public或者缺省。 静态内部:一个与另一个关联性比较强,但是又...

    java中的内部类

    java内部类分为:成员内部类、静态内部类、局部内部类、匿名内部类。

    使用场景:

    • 成员内部类:不想被其他类公开使用的类,因为外部类只能定义为public或者缺省。类是属于对象的,所以不能有静态属性
    • 静态内部类:一个类与另一个类关联性比较强,但是又可以不依赖外部类而独立存在。比如HashMap与Node。静态内部类是属于类的,跟普通类使用没什么区别。
    • 局部内部类:局部内部类访问方法中定义的final类型的局部变量,局部类完全对外部隐藏,比较少用
    • 匿名内部类:适用于快速构造对象,lambda表达式等场景

    成员内部类

    • 内部类的对象总有一个隐式引用,它指向创建它的外部类的对象,编译器修改了所有的内部类的构造器,添加了一个外围类引用的参数OuterClass.this

    • 内部类构造器:A.B = new A().newB()

    • 内部类不允许有static变量(static final除外)和方法

    • 内部类拥有访问特权,可以访问外围类的私有域

    // 只能public或缺省修饰
    public class Outer {
    
        private static String name;
    
        private String key;
    
        private String getKey() {
            return key;
        }
    
        // public、private、protected或缺省修饰
        private class Inner {
            // static变量必须为常量
            private static final int LEN = 1;
    
            // 不能有static方法
            private void inner() {
                // 可以直接访问外部类的所有属性与方法
                System.out.println(key);
                // 外部类的static属性也可以访问
                System.out.println(name);
            }
    
        }
    }
    

    静态内部类

    • 静态内部类没有外围类对象的引用特权
    • 静态内部类可以有静态域和方法
    • 声明在接口中的内部类自动成为public static类
    public class Outer {
    
        private String key;
    
        static class Inner{
            // 可以有static属性
            private static int len = 1;
    
            // 可以有static方法
            private static void inner() {
                // 不能访问外部类属性key
                System.out.println(len);
            }
        }
    
    }
    

    局部内部类

    • 局部类不能用public或private声明,作用域被限定在声明这个局部类的块中
    • 不能有static方法和属性(static final除外)
    • 只能访问局部的final变量
    public class Outer {
        public static void main(String[] args) {
            final Object a = new Object() ;
            Object b = new Object();
            class Inner{
                // 不能有static与属性
                private void test() {
                    // 只能访问final对象a
                    System.out.println(a);
                }
            }
            // b重新赋值,否则可能会将b优化为final
            b = new Object();
        }
    }
    

    匿名内部类

    • 匿名类不能有构造器,将构造器参数传递给超类的构造器
    • 匿名类的equals方法无法判断:if (getClass() != other.getClass()) return false;
    • “双括号初始化”
    • 匿名内部类类名为OutClass$数字
    invite(new ArrayList<String>() { {add("Harry"); add("Tony"); } } )
    
    展开全文
  • Java内部类的四个应用场景
  • 三种java内部类及其应用场景

    千次阅读 2019-11-17 13:16:53
    内部类: 成员内部类 局部内部类 匿名内部类 内部类仍然是一个独立的,在编译之后会被编译成独立的.class文件, 但是前面冠以外部的类名和$号 内部类不能用普通的方式访问,内部类是外部的一个成员 ,因此...
  • Java内部类是Java言语的一个很重要的概念,《Java编程思想》花了很大的篇幅来讲述这个概念。但是我们在实践中很少用到它...本文试图谈一谈让这个幕后英雄也有用武之地的四个场景,希望引起大家对使用Java内部类的兴趣。
  • 问题:内部类、静态内部类区别、使用场景?1.静态内部类可以有静态成员(方法,属性),而非静态内部类则不能有静态成员(方法,属性)。2.静态内部类只能够访问外部的静态成员,而非静态内部类则可以访问外部的所有...
  • java内部类使用场景

    千次阅读 2015-07-01 15:45:09
    转载:... ... 场景一:  当某个除了它的外部,不再被其他的类使用的时,可以考虑将其定义为内部类场景二: 解决一些非面向对象的语句块 场景之三: 一些多算法场合,
  • 无意间都到一篇《走心的安卓工程师跳槽经验分享》,发现自己工作几年了,技术方面虽然有了飞跃的进步,可是不知道自己的技术...第一节 内部区别以及使用场景。(java内部类 百度百科) java内部类分为: 成员内部...
  • java匿名内部类什么是匿名内部类?匿名内部类使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承) 什么是匿名内部类? 匿名内部类,顾名思义,就是不知道这个到底是什么名字,也...
  • Java 匿名(匿名内部类)

    万次阅读 多人点赞 2020-12-25 23:41:48
    Java匿名(匿名内部类) 学习的参考博文:无恨之都 1. 初识 匿名 标准说法: 内部类包括:成员、局部、匿名(匿名内部类)。 匿名概念: 匿名可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。 你可以...
  • 一、java实体entity实体类场景:比如mvc设计中model层定义java实体对java实体的众多理解:A. 通常定义在model层里面B. 一般的实体对应一个数据表,其中的属性对应数据表中的字段。好处:1、对象实体(其实是...
  • Java中匿名内部类使用

    万次阅读 多人点赞 2018-10-04 16:24:35
     当或接口类型作为参数传递时,可以直接使用匿名内部类方式创建对应的对象 3、匿名内部类嵌套使用 ① 需求:按main方法中给出的调用方式补全Class InnerClass中的代码,使得在控制台中能够输出HelloWorld。 ...
  • Java内部类与匿名内部的区别

    千次阅读 2017-05-23 13:25:28
    内部类内部类基本概念如果A需要直接访问B中的成员,而B又需要建立A的对象。这时,为了方便设计和访问,直接将A定义在B中。
  • java 内部类(inner class)详解

    万次阅读 多人点赞 2016-06-30 17:30:17
    一、为何使用内部类 内部类提供了更好的封装,只有外部能访问内部类 内部类可以独立继承一个接口,不受外部是否继承接口影响 内部类中的属性和方法即使是外部也不能直接访问,相反内部类可以直接访问外部的...
  • 幕后英雄的用武之地 ——浅谈Java内部类的四个应用场景 Java内部类是Java言语的一个很重要的概念,《Java编程思想》花了很大的篇幅来
  • 文章出自:安卓进阶学习指南 主要贡献者: Cloud9527 Alex_赵 Struggle shixinzhang ...成员内部类使用场景 静态内部类使用场景 匿名内部类使用场景 局部内部类 内存泄漏 总结 ...
  • Java内部类详解

    千次阅读 多人点赞 2018-03-19 20:02:47
    Java内部类详解  说起内部这个词,想必很多人都不陌生,但是又会觉得不熟悉。原因是平时编写代码时可能用到的场景不多,用得最多的是在有事件监听的情况下,并且即使用到也很少去总结内部的用法。今天我们就来...
  • 一个匿名内部类仅适用在想使用一个局部并且只会使用这个局部一次的场景。 匿名内部类是没有需要明确声明的构造函数的,但是会有一个隐藏的自动声明的构造函数。 创建匿名内部类有两种办法: 通过继承一个...
  • 静态内部类使用场景

    千次阅读 2015-09-08 16:11:32
    在实际的工作开发中,使用普通的内部类场景比较多,似乎静态内部类并不常用,但是它也有其特定的使用场景。 比如说我们学习JAVA的时候,的main方法,它是static 方法,是程序的入口,但不需要每个java文件都定义...
  • 基础篇:JAVA内部类使用介绍

    千次阅读 多人点赞 2020-08-30 10:23:24
    内部类的介绍及使用
  • Java 内部类和匿名内部类

    万次阅读 多人点赞 2017-11-01 19:07:21
    内部类分为成员内部类(定义在外部的成员位置)和局部内部类(定义在外部的方法里面)。 (1) 成员内部类 class Outer { class Inner { //成员内部类 } } 成员内部类的特点: 1、成员内部类可以直接访问...
  • 昨天的文章中,遗留了一个问题就是,为什么Java内部类字段和方法不能使用static修饰。先下下面一段代码:class OuterClass { public int age=20; class InnerClass { static int i = 100; // compile error ...
  • 详解java动态代理机制以及使用场景(一)

    万次阅读 多人点赞 2017-10-19 10:29:10
    说起java动态代理,在我刚开始学java时对这项技术也是十分困惑,明明可以直接调通的对象方法为什么还要使用动态代理?随着学习的不断深入和工作经验的积累,慢慢的体会并理解了java动态代理机制。昨天再给公司新同事...
  • 在Java编程中,使用private关键字修饰了某个成员,只有...Java内部类 在Java中相信很多人都用过内部,Java允许在一个里面定义另一个里面的就是内部,也叫做嵌套。一个简单的内部实现可以如下 clas...
  • Java中的反射基础及其应用场景

    千次阅读 2021-11-09 15:42:18
    1.基础 1、反射的定义: Java反射机制是在运行状态中,对于任意一个,都能够知道这个中的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和...3Java 反射机制的应用场景 逆向代码 ,例如反编译.
  • java非静态内部类中的属性this$0

    千次阅读 2019-10-07 21:21:43
    和普通的外层一样,只是碰巧被声明在另一个内部而已,而且还带有点特殊技能:可以访问外层的所有成员(包括私有的)。 非静态成员的每个实例都隐含着与外层的一个外层实例(在jdk...
  • Java设计模式常见使用场景

    万次阅读 多人点赞 2018-05-09 16:07:16
    一、Java I/O中的设计模式1、适配器模式适配器模式就是把一个的接口变换成客户端所能接受的另一种接口,从而使两个接口不匹配而无法在一起工作的两个能够在一起工作。通常被用在一个项目需要引用一些开源框架来...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 331,391
精华内容 132,556
关键字:

java内部类使用场景

java 订阅