精华内容
下载资源
问答
  • 2021-02-28 13:05:49

    package day6$6;

    public class Inside {

    public static void main(String[] args) {

    //先创建一个外部类对象

    Outside in=new Outside();

    //在通过外部类对象创建一个内部类对象

    Outside.Indoor oi = in.new Indoor();

    //调用内部类自己的属性和方法

    oi.Swim();

    System.out.println(oi.oo);

    //外部类自己调用外部类

    in.age=8;

    System.out.println(in.age);

    System.out.println("=============================================");

    //静态内部类

    //静态内部类的创建需要依赖外部类

    Out.Ind j=new Out.Ind();

    //静态内部类不可以调用外部类的属性和方法

    //静态内部类调用自己的属性和方法

    j.pp="ajk";

    j.Swim();

    //在静态内部类中,只能使用外部类名直接调用外部的静态属性和方法

    Out.age=3;

    }

    }

    //外部类

    class Outside {

    String name = "张";

    static int age = 29;

    public void run() {

    System.out.println("我在狂奔");

    // 内部类

    }

    class Indoor {

    String oo = "aljk";

    public void Swim() {

    System.out.println("我在游泳");

    run();

    }

    }

    }

    //外部类

    class Out {

    String name = "张了";

    static int age = 2;

    public static void run() {

    System.out.println("我在夕阳狂奔");

    }

    // 静态内部类

    static class Ind {

    String pp= "appk";

    int age=5;

    public void Swim() {

    System.out.println("我在水库游泳");

    //直接使用自己类中的age

    System.out.println(age);

    //调用外部类中的age

    System.out.println(Out.age);

    //外部类的方法直接调用

    run();

    }

    }

    }

    更多相关内容
  • 主要介绍了Java单例模式实现静态内部类方法示例,涉及构造函数私有化等相关内容,需要的朋友可以了解下。
  • 主要介绍了Java中的静态内部类详解及代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 上次有朋友问我,java中的可以是static吗?我给他肯定的回答是可以的,在java中我们可以有静态实例变量、...当然也可以是静态的,下面小编整理了些关于java中的static class相关资料分享在脚本之家平台供大家参考
  • 主要介绍了Java内部类应用之静态内部类应用,结合实例形式分析了Java静态内部类的原理、功能、用法及相关操作注意事项,需要的朋友可以参考下
  • 静态内部类

    千次阅读 2021-07-25 13:04:24
    静态内部类就是用saitic关键字修饰的内部类类,是与类共享的,所以静态内部类的对象不依赖于外部类的对象,可直接创建。        我们先创建一个类,在其中创建一个静态内部类。 ...

           静态内部类就是用saitic关键字修饰的内部类类,是与类共享的,所以静态内部类的对象不依赖于外部类的对象,可直接创建。
           我们先创建一个类,在其中创建一个静态内部类。

    package people;
    //外部类
    public class Person {
        int age;
        static String name="小明";
        public void eat(){
            System.out.println("我是Person中的非静态方法");
        }
        public static void run(){
            System.out.println("我是Person中的静态方法");
        }
        public Heart getHeart(){
            new Heart().em=20;
            return new Heart();
        }
    
        //静态内部类
        static class Heart{
            static int age=13;
            int em=10;
            public static void say(){
                System.out.println("Hello"+name);
            }
            public String beat(){
                //通过对象实例来调用非静态成员
                new Person().eat();
                //可以直接调用外部类的静态成员
                run();
                //若调用外部类的同名熟悉,需要通过对象实例来调用 
                //格式:new 外部类名().属性名;如new Person().age  
                return age+"心脏再跳动!";
            }
        }
    }
    
    

           可以发现在静态内部类中我们如果调用外部类的静态方法或者静态属性,可直接调用。
           在调用非静态的方法和属性时,则需要通过对象实例来调用:new 外部类().属性名
           接下来在创建一个测试类。

    package people;
    //将内部类实例化
    public class PeopleTest {
        public static void main(String[] args) {
            Person lili=new Person();
            lili.age=12;
            //获取静态内部类对象实例
            Person.Heart myHeat=new Person.Heart();
            System.out.println(myHeat.beat());
            Person.Heart.say();
        }
    }
    

           可以发现静态内部类对象实例时,不需要依赖外部类对象。可以通过    外部类.内部类.静态成员;     来访问内部类中的静态成员。
           运行结果:

    我是Person中的非静态方法
    我是Person中的静态方法
    13心脏再跳动!
    Hello小明
    

    这里输出 13心脏再跳动 是因为虽然在上面声明lili.age=12,但是在静态内部类中有同名的age属性并且赋值为13,在静态内部类Heart中beat()方法的返回值默认为静态内部类的age,若想返回值为测试类中lili.age=12,将静态内部类中的返回语句修改为

    return new Person().age+"心脏再跳动!";
    

    本篇文章仅代表个人见解,如有错误,欢迎指正

    展开全文
  • 背景开发新项目,写Swager的mode的时候用到了嵌套Model,于是在代码中,出现了静态内部类。在codeReview的时候稍微和大家聊了一下。尤其是Static 修饰类和修饰对象和变量不一样呢?定义1. 内部类可以将一个类的定义...

    背景

    开发新项目,写Swager的mode的时候用到了嵌套Model,于是在代码中,出现了静态内部类。在codeReview的时候稍微和大家聊了一下。尤其是Static 修饰类和修饰对象和变量不一样呢?

    定义

    1. 内部类

    可以将一个类的定义放在另一个类的定义内部,这就是内部类;

    嵌套类是其封闭类的成员。非静态嵌套类(内部类)可以访问封闭类的其他成员,即使它们被声明为私有的也是如此。静态嵌套类无权访问封闭类的其他成员。为一体的一个部件OuterClass,一个嵌套类可以声明private,public,protected,或包专用。(回想一下,只能声明外部类public或将其包装为私有。)

    2. 静态内部类

    再一个普通类里面,给内部类加上static关键字的修饰;

    与类方法和变量一样,静态嵌套类与其外部类相关联。与静态类方法一样,静态嵌套类不能直接引用其封闭类中定义的实例变量或方法:它只能通过对象引用来使用它们。(就和两个普通不同的类之间的使用)

    3. 两者的区别

    内部类只是外部类的成员变量,通俗讲,就是你只能通过先调用外部类才能去拿到这个类(但是这是和组合还是有区别的)。

    但是静态内部类就像是一个普通类一样。可以直接调用,直接去new对象。

    4. Java 拥有嵌套类有什么作用呢?

    这是一种对仅在一个地方使用的类进行逻辑分组的方法:如果一个类仅对另一个类有用,那么将其嵌入该类并将两者保持在一起是合乎逻辑的。嵌套此类“帮助程序类”可使它们的程序包更加简化。

    它增加了封装:考虑两个顶级类A和B,其中B需要访问A的成员,否则将对其进行声明private。通过将类B隐藏在类A中,可以将A的成员声明为私有,而B可以访问它们。另外,B本身可以对外界隐藏。

    这可能会导致代码更具可读性和可维护性:在顶级类中嵌套小类会使代码更靠近使用位置。

    Demo

    talk is cheap ,Show me Code;

    package 静态内部类;

    import com.sun.tools.internal.xjc.reader.xmlschema.bindinfo.BIConversion;

    import javassist.runtime.Inner;

    import lombok.Data;

    /**

    * @authoryuanxindong

    * @date: 2020/6/19 10:25 下午

    */

    @Data

    public class OuterClassDemo {

    String outerStr;

    public OuterClassDemo(String outerStr) {

    this.outerStr = outerStr;

    }

    @Data

    public static class StaticInnerClass{

    public StaticInnerClass(String innerStr) {

    this.innerStr = innerStr;

    }

    private String innerStr;

    }

    @Data

    public class InnerClass{

    private String innerClassStr;

    public InnerClass(String outerStr) {

    //可以和外部类通讯

    this.innerClassStr = getOuterStr();

    }

    }

    public static void main(String[] args) {

    OuterClassDemo staticClassDemo =new OuterClassDemo("Outer");

    staticClassDemo.getOuterStr();

    // 内部正常类是不能直接new出来的

    // OuterClass outerClass = new OuterClass();

    StaticInnerClass innerClass = new StaticInnerClass("StaticInner");

    System.out.println(innerClass.getInnerStr());

    initInnerClass();

    }

    public static void initInnerClass(){

    OuterClassDemo staticClassDemo1 = new OuterClassDemo("OuterClassDemo");

    InnerClass innerClass = staticClassDemo1.new InnerClass("outerStr");

    System.out.println(innerClass.getInnerClassStr());

    }

    }

    注意事项

    序列化强烈建议不要对内部类(包括 本地和 匿名类)进行序列化。当Java编译器编译某些构造(例如内部类)时,它会创建综合构造。

    这些是类,方法,字段以及其他在源代码中没有相应构造的构造。合成构造使Java编译器无需更改JVM就可以实现新的Java语言功能。但是,合成构造在不同的Java编译器实现中可能有所不同,这意味着.class文件在不同的实现中也可能有所不同。因此,如果序列化一个内部类,然后使用其他JRE实现对其进行反序列化,则可能会遇到兼容性问题。

    核心讨论

    了解了静态内部类后,那static为什么修饰了类,对于这个类也是起了一个全局可用的一个作用?

    越想问题越多,还有就是为什么被Static 修饰的方法可以被类直接引用到?而static 修饰的类也可以被其他的类直接使用,而不依赖于对象。

    答 :我们得明确一下

    static修饰类的方法,表示这个方法和这个类对象没有关系,只是和这个类有关系

    static 修饰变量,按照是否静态的对类成员变量进行分类可分两种:一种是被static修饰的变量,叫静态变量或类变量;另一种是没有被static修饰的变量,叫实例变量。两者的区别是:

    对于静态变量在内存中只有一个拷贝(节省内存),JVM只为静态分配一次内存,在加载类的过程中完成静态变量的内存分配,可用类名直接访问(方便),当然也可以通过对象来访问(但是这是不推荐的)。

    好的,是这样的。static修饰对象 可以全局使用,修饰方法可以不依赖于对象,修饰类,也不用依赖与他的对象,也可以被其他的类直接使用,或者自己进行初始化。

    总结

    嵌套类:内部类和静态内部类

    内部类属于外部类的成员,必须依赖与外部对象来实现,静态内部类,不依赖,可以自己单独实现。

    static 的修饰 变量,类,方法,代码块。 共性全局性。变量的话也就是全剧唯一性,会出现多个饮用,但不会出现多个存储。

    展开全文
  • 本篇是对现网上流传的 Kotlin 实现静态内部类单例模式的纠正,为了把原理说清楚,文章前奏可能会有些长,熟悉静态内部类单例模式原理的朋友,可以直接跳转到文章最后,直接看结果即可。 最近在整理基础库的时候,...

    本篇是对现网上流传的 Kotlin 实现静态内部类单例模式的纠正,为了把原理说清楚,文章前奏可能会有些长,熟悉静态内部类单例模式原理的朋友,可以直接跳转到文章最后,直接看结果即可。

    最近在整理基础库的时候,需要一个基础类来存储初始化的数据,例如应用的 Application Context,用户的登录 token 等等信息,这些基本都是应用全局类的信息,在应用的整个生命周期都会用到,因此我将这个基础类设计为单例模式来优化性能。

    我知道的单例模式就有6钟,饿汉式、懒汉式、线程安全的懒汉式,volatile + 双重校验锁试,静态内部类式,,枚举式。

    我挑哪种来用呢?那肯定是性能最好的呀!

    一个单例模式性能的好坏,主要考究其在复杂的生产环境下,还能否保证实例的唯一性

    可能会碰到的生产环境有以下几种,如果在以下情况下不能保证实例的唯一,那么该单例模式就是有瑕疵的。

    1. 多线程情况下是否会被多次创建。

    2. 反射调用单例类的构造方法时,能否重新创建实例。

    3. 如果单例类实现了 Serializable 接口,其反序列化时生成的实例是否与序列化时的实例是同一个。

    枚举式据说是最安全,性能最好的单例模式,Java 不允许反射调用枚举类的构造方法,对枚举类的序列化过程也做了特殊处理,同时枚举类利用语言特性保证了多线程安全。

    不过枚举式我用的非常少,个人不太习惯,我挑了使用最顺手的静态内部类式,这种单例模式我用的最多。

    然而静态内部类单例模式是有瑕疵的,静态内部类利用了类的加载机制保证了多线程安全,但其构造方法仍然可以通过反射的方式被外部调用。如果类实现了 Serializable 接口,那么其默认的反序列化过程生成的对象与序列化时的对象也是不同的。

    虽然有瑕疵,但都是有解决办法滴。

    解决反射调用构造方式时可能会重新生成对象的问题,我们只需要在类的构造方法里添加一个标志位校验就可以解决:

    class Common private constructor(){
        
        companion object {
        	private var flag = false
        }
    
        // 防止反射破坏单例
        init {
            if (!flag) {
                flag = true
            } else {
                throw Throwable("SingleTon is being attacked.")
            }
        }
    }
    

    而反序列化的问题,可以通过在类中声明 readResolve()方法 ,在反序列化返回对象前替换成我们的单例解决。

    fun readResolve(): Any {
        return Common.getInstance()
    }
    

    更多解决单例模式瑕疵问题的知识,这里就不展开啦,有兴趣的同学可以自己去网上冲浪一下。

    考虑到我的单例类使用场景,不需要实现序列化接口,因此只需要解决反射调用的问题就行了。

    瑕疵解决了,那么现在就来给我的单例类实现一个静态内部类的单例模式吧~

    静态内部类单例模式,作为一个 Java 老手,用 Java 写我可谓是信手拈来,直接用文档编辑器莽着敲,都不带看的:

    // java 实现静态内部类单例
    class Common {
      private static boolean flag = false;
      
      // 解决反射调用问题
      private Common() {
        if (!flag) {
          flag = true
        } else {
          throw new Throwable("SingleTon is being attachked.")
        }
      }
    	
      public static final Common getInstance() {
    	  return CommonSingleTonHolder.sInstance
      }
    	
      private static final class CommonSingleTonHolder {
    	  private static Common sInstance = new Common();
      }
    }
    

    抬手之间还解决了反射调用的问题~

    为什么说静态内部类的单例模式是线程安全的呢? 这里要简单提一下类的加载机制了

    简单的说,类加载过程包括五个过程:加载、校验、准备、解析、初始化。

    1. 加载:虚拟机通过类的全限定类名获取类的二进制字节流,通过这个字节流代表的静态存储结构转换为方法区中的运行时数据存储结构,并在堆中生成一个class对象,来作为访问这个运行时数据存储结构的入口。
    2. 校验:虚拟机校验类的字节流文件是否符合虚拟机的规范,是否会对虚拟机的安全造成影响。主要包括文件格式校验,元数据校验,字节码校验,符号引用校验。
    3. 准备:为类中的静态变量分配堆内存,并将其初始化为默认值
    4. 解析:将Class文件中的符号引用转化为指向内存的直接引用。
    5. 初始化:执行类构造器的clinit方法,clinit方法里面包含类的静态变量的赋值操作和静态语句块。

    类的静态变量会在准备阶段分配内存,并被初始化为默认值。在初始化阶段,会执行类的<clinit>()方法,执行静态变量的赋值操作和静态语句块。

    虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步,如果多个线程同时去初始化一个类,那么只会有一个线程去执行这个类的<clinit>()方法,其他线程都需要阻塞等待,直到活动线程执行<clinit>()方法完毕。因此说静态内部类的单例在多线程访问时也是线程安全的。

    静态内部类单例模式也是一种懒汉模式,只有在执行 Common.getInstance()时才会去加载 CommonSingleTonHolder 类,为 sInstance 静态属性初始化。

    Kotlin 实现静态内部类单例模式

    前文介绍了这么多都是有关于 Java 的实现方式,用 Kotlin 怎么实现呢?

    本着伸手就有,决不自己动手的原则,网上搜索一下,有能直接拿来用的,直接 copy copy~

    1_kotlin_search.png

    现网上传的 Kotlin 静态内部类单例模式
    // google 第一页搜索内容,截止到 2022 年 1 月 14 日
    class SingletonDemo private constructor() {
        companion object {
            val instance = SingletonHolder.holder
        }
     
        private object SingletonHolder {
            val holder = SingletonDemo()
        }
    }
    

    搜索完点击第一条,返回了上面的搜索结果。

    喔,看着挺简单的,看看有没其他实现,陆续点击第二条第三条搜索内容,发现一整页的静态内部类单例都是返回这样的结果。

    大家都一样,得,就你了。ctrl + c,ctrl + v,改个类名,nice,搞定。

    class Common private constructor(){
    
        // 防止反射破坏单例
        init {
            if (!flag) {
                flag = true
            } else {
                throw Throwable("SingleTon is being attacked.")
            }
        }
    
        companion object {
        	private var flag = false
        	// 单例
    		val instance = CommonSingletonHolder.holder
        }
    
        /**
         * 静态内部类单例
         */
        private object CommonSingletonHolder {
            val holder = Common()
        }
    
    }
    

    通过 Common.instance就可以访问我们的单例了。完美完美,对比一下 Kotlin 与 Java 的实现方式,非常像!

    把上面的 Kotlin 代码反编译成 Java,再看,我却觉得有些不对劲。

    为了让 Kotlin 反编译生成的代码与 Java 原生的调用方式尽量相同,反编译前,我给 instance 属性加了 @JvmField 注解。

    companion object {
        @JvmField
        val instance = CommonSingletonHolder.holder
    }
    

    然后再反编译成 Java 代码,省去与分析无关的代码后:

    public final class Common {
       @JvmField
       @NotNull
     	// 单例
       public static final Common instance;
    
       private Common() {}
    
     	// 单例的赋值
       static {
          instance = Common.CommonSingletonHolder.INSTANCE.getHolder();
       }
    
       // $FF: synthetic method
       public Common(DefaultConstructorMarker $constructor_marker) {
          this();
       }
    
       private static final class CommonSingletonHolder {
          @NotNull
          private static final Common holder;
          @NotNull
          public static final Common.CommonSingletonHolder INSTANCE;
    
          @NotNull
          public final Common getHolder() {
             return holder;
          }
    
          static {
             Common.CommonSingletonHolder var0 = new Common.CommonSingletonHolder();
             INSTANCE = var0;
             holder = new Common((DefaultConstructorMarker)null);
          }
       }
    
       ...
    }
    

    好像不太对喔!仔细看单例的赋值那一块代码,它是在 static 静态代码块里进行初始赋值的喔。

    前文说了,静态内部类本质上也是一种懒汉单例模式,如果 instance 在 静态代码块被初始化,那么 instance 就会在 Common 类加载的过程中就完成初始化,那本质上,它不就变成一种饿汉单例模式了吗?

    写个 test case 验证一下 instance 是在什么时候初始化的:

    class Common private constructor(){
    
        init {
            JLog.d("Common", "init Common.")
        }
    
        companion object {
        	private var flag = false
        	
            @JvmField
            val instance = CommonSingletonHolder.holder
    
            fun test() {
                JLog.d("Common", "Common test called.")
            }
        }
    
        /**
         * 静态内部类单例
         */
        private object CommonSingletonHolder {
            val holder = Common()
        }
    
    }
    
    // 执行 test() 方法
    Common.test()
    

    调用 Common.test() 跑跑看,如果是懒汉模式,那么只要Common没有执行到 CommonSingletonHolder.holder 就不会触发 CommonSingletonHolder 类的加载,更不会走到 val holder = Common() 完成 instance 的初始化。

    2022-01-14 14:29:11.330 3500-3500/com.jamgu.common D/Common: init Common.
    2022-01-14 14:29:11.330 3500-3500/com.jamgu.common D/Common: Common test called.
    

    Bingo!日志首先打印了 init Common. Instance 在 Common 类加载的时候就被初始化了!,我们实现的居然是一种静态内部类的饿汉模式

    啊这,饿汉模式和静态内部类模式都沾点的单例模式,应该叫什么模式??饿静式?听着好像也还说得过去。。

    哈哈,开个玩笑,言归正传回来,我们实现的代码既不是静态内部类模式,也不是饿汉模式,那应该怎么修改让它符合一个正宗的静态内部类模式呢?

    Easy,类的静态属性和静态代码块,会在类加载的初始化阶段赋值和执行,但类的静态方法不会呀,把单例作为静态方法的返回值就可以完美地让单例懒加载了。

    companion object {
        @JvmStatic
      	// 修改此处
        fun getInstance() = CommonSingletonHolder.holder
    
        fun test() {
            JLog.d("Common", "Common test called.")
        }
    }
    

    再执行 Common.test(),看看结果:

    2022-01-14 14:46:34.914 3862-3862/com.jamgu.common D/Common: Common test called.
    

    没有执行单例的初始化,搞定~

    Kotlin 静态内部类单例模式的正确实现方式

    最后,一个用 Kotlin 实现的,安全的静态内部类单例模式就崭新出炉了。

    class Common private constructor(){
    
        // 防止反射破坏单例
        init {
            if (!flag) {
                flag = true
            } else {
                throw Throwable("SingleTon is being attacked.")
            }
        }
    
        companion object {
        	private var flag = false
        	
            @JvmStatic
            fun getInstance() = CommonSingletonHolder.holder
        }
    
        /**
         * 静态内部类单例
         */
        private object CommonSingletonHolder {
            val holder = Common()
        }
    
    }
    

    现网上传的静态内部类版本不准确噢,仅需要做一些修改,就可以实现真正的静态内部类单例模式了~

    @JvmField
    val instance = CommonSingletonHolder.holder
    // 改成 ----->>>>>
    @JvmStatic
    fun getInstance() = CommonSingletonHolder.holder
    

    兄dei,如果觉得我写的还不错,麻烦帮个忙呗 😃

    1. 给俺点个赞被,激励激励我,同时也能让这篇文章让更多人看见,(#.#)
    2. 不用点收藏,诶别点啊,你怎么点了?这多不好意思!
    3. 噢!还有,我维护了一个路由库。。没别的意思,就是提一下,我维护了一个路由库 =.= !!

    拜托拜托,谢谢各位同学!

    展开全文
  • 内部类与静态内部类区别及举例

    千次阅读 2021-07-02 17:04:26
    静态内部类相对与外部类是独立存在的,在静态内部类中无法直接访问外部类中的变量、方法。如果要访问的话,必须要new一个外部类的对象,使用new出来的对象来访问。 但是可以直接访问静态变量,调用静态的方法。 ...
  • 内部类及静态内部类的实例化

    千次阅读 2021-03-10 01:12:29
    内部类的实例化如果内部类未声明为static,在实例化时首先需要new一个外部类的对象。并通过p.new Inner()的方式new 内部类,表明这个内部类指向该外部类。内部类的class类型为:Parent.Inner,而不是p.Inner,这个...
  • 内部类和静态内部类的调用方式

    千次阅读 2020-08-20 16:56:37
    一、静态内部类的创建需要依赖外部类 Out.Ind j=new Out.Ind(); 二、非静态内部类 Outside in=new Outside(); //在通过外部类对象创建一个内部类对象 Outside.Indoor oi =in.newIndoor();
  • java普通内部类和静态内部类的区别
  • 静态内部类和非静态内部类的区别

    千次阅读 2020-07-20 10:55:18
    静态内部类和非静态内部类的区别: 1. 静态内部类不持有外部类的引用 在普通内部类中,可以直接访问外部类的属性、方法,即使是private类型也可以,这是因为普通内部类持有外部类的引用,可以自由访问。而静态内部类...
  • Java之静态内部类(static class)

    千次阅读 2021-02-13 00:55:51
    一、静态内部类的使用目的。在定义内部类的时候,在其前面加上一个权限修饰符static。这个内部类就变为了静态内部类。如在进行代码程序测试的时候,如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序...
  • 前言 在项目开发过程中,我们需要用实体接收传递过来的参数,若前端传来的Json结构比较复杂,我们就需要用相对复杂的实体接收参数,即一个DTO引用另一...本文的重头戏,静态内部类粉墨登场了。 拾遗-什么是内部类 ...
  • Java 静态内部类 的详细解释

    千次阅读 2021-03-11 02:30:47
    01:静态内部类 的成员可以是 静态的数据域 和 静态的方法 ,因为这个类是静态的, 在加载的时候一并被加载进去如下图: //解释: 这个Outer在被虚拟机加载的时候, name被初始化, 因为StaticInner 依然是一个静态的...
  • 深入理解单例模式:静态内部类单例原理

    万次阅读 多人点赞 2018-05-26 02:00:54
    本文主要介绍java的单例模式,以及详细剖析静态内部类之所以能够实现单例的原理。OK,废话不多说,进入正文。 首先我们要先了解下单例的四大原则: 1.构造私有。 2.以静态方法或者枚举返回实例。 3.确保实例只有...
  • public class InnerClassTest { int a = 1; static int b = 2; private int c = 3;... //非静态内部类 class Inner1{ void test(){ System.out.println(a); //外部类属性 System.out.println(b); //外部.
  • 静态内部类和内部类的关系 只有内部类才能被声明为静态类,即静态内部类; 只能在内部类中定义静态类; 静态内部类与外层类绑定,即使没有创建外层类的对象,它一样存在; 静态类的方法可以是静态的方法也可以是非...
  • 问题:内部类、静态内部类区别、使用场景? 1.静态内部类可以有静态成员(方法,属性),而非静态内部类则不能有静态成员(方法,属性)。 2.静态内部类只能够访问外部类的静态成员,而非静态内部类则可以访问外部类的...
  • 首先我们看下RecyclerView的ViewHolder的写法,java和kotlin分别用静态内部类进行实现,代码是随意找的: java静态内部类: static class EndViewHolder extends BlocksView.ViewHolder { public ...
  • android的内部类和静态内部类的区别

    千次阅读 2018-10-17 10:53:19
    1.static静态修饰符 在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的。  static修饰表示静态的,在类加载时JVM会把它放到方法区,被本类以及本类中所有实例所公用。...2.内部类 定义在一个类内...
  • java中静态内部类的加载时机?

    千次阅读 2021-02-27 11:31:20
    1.问题: 静态内部类的加载时机?他和外部类的加载有没有什么关系?...①一个类内部有静态内部类和非静态内部类静态内部类和非静态内部类一样,都是在被调用时才会被加载 不过在加载静态内部类的过程中.
  • Java静态内部类和非静态内部类

    千次阅读 2019-01-08 17:35:53
    一、非静态内部类: 1、变量和方法不能声明为静态的。(类的编译顺序:外部类–静态方法或属性–内部类,如果内部类声明为静态的,造成编译顺序冲突。个人理解) 2、实例化的时候需要依附在外部类上面。比如:B是A的非...
  • java 静态内部类的使用

    万次阅读 2018-11-05 19:06:39
    java 静态内部类的使用
  • (1)静态内部类只能访问外部类的静态方法,静态属性,静态方法,如图,当静态内部类试图访问非静态变量和非静态方法时编译器报错了: (2)而普通的内部类可以访问外部类的任何属性和方法(静态、非静态、私有、...
  • &nbsp;&nbsp;&nbsp;&nbsp;如果一个类中定义了静态成员变量和静态方法,那么静态方法可以访问...静态内部类和非静态内部类同静态方法和非静态方法类似。 为什么要使用内部类 &nbsp;&n...
  • java静态内部类的作用

    2021-05-17 14:17:41
    需要了解2个概念:内部类和静态修饰符static ...这样静态内部类就可以理解了,因为这个类没有必要单独存放一个文件,它一般来说只被所在外部类使用。并且它可以直接被用 外部类名+内部类名 获得。 以下举例说明怎

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 880,954
精华内容 352,381
关键字:

静态内部类

友情链接: en.stsw-link008.zip