精华内容
下载资源
问答
  • 内部静态类

    2014-11-02 15:40:19
    这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。由于静态内部类在定义、使用的时候会有种种的限制。所以在实际工作中用到的并不多。   在开发过程中,内部类中使用的最多的还是非静态地...
    在一个类中创建另外一个类,叫做成员内部类。这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。由于静态的内部类在定义、使用的时候会有种种的限制。所以在实际工作中用到的并不多。 
      在开发过程中,内部类中使用的最多的还是非静态地成员内部类。不过在特定的情况下,静态内部类也能够发挥其独特的作用。 
     
      一、静态内部类的使用目的。 
     
      在定义内部类的时候,可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。不过由于种种的原因,如使用上的限制等等因素(具体的使用限制,笔者在下面的内容中会详细阐述),在实际工作中用的并不是很多。但是并不是说其没有价值。在某些特殊的情况下,少了这个静态内部类还真是不行。如在进行代码程序测试的时候,如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口,必须具有),那么会出现很多额外的代码。而且最主要的时这段主程序的代码对于Java文件来说,只是一个形式,其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下,就可以将主方法写入到静态内部类中,从而不用为每个Java源文件都设置一个类似的主方法。这对于代码测试是非常有用的。在一些中大型的应用程序开发中,则是一个常用的技术手段。为此,这个静态内部类虽然不怎么常用,但是程序开发人员还必须要掌握它。也许在某个关键的时刻,其还可以发挥巨大的作用也说不定。 
     
      二、静态内部类的使用限制。 
     
      将某个内部类定义为静态类,跟将其他类定义为静态类的方法基本相同,引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说,主要有如下几个地方要引起各位程序开发人员的注意。 
     
      一是静态成员(包括静态变量与静态成员)的定义。一般情况下,如果一个内部类不是被定义成静态内部类,那么在定义成员变量或者成员方法的时候,是不能够被定义成静态成员变量与静态成员方法的。也就是说,在非静态内部类中不可以声明静态成员。如现在在一个student类中定义了一个内部类age,如果没有将这个类利用static关键字修饰,即没有定义为静态类,那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。在编译的时候就通不过。故程序开发人员需要注意,只有将某个内部类修饰为静态类,然后才能够在这个类中定义静态的成员变量与成员方法。这是静态内部类都有的一个特性。也正是因为这个原因,有时候少了这个静态的内部类,很多工作就无法完成。或者说要绕一个大圈才能够实现某个用户的需求。这也是静态的内部类之所以要存在的一个重要原因。 
     
      二是在成员的引用上,有比较大的限制。一般的非静态内部类,可以随意的访问外部类中的成员变量与成员方法。即使这些成员方法被修饰为private(私有的成员变量或者方法),其非静态内部类都可以随意的访问。则是非静态内部类的特权。因为在其他类中是无法访问被定义为私有的成员变量或则方法。但是如果一个内部类被定义为静态的,那么在银用外部类的成员方法或则成员变量的时候,就会有诸多的限制。如不能够从静态内部类的对象中访问外部类的非静态成员(包括成员变量与成员方法)。这是什么意思呢?如果在外部类中定义了两个变量,一个是非静态的变量,一个是静态的变量。那么在静态内部类中,无论在成员方法内部还是在其他地方,都只能够引用外部类中的静态的变量,而不能够访问非静态的变量。在静态内部类中,可以定义静态的方法(也只有在静态的内部类中可以定义静态的方法),在静态方法中引用外部类的成员。但是无论在内部类的什么地方引用,有一个共同点,即都只能够引用外部类中的静态成员方法或者成员变量。对于那些非静态的成员变量与成员方法,在静态内部类中是无法访问的。这就是静态内部类的最大使用限制。在普通的非静态内部类中是没有这个限制的。也正是这个原因,决定了静态内部类只应用在一些特定的场合。其应用范围远远没有像非静态的内部类那样广泛。 
     
     三是在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。 
     
          通常情况下,在一个类中创建成员内部类的时候,有一个强制性的规定,即内部类的实例一定要绑定在外部类的实例中。也就是说,在创建内部类之前要先在外部类中要利用new关键字来创建这个内部类的对象。如此的话如果从外部类中初始化一个内部类对象,那么内部类对象就会绑定在外部类对象上。也就是说,普通非静态内部类的对象是依附在外部类对象之中的。但是,如果成员开发人员创建的时静态内部类,那么这就又另当别论了。通常情况下,程序员在定义静态内部类的时候,是不需要定义绑定在外部类的实例上的。也就是说,要在一个外部类中定义一个静态的内部类,不需要利用关键字new来创建内部类的实例。即在创建静态类内部对象时,不需要其外部类的对象。具体为什么会这样,一般程序开发人员不需要了解这么深入,只需要记住有这个规则即可。在定义静态内部类的时候,千万不要犯画蛇添足的错误。 
     
      从以上的分析中可以看出,静态内部类与非静态的内部类还是有很大的不同的。一般程序开发人员可以这么理解,非静态的内部类对象隐式地在外部类中保存了一个引用,指向创建它的外部类对象。不管这么理解,程序开发人员都需要牢记静态内部类与非静态内部类的差异。如是否可以创建静态的成员方法与成员变量(静态内部类可以创建静态的成员而非静态的内部类不可以)、对于访问外部类的成员的限制(静态内部类只可以访问外部类中的静态成员变量与成员方法而非静态的内部类即可以访问静态的也可以访问非静态的外部类成员方法与成员变量)。这两个差异是静态内部类与非静态外部类最大的差异,也是静态内部类之所以存在的原因。了解了这个差异之后,程序开发人员还需要知道,在什么情况下该使用静态内部类。如在程序测试的时候,为了避免在各个Java源文件中书写主方法的代码,可以将主方法写入到静态内部类中,以减少代码的书写量,让代码更加的简洁。 
     
      总之,静态内部类在Java语言中是一个很特殊的类,跟普通的静态类以及非静态的内部类都有很大的差异。作为程序开发人员,必须要知道他们之间的差异,并在实际工作中在合适的地方采用合适的类。不过总的来说,静态内部类的使用频率并不是很高。但是在有一些场合,如果没有这个内部静态类的话,可能会起到事倍功半的反面效果
    展开全文
  • JAVA内部静态类

    2018-08-16 09:41:13
    * @Author: shuyizhi @Date: 2018-08-15 15:04 @Description: 内部静态类 * 1、创建静态内部类方式:Outer.Inner inner = new Outer.Inner();静态内部类不依赖于外部类。 *2、外部类可通过内部类的对象调用内部...
    package stringtest;
    
    /**
     * @Author: shuyizhi @Date: 2018-08-15 15:04 @Description: 内部静态类
     * 1、创建静态内部类方式:Outer.Inner inner = new Outer.Inner();静态内部类不依赖于外部类。
     *2、外部类可通过内部类的对象调用内部类的私有成员变量或方法。
     *3、静态内部类访问外部类的静态成员变量或方法必须是静态的。
     *4、静态内部类中可定义静态的成员变量和方法。
     *5、外部类可以创建静态内部类的实例,即使是私有的;并可通过内部类的实例访问内部类的成员变量和方法,即使是私有的。
     */
    public class StaticInnerClass {
        private static String s1 = "This is s1 in Outer";
        private static String s2 = "This is s2 in Outer";
    
        public void method1() {
            /** 外部类可以通过内部类的对象调用内部类的私有非静态成员变量或方法 */
            System.out.println("内部类的s1: " + new Inner().s1);
            System.out.println("内部类的method2方法: " + new Inner().method2());
    
            /** 外部类通过内部类名称访问私有静态成员变量或方法 */
            System.out.println("内部类的s3: " + Inner.s3);
            System.out.println("内部类的method3方法: " + Inner.method3());
        }
    
        public static String method2() {
            return "This is method2 in Outer";
        }
    
        /** 内部静态类 */
        public static class Inner {
            private String s1 = "This is s1 in Inner";
            private static String s3 = "This is s3 in Inner";
    
            public void method1() {
                /** 静态内部类可以直接访问外部类的私有静态成员变量或方法 */
                System.out.println("外部类的s2: " + s2);
    
                /** 同名变量的访问 */
                System.out.println("外部类的s1: " + StaticInnerClass.s1);
                System.out.println("内部类的s1: " + s1);
    
                /** 同名方法的访问 */
                System.out.println("外部类的method1方法: " + StaticInnerClass.method2());
                System.out.println("内部类的method2方法: " + method2());
            }
    
            private String method2() {
                return "This is method2 in Inner";
            }
    
            private static String method3() {
                return "This is static method3 in Inner";
            }
        }
    }
    

    转载 https://www.cnblogs.com/SQP51312/p/6102620.html

    展开全文
  • (1) 与一般内部类不同,在静态代码中不能够使用this操作,所以在静态内部类中只可以访问外部类的静态变量和静态方法。使用静态内部类的目的和使用内部类相同。如果一个内部类不依赖于其外部类的...因为内部静态类

    (1) 与一般内部类不同,在静态代码中不能够使用this操作,所以在静态内部类中只可以访问外部类的静态变量和静态方法。使用静态内部类的目的和使用内部类相同。如果一个内部类不依赖于其外部类的实例变量,或与实例变量无关,则选择应用静态内部类。

    (2)  因为非静态内部类只能声明非静态成员或方法,而静态内部类则可拥有静态的成员和方法。 但静态内部类中只能引用其外部类的静态成员或变量。因为内部静态类并不与外部类对象关联。    此外,内部类的继承与接口与外部类独立,解决了多继承的问题。


    内部类的作用:

    1、隐藏你不想让别人知道的操作,也即封装性。

    2、一个内部类对象可以访问创建它的外部类对象的内容,甚至包括私有变量!


    内部类的功能在于,每个内部类都能独立的继承一个接口的实现,所以无论外围类是否已经继承了某个(接口的)实现,对于内部类都没有影响。内部类使得多重继承的解决方案变得完整,并且内部类允许继承多个非接口类型(类或抽象类)。通过内部类分别继承一个基类,外部类创建内部类的对象,并使用内部类的方法,变相地实现了多继承。
    java内部类有什么好处?为什么需要内部类?
    1、举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能。

    2、真正的原因是这样的,java中的内部类和接口加在一起,可以解决常被C++程序员抱怨java中存在的一个问题:没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。

    静态内部类和非静态内部类的区别
    1、和非静态内部类相比,区别就在于静态内部类没有了指向外部的引用。
    2、在任何非静态内部类中,都不能有静态数据、静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。


    展开全文
  • 对于普通内部类静态内部类 1.静态内部类相对于外部是独立存在的 2.对于普通内部类是作为外部的一部分存在的。 调用关系如下: //1.普通内部类可以直接调用外部的普通属性,普通内部类的方法也可以直接...
    对于普通内部类和静态内部类
    
    1.静态内部类相对于外部类是独立存在的
    2.对于普通内部类是作为外部类的一部分存在的。
    
    调用关系如下:
    
    //1.普通内部类可以直接调用外部类的普通属性,普通内部类的方法也可以直接调用外部类的属性。
    //2.普通内部类不可以调用外部类的普通方法,普通内部类的方法可以直接调用外部类的方法。
    //3.普通内部类调用其他普通内部通过创建其他内部类对象的方式。
    //4.普通内部类调用其他静态内部通过创建其他内部类对象的方式。
    //5.静态内部类可以直接调用外部类的静态属性,普静态内部类的方法也可以直接调用外部类的静态属性和静态方法。
    //6.静态内部类不可以调用外部类的静态方法,静态内部类不可以调用外部类的普通方法。
    

    代码实现:

    public class InnerOutClass {
        public  int out1=1;//外部类的普通属性
    //    public static int outs=staticout;不能
        public static  int staticout=1;//外部类的静态属性
        //普通类A
        public class A{
            //内部类AA
            int i=out1;//直接调用外部类的普通属性
            InnerOutClass a=new InnerOutClass();
    //        a.D();//不可以调用
            //D();//不可以调用
            B b=new B();//调用其它内部类
    //        b.BB();不能
            public void AA(){
               int aout=out1;
               System.out.println("AA i:"+i);
                System.out.println("AA aout:"+aout);
                System.out.print("AA :");
                D();
            }
    
        }
        //普通类B(其他类)
        public class B{
            public void BB(){
                System.out.println("BB");
            }
    
    
        }
    
        //静态类C
        public static class C{
    //        int ccc=out1;  不能
           public static int cc=staticout;
            InnerOutClass c=new InnerOutClass();
    //         c.D(); 不能
    //        c.F();不能
            F();
           public static void CC(){
               int  s=staticout;
               F();
           }
        }
        //外部类的普通方法D
        public void D(){
            System.out.println("DD");
        }
        //外部类的静态方法F
        public static void F(){
            System.out.println("FF");
        }
    }
    
    展开全文
  • java 内部静态类 浅谈

    2016-11-18 16:23:49
    java 内部静态类(内部成员均为静态)1、静态内部类可以定义静态和非静态成员 2、静态内部类可以直接访问外部静态成员 3、静态内部类不可以访问外部非静态成员 4、外部类可以通过实例化静态内部类 访问内部类成员...
  • java枚举//内部静态类

    2019-05-05 12:03:01
    内部静态类 public class Testconstans { public static final String test="测试"; /** 奖惩记录 */ public static class RewardPunishment { public static final String REWARD = "奖励"; public...
  • Java内部静态类

    2017-05-24 16:38:50
    外部可以访问内部类的所有方法与属性,包括private修饰的。   OutClass.InnerClass obj = outClassInstance.new InnerClass();...//注意是外部本身,静态内部类 (1)非静态内部类能够访问外部...
  • 利用内部静态类实现单例模式 [java] view plain copy public class Singleton  {   private Singleton(){ }     public static Singleton getInstance()   {   ...
  • Java 中的内部静态类

    2010-01-24 19:03:00
    Java 中内部动态类(没有static)关键字和内部静态类的就在于内部动态类不能定义静态变量或是静态方法,如果要在内部类中使用静态成员,必须将类声明为静态类.内部类中的静态方法可以访问外部类的静态方法和本类中的静态...
  • 内部静态类的优点

    千次阅读 2016-05-21 09:59:56
    1.如果内部类不会引用到外部东西的话,强烈建议使用静态内部类,因为这样更节省资源,减少内部类其中的一个指向外部的引用。 2.这个静态内部类,不需要在外部引用,只为当前提供服务。 封装的完整性。 3....
  • ---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流! ---------------------- ...内部类 ...01 中定义的就是内部类 ...04 外部访问内部类需要创建内部类的对象 05 当内部类
  • JAVA内部静态类之间的调用时,需要注意的事项。阅读代码和注释。 package myNextStep; public class OutClassStatic { /** * @param args */ static String school = "Sheffield Hallam ...
  • 关于内部静态类

    2013-03-07 19:53:17
    这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。由于静态内部类在定义、 使用的时候会有种种的限制。所以在实际工作中用到的并不多。  在开发过程中,内部类中使用的最多的还是非静态...
  • JAVA设计模式之单例模式内部静态类 经典示例 三个要点JAVA设计模式之单例模式:内部静态类 单例模式最初的定义出现于《设计模式》(艾迪生维斯理, 1994):“保证一个类仅有一个实例,并提供一个访问它的全局访问点...
  • JAVA 内部静态类--解析静态内部类的使用目的与限制 标签: java程序开发objectstring测试工作 2010-03-23 12:24 13256人阅读 评论(6) 收藏 举报  分类:   编程点滴(34)  ...
  • 剑指Offer Java实现 - 单例模式 饿汉式 懒汉式 双重校验 内部静态类 单例模式 单例模式可以说是Java设计模式中最简单的一个了,它属于创建型模式。单例模式只涉及到一个单一的类,其中心思想就是由该类负责创建...
  • http://java67.blogspot.fi/2012/10/nested-class-java-static-vs-non-static-inner.html 私有内部静态类 不需要外部类的引用 这是跟私有内部类 最本质的区别
  • 如果你不需要内部类对象与其外围对象之间有联系,那你可以将内部类声明为static。这通常称为嵌套(nested class)。想要理解static应用于内部类时的含义,你就必须记住,普通的内部类对象隐含地保存了一个引用,...
  • ...// supports 7-bit chars....//.......//.......不过由于种种的原因,如使用上的限制等 等因素(具体的使用限制,...但是在有一些场合,如果没有这个内部静态类的话,可能 会起到事倍功半的反面效果。  
  • Enum和内部静态类在Spring中的配置

    千次阅读 2011-05-11 10:46:00
    项目中需要在spirng配置文件中配置Enum和内部静态类。记录一下,备忘。 <bean id="executor" class="java.util.concurrent.ThreadPoolExecutor"> ${core_pool.size}"/> ${max_pool.size}"/> ...
  • 昨日看《Effective Java》第二条:遇到多个构造器参数时要考虑用构造器。其中,演示通过Builder模式,构建复杂的对象。因为之前对java不是很了解的原因...之前,在.net中的静态类一直都是不能实例化的。查了下资料,果
  • 内部类一直比较神秘,尤其是加上private、static修饰符以后,更加使人迷惑。但是看很多JDK源码里面都采用了此种设计。比如:ReferenceQueue中的lock、LinkedHashMap中的Entry。感兴趣的同学可以看一下这部份源码。 ...
  • 为什么能访问到内部静态类的私有属性呢?不是私有属性对外部类不可见的吗? 评论 ( 0 ) • 分享 • 链接 • 2012-11-30   5个答案 票 数 ...
  • 它引入了一个内部静态类(static class),内部静态类只有在调用时才会加载,它保证了Singleton 实例的延迟初始化,又保证了实例的唯一性。是一种提前初始化和延迟初始化的综合模式,也就是饿汉式和饱汉式的结合体。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,924
精华内容 9,969
关键字:

内部静态类