为什么“非静态的内部类中的成员不能定义成静态的”? [问题点数:100分,结帖人xiaozhimin1978]

Bbs2
本版专家分:200
结帖率 100%
Bbs9
本版专家分:51665
Blank
蓝花 2010年5月 Java大版内专家分月排行榜第三
Bbs6
本版专家分:9184
Bbs6
本版专家分:6845
Blank
黄花 2006年5月 Java大版内专家分月排行榜第二
Bbs7
本版专家分:21703
Blank
蓝花 2003年10月 Java大版内专家分月排行榜第三
Bbs6
本版专家分:6285
Bbs2
本版专家分:200
Bbs9
本版专家分:51665
Blank
蓝花 2010年5月 Java大版内专家分月排行榜第三
Bbs2
本版专家分:200
Bbs7
本版专家分:18243
Blank
黄花 2007年1月 Java大版内专家分月排行榜第二
Blank
蓝花 2007年4月 Java大版内专家分月排行榜第三
Bbs9
本版专家分:51665
Blank
蓝花 2010年5月 Java大版内专家分月排行榜第三
Bbs9
本版专家分:51665
Blank
蓝花 2010年5月 Java大版内专家分月排行榜第三
Bbs2
本版专家分:200
Bbs9
本版专家分:51665
Blank
蓝花 2010年5月 Java大版内专家分月排行榜第三
Bbs5
本版专家分:2868
Bbs2
本版专家分:200
Bbs9
本版专家分:51665
Blank
蓝花 2010年5月 Java大版内专家分月排行榜第三
Bbs4
本版专家分:1003
Bbs2
本版专家分:200
Bbs9
本版专家分:51665
Blank
蓝花 2010年5月 Java大版内专家分月排行榜第三
Bbs2
本版专家分:200
为什么内部类中有static成员内部类也必须声明为static
如果A和B类关系紧密,且A类的主要作用是帮助完成B类的实现,这时可将A类作为B类的<em>内部类</em>,两个类可以互相访问各自的私有<em>成员</em>,这样就方便B类的设计,使B类更加自给自足(self contained)。这是我理解的<em>内部类</em>产生的原因,有点类似于C++中的友元类。         A类作为B类的<em>内部类</em>,便是B类的一份子,地位上和B类的属性和方法相当,此时A类便有static和非static之分了,这就是
在main()方法中不能创建非静态内部类的实例
public class A { public static void main() { B b = new B(); } class B { } }
Java接口类只能声明静态属性
Java的接口在声明属性时会发现一个很奇怪的现象, 可能大家在很多地方都会看到这样的描述: 接口类中的只能有<em>静态的</em>属性, 但是在实际写代码中你会发现, 可以在接口中声明一个不是<em>静态的</em>属性, 并且不会报错, 如下: TestInterface.java  package top.itart; public interface TestInterface { public String
为什么静态方法不能调用非静态的变量和方法
你想一下嘛  因为静态是随着累的加载而加载的  也就是说类只要存在了,那么静态就存在了,而静态是优先于对象存在的  ,你要访问非<em>静态的</em>东西,也就是非<em>静态的</em><em>成员</em>(包括变量和方法),非<em>静态的</em>东西还没存在你怎么访问的到吗??楼主好好想一下就能明白了 下面那个是我学习时的笔记 你看一下吧  /* 静态:static 用法:是一个修饰符;用于修饰<em>成员</em>(<em>成员</em>变量和<em>成员</em>函数) 当<em>成员</em>被静态修饰后,就多了一种...
java静态方法不能调用非静态方法的原因
静态方法是属于类的,即静态方法是随着类的加载而加载的,在加载类时,程序就会为静态方法分配内存,而非静态方法是属于对象的,对象是在类加载之后创建的,也就是说静态方法先于对象存在,当你创建一个对象时,程序为其在堆中分配内存,一般是通过this指针来指向该对象。静态方法不依赖于对象的调用,它是通过‘类名.静态方法名’这样的方式来调用的。而对于非静态方法,在对象创建的时候程序才会为其分配内存,然后通过类的
静态成员变量和非静态成员变量的5个主要区别
1、从保存位置: a) 静态<em>成员</em>变量: 方法区的静态区域 b) 非静态<em>成员</em>变量: 堆内存中的对象空间里面 2、从书写格式上看: a) 静态<em>成员</em>变量: 在数据类型前面多了一个static修饰 b) 非静态<em>成员</em>变量: 没有static修饰 3、从生命周期上看: a) 静态<em>成员</em>变量:  在类加载的时候,类加载完成,就分配完空间;直到类被卸载时空间被回收 b) 非静态<em>成员</em>变量: 创建对象的...
为什么接口中只能定义静态常量引发的接口与抽象类的区别的问答
1、<em>为什么</em>必须是<em>静态的</em>:由于接口<em>不能</em>实例化,非静态<em>成员</em>只能使通过实例调用,所以必须<em>定义</em>为static<em>静态的</em> 2、<em>为什么</em>抽象类也<em>不能</em>被实例化,但抽象类里面可以<em>定义</em>非<em>静态的</em>: 由于子类与抽象类的关系中,子类继承(extends)抽象类, java中,子类继承父类,子类实例化,首先要执行父类的构造器,所以抽象类里面有构造器,有构造器就有实例化, 只是这种实例化是比较特殊的实例化,并<em>不能</em>获
Android 非静态内部类导致的内存泄露(非static内部类
从.class文件分析非静态<em>内部类</em>和静态<em>内部类</em>的区别 我们看一个例子就明白了. public class OuterClass { public class NormallInnerClass { public void call() { fun(); } } public static class Static
Java中静态跟非静态的区别总结
静态变量跟实例变量的区别,静态方法跟实例方法的区别
Java static内部类疑惑
转自:用static关键字修饰类  Java里面static一般用来修饰<em>成员</em>变量或函数。但有一种特殊用法是用static修饰<em>内部类</em>,普通类是不允许声明为<em>静态的</em>,只有<em>内部类</em>才可以。被static修饰的<em>内部类</em>可以直接作为一个普通类来使用,而不需实例一个外部类(见如下代码) 主要是比较 静态<em>内部类</em> 和 非静态<em>内部类</em> 的区别 代码走起   Java代码  
怎么想静态内部类可以有静态成员和方法而成员内部类不行?
因为:(没有理论依据,纯粹是为了寻找一个思想依据) 1、<em>成员</em><em>内部类</em>:在没有产生外部类对象的情况下,<em>内部类</em>是不可能被访问到的,即(外部类类名).(<em>内部类</em>类名)是不可能的,只能通过外部类的对象名来访问!既然是属于外部类对象的,那<em>内部类</em>属性就<em>不能</em>提前部署在内存中啦,所以就<em>不能</em>有<em>静态的</em><em>成员</em>和方法啦! {即:<em>成员</em><em>内部类</em>的对象是依附于外部类的对象而存在的,要创建<em>内部类</em>对象,必须先创建外部类对象,(<em>内部类</em>的
Scala编程 Scala是静态类型的
1 通过类型推断避免了冗余性2 通过模式匹配,组织和编写类型的新的方法获取了灵活性3 静态类型系统的经典优越性    1) 可检验属性    2) 安全的重构    3) 文档,静态类型是被编译器检查过的正确的程序文档...
为什么从静态方法里不能调用非静态的方法和变量
静态方法里<em>不能</em>调用非静态变量
静态和非静态的区别
静态变量和非静态变量的区别,静态方法和非静态方法的区别
个人对静态类和非静态类的理解
静态类和非静态类的主要区别:  主要区别在于静态类<em>不能</em>实例化,静态类编译器能够执行检查确保不是偶然的添加实例<em>成员</em>,静态类中<em>不能</em>创建非<em>静态的</em>方法,即静态方法中只能创建静态方法,但在非静态类中可以调用静态方法。  静态类的主要特性:  1:仅包含静态<em>成员</em>。  2:无法实例化。  3:是密封的。  4:<em>不能</em>包含实例构造函数。  5:非静态类可以包含<em>静态的</em>方法、字段、属性或事件;  6:静态方法和属性<em>不能</em>...
为什么不能静态的方法里调用非静态的方法或变量
程序最终都将在内存中执行,变量只有在内存中占有一席之地时才能被访问。 类的静态<em>成员</em>(变量和方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接去访问;非静态<em>成员</em>(变量和方法)属于类的对象,所以只有在类的对象产生(创建类的实例)时才会分配内存,然后通过类的对象(实例)去访问。 在一个类的静态<em>成员</em>中去访问其非静态<em>成员</em>之所以会出错是因为在类的非静态<em>成员</em>不存在的时候类的静态<em>成员</em>就已经存在了,
ThreadLocal类为什么要加上static修饰
问题的来源是:    在我写一个OpenSessionFilterInView的时候(当然Spring已经有了这个功能),需要在view中这里也就是在Filter中从spring工厂的hibernate sessionFactory中获取一个session,并且需要把session传到DAO当中,那么问题来了,如果ThreadLocal是<em>静态的</em>,那么多线程并发的时候 主存中只有一个ThreadL
静态常量与非静态常量的区别
什么叫常量?一般来说就是不会变的量 静态与非静态: 静态:对于该类的对象来说,都只有一个,叫类变量 非静态:每个该类的对象都各有一个,叫<em>成员</em>变量. 因为是常量,不会变的,所有的对象都是一样的,所以就只需要一个就够了. 工商银行卡类:他们有一个<em>静态的</em>银行卡名称叫:工商银行卡静态 每个卡又月自己的卡号非静态. 在创建对象的时候,需要每个<em>成员</em>变量(非静态)开辟内存空
如何实现自己特定的内存管理,如何正确替换C++中的全局运算符new和delete
如何实现自己特定的内存管理,如何正确替换C++中的全局运算符new和delete
Java中类、方法声明为静态的含义
这个静态类问题从俩个方面很好的就能够理解: 1、<em>静态的</em>特性 静态是不需要建立对象而直接进被虚拟机放入方法区(三大区:栈内存、堆内存、方法区) 2、类如何被使用 类被使用的前提就是有已经被建立的对象 通过上面两点综合去理解 静态类就是当程序一旦被执行,静态类直接被放入方法区,可以直接通过类名进行调用,而不需要建立类的对象。 静态方法使用上来说,主要有3点区别: 1、在外部调用
静态内部类和访问非静态成员变量
静态<em>内部类</em>访问包含它的外部类的非静态<em>成员</em>变量时,可以通过new外部类().<em>成员</em>的方式访问,这是因为<em>静态的</em>只能访问<em>静态的</em>,因为他们在对象没创建前就存在了。如果想访问非<em>静态的</em>则必须初始化该对象,因为只有初始化后对象在内存才存在(<em>静态的</em>除外)...
匿名内部类是否可以由静态的内容
在使用匿名<em>内部类</em>时,要记住以下几个原则:  · 匿名<em>内部类</em><em>不能</em>有构造方法。  (因为匿名<em>内部类</em>是没有类名的)  · 匿名<em>内部类</em><em>不能</em><em>定义</em>任何静态<em>成员</em>、方法和类。 理由:匿名<em>内部类</em>是晚于外部类加载的,但是匿名<em>内部类</em>和其对象几乎是同时加载的,但是还是早于对象加载,而静态内容是属于类的,当类加载的时候就开始加载,所以当匿名<em>内部类</em>中有静态内容,就会随着类加载,而这时和对象创建冲突。
Java中关于抽象方法和静态不能共存
静态和抽象<em>不能</em>共存与方法上,因为静态属于字节码,不需要对象就可以运行,而抽象方法没有方法体,运行没有意义,所以<em>不能</em>共存但是一个抽象类可以有静态方法  抽象类<em>不能</em>实例化但是可以通过类名.方法名()来调用...
java静态成员和非静态成员的区别
static(静态)关键字      static关键字: 用于修饰<em>成员</em>(<em>成员</em>变量和<em>成员</em>函数)     被修饰后的<em>成员</em>具备以下特点: 随着类的加载而加载 优先于对象存在 被所有对象所共享 可以直接被类名调用   使用注意 静态方法只能访问静态<em>成员</em> 静态方法中不可以写this,super关键字 主函数是<em>静态的</em> stati...
为什么静态方法不能直接访问非静态成员
static<em>成员</em>是在JVM的CLASSLOADER加载类的时候初始化的,而非static的<em>成员</em>是在创建对象,即new 操作的时候才初始化的;类加载的时候初始化static的<em>成员</em>,此时static 已经分配内存空间,所以可以访问;非static的<em>成员</em>还没有通过new创建对象而进行初始化,所以必然不可以访问。 简单点说:静态<em>成员</em>属于类,不需要生成对象就存在了.而非静态需要生成对象才产生,所以静态<em>成员</em>
内部类的序列化问题;静态变量不能被序列化的问题
1.父类序列化,则非<em>静态的</em><em>内部类</em>也要序列化,不然会报错。 2.父类序列化,静态<em>内部类</em>不序列化也可以,不会报错,但是数据会丢失。
什么时候要把方法写成静态的。什么时候写成实例化方法。
java里面有两种,一种是静态方法,一种是实例化方法。 静态方法在程序开始时生成内存,实例方法在程序运行中生成内存 所以静态方法可以直接调用,实例方法要先成生实例,通过实例调用方法,静态速度很快,但是多了会占内存。 静态内存是连续的,因为是在程序开始时就生成了,而实例申请的是离散的空间,所以当然没有静态方法快, 而且静态内存是有限制的,太多了程序会启动不了。 静态方法
在java中为什么main方法必须是静态的解释
public class Test { public static void main(String[] args) { //正确的 double i = 50.0; double k = i + 50.0; double j = k+1; System.out.println("j is "+j+"and k is "+k
静态方法中不能new内部类的实例对象
  因为<em>内部类</em>有一个重要特性,就是可以访问外部类的<em>成员</em>变量,既然是这样,那外部类就必须实例化。   但是在静态方法中,是可以不用new外部类的实例对象就可以运行。   所以这就造成了矛盾。   所以在静态方法中<em>不能</em>直接new<em>内部类</em>的实例对象,必须先实例化外部类的实例对象。   要想解决这个问题:   可以在外部类里面新建一个init方法,把new<em>内部类</em>的逻辑移植到init里...
java中静态方法调用非静态成员变量、非静态方法
public class Circle { private double radius = 1.0; double getAre() { return radius * radius * Math.PI; } public static void main(String[] args) { Circle myCircle = new Circle();
c++类的成员函数做回调函数为啥要申明为static的
众所周知,C++的类<em>成员</em>函数<em>不能</em>像普通函数那样用于回调,因为每个<em>成员</em>函数都需要有一个对象实例去调用它。         通常情况下,要实现<em>成员</em>函数作为回调函数,一种常用的方法就是把该<em>成员</em>函数设计为静态<em>成员</em>函数,但这样做有一个缺点,就是会破坏类的结构性,因为静态<em>成员</em>函数只能访问该类的静态<em>成员</em>变量和静态<em>成员</em>函数,<em>不能</em>访问非<em>静态的</em>,要解决这个问题,需要把对象实例的指针或引用做为参数传给它。
错误:非静态的字段、方法或属性“System.Web.UI.Page.Session.get”要求对象引用
 一开始时的语句为:string sql = "select basename from base WHERE baseid =" + Session["UserRights"].ToString() + "";执行时发生错误:非<em>静态的</em>字段、方法或属性“System.Web.UI.Page.Session.get”要求对象引用; 后将语句改为:string sql =
为什么Java工具类方法为静态类
转自:Java静态工具类线程安全的一些建议基础:每个线程都有自己的线程栈,栈与线程同时创建,每一个虚拟机线程都有自己的程序计数器PC,在任何时刻,一个虚拟机线程只会执行一个方法的代码,这个方法称为该线程的当前方法,如果这个方法不是native的,程序计数器就保存虚拟机正在执行的字节码指令的地址。线程调用方法的时候会创建栈帧,用于保存局部变量表和操作数栈以及指向该类常量池的引用 静态方法虽然是同一个
JAVA 构造方法 静态方法
构造方法 作用: 对 对象的属性(<em>成员</em>变量)进行初始化 写法: 1.构造方法的方法名与类名完全相同 2.没有返回值类型(连void都不写) 3.没有返回值注意事项: 1.没写构造方法 系统则会提供一个无参的构造方法 2.写了有参的构造方法 系统不会提供无参的构造方法 所以在 写有参的构造方法时 最好把无参的也写上Car c1 = new Car("奥迪",4);
C#中静态类与非静态类的区别
 静态与非<em>静态的</em>区别 1、用static(静态) 关键字来区分; 在非静态类中既可以有非静态<em>成员</em>(实例<em>成员</em>)也可以有静态<em>成员</em>; 在静态类中只能有静态<em>成员</em>存在; 2、调用实例<em>成员</em>时,必须使用  对象名.实例<em>成员</em>       调用静态<em>成员</em>时,必须使用  类名.静态<em>成员</em> 3、静态函数中只能访问静态<em>成员</em>,不允许访问实例<em>成员</em>;       实例函数中既可以访问静态<em>成员</em>,也可以使用实例<em>成员</em>; 4、静态...
【Java】中静态方法如何访问非静态方法和非静态变量
JAVA中静态方法<em>不能</em>直接访问非静态方法和非静态变量。 如果需要访问,则有两种方式: a.将非<em>静态的</em>方法和变量加static,变成<em>静态的</em>; (但不建议,一是耗内存,二是面向对象可能失去意义) b.通过引用类访问。 如下图:
java中静态方法为什么不能调用非静态方法或者变量
静态方法只能调用静态方法(或者变量),非静态方法可以调用静态方法(或者变量)类的静态<em>成员</em>(变量和方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接去访问(类名.方法|类名.变量);非静态<em>成员</em>(变量和方法)属于类的对象,所以只有在类的对象产生(创建类的实例)时才会分配内存,然后通过类的对象(实例)去访问。在一个类的静态<em>成员</em>中去访问其非静态<em>成员</em>之所以会出错是因为在类的非静态<em>成员</em>不存在的时候类
C#中静态变量与非静态变量的区别
静态变量与非静态变量的区别如下:  1.内存分配  静态变量在应用程序初始化时,就存在于内存当中,直到它所在的类的程序运行结束时才消亡;  而非静态变量需要被实例化后才会分配内存。  2.生存周期  静态变量生存周期为应用程序的存在周期;  非静态变量的存在周期取决于实例化的类的存在周期。  3.调用方式  静态变量只能通过“类.静态变量名”调用,类的实例<em>不能</em>调用;  非静态变量
抽象方法为什么不能静态的
抽象方法是没有方法体的,也就是不具体实现什么,如果是<em>静态的</em>意味着可以直接调用,然而这样是没有什么意义的。
Java---- 静态内部类与非静态内部类的区别
在面试中回答的很不全,所以再此做一个总结。1 static 静态修饰符在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的。 static修饰表示<em>静态的</em>,在类加载时JVM会把它放到方法区,被本类以及本类中所有实例所公用。在编译后所分配的内存会在一直存在,直到程序退出内存才会释放这个空间。如果一个被所有实例公用的方法被申明为static,那么就可以节省空间了,不用每个实例初始化的时候都被分
Java —— static 关键字、static 内部类、枚举类
一、static 关键字 之前虽然知道静态方法只能操作静态变量,但有时写测试小程序时,main 方法中引用<em>成员</em>变量提示须为<em>静态的</em>,有点疑惑(忘了最基础的入口main 方法是<em>静态的</em>...)。在此,简单整理下,让我一次弄个明明白白! 先上结论: 只需记住一点,静态方法或静态类只能操作静态方法或静态<em>成员</em>属性(静态操作静态),其它情况随意! 理解含义: main 方法中能使用的<em>成员</em>属性必须为静态
main方法不能直接调用 非静态方法
public class Test { public static void main(String [] args) { amethod(args); } public void amethod(String [] args){ } }   问题原因:main方法是静态方法,静态方法可以在没有对象实例的时候直接调用,故可以直接调用main方法,但是因为没有对象实例,所以<em>不能</em>调用非静态方法。 <br
C#中被委托的方法必须是静态的吗?
静态方法与实例方法的区别: 静态方法都是通过关键字static来<em>定义</em>的,静态方法不需要实例这个对象就可以通过类名来访问这个对象。在静态方法中<em>不能</em>直接访问类中的非静态<em>成员</em>。而用实例方法则需要通过具体的实例对象来调用,并且可以访问实例对象中的任何<em>成员</em>。 如果用委托绑定实例方法的话需要用实例对象来访问,所以我们在绑定实例方法到委托的时候必须同时让委托得到实例对象的信息,这样才能在委托被回调的时候成功
JAVA中什么时候定义静态 的练习
/*  * 什么时候使用静态?  * 要从两方面下手:  * 因为静态修饰的内容有<em>成员</em>变量和<em>成员</em>函数。  * 什么时候<em>定义</em>静态变量(类变量)呢?  * 当对象中出现共享数据时,该数据被静态所修饰。  * 对象中的特有数据要<em>定义</em>成非静态存在于堆内存中  *   *   * 什么时候<em>定义</em>静态函数呢?  * 当功能内部没有访问到非静态数据(创建对象的目的是为了封装数据)  * 那么
为啥使用静态的handler对象避免内存泄漏呢?
因为使用static,对象是在ROM中,而不是RAM内存中,自然避免了内存泄漏;new对象是在RAM中
实现接口成员的两种方式有何区别有什么用途
若要实现接口<em>成员</em>,类中的对应<em>成员</em>必须是公共的、非<em>静态的</em>,并且与接口<em>成员</em>具有相同的名称和签名。但是如果使用显示的实现方式,就可不必使用publicz关键字.<em>为什么</em>要提供显示的实现方式呢,他们有什么区别?显式实现接口<em>成员</em>与实现接口<em>成员</em>的区别是方法名字前面有接口名。这样就可不使用public关键字来实现接口<em>成员</em>.这样就导致了在使用上有所区别.使用时的区别是如果只有显式实现,则只能通过接口类型的变量来
c++静态成员函数为什么不能为虚函数?
知乎用户 three passions govern my life 2 人赞同 可以把静态<em>成员</em>函数看作是“命名空间受限的普通函数”,所以它<em>不能</em>有运行时多态 发布于 2015-06-23 添加评论 感谢  分享  收藏 • 没有帮助 • 举报 • 作者保留权利 Elvis Wang C++程序员转型Ja
java静态与非静态的区别
静态是指被static修饰符修饰的,包括类、方法、变量、块等。 静态特点: 1.一声明就被储存在栈中,直接占据内存,可以快速稳定的调用; 2.生命周期长,从JVM加载开始到JVM卸载结束; 3.全局唯一:在一个运行环境中,静态变量只有一个值,任何一次修改都是全局性影响; 4.占据内存,程序中应包含尽量少的static; 非静态是指没被static修饰的。 特点: 1.new的时候占
【已解决】VS错误 CS0120 对象引用对于非静态的字段、方法或属性“AgvWareHouseLib.Offline(string, string)”是必需的
引用类库是发现错误: 严重性    代码    说明    项目    文件    行    禁止显示状态 错误    CS0120    对象引用对于非<em>静态的</em>字段、方法或属性“AgvWareHouseLib.Offline(string, string)”是必需的    AgvWareHouse    F:\test\AgvWareHouse\AgvWareHouse\OffProduc
线程池踩坑 - 作为实例成员或方法局部变量的误区
本文目录: 1. 概述 2. 验证 3. 剖析 4. 小结 1. 概述 线程池可以把线程复用起来,减少线程创建销毁的时间和资源消耗,提高了程序任务执行的吞吐率。 就像线程属于全局使用的资源一样,线程池一般也是全局性,对整个应用进程的线程复用做有效的管理。设计者一般都会把线程池作为类的静态<em>成员</em>或者单例<em>成员</em>,存活于整个进程的生命周期。 但是还是例外地看到了类似这样的代码。 ...
静态方法里的变量都是静态的吗?
静态方法里面的变量都是<em>静态的</em>,这样的说法并不正确,只能说静态方法只能引用静态<em>成员</em>变量,它的内部可以<em>定义</em>非<em>静态的</em>变量  
为何Android使用非静态内部类容易造成的泄漏!
前言先看完下面这些也许答案才能明白:静态变量与静态方法:数据存放的位置与普通变量方法不同;存放在data segment(数据段)指的是你程序运行之前就已经存进去数据了; 普通变量与普通方法:存放堆栈与方法区内,程序运行后才生成;所以时间都不平衡的两类数据是<em>不能</em>已经要存的调用未来的数据(静态调用非静态);理解这个时间顺序一系列问题也就可以解决了;再理解静态<em>内部类</em>与非静态<em>内部类</em>(咱不背规则咱要弄懂实
C#静态与非静态比较
静态和非<em>静态的</em>不同的地方,就是<em>静态的</em>从程序一启动就会一直占用内存,而非<em>静态的</em>只在使用后(实例化)后才会占用内存.但是每实例化个一个对象时又会另外占用内存. 举个例子,比如说一个数据库的连接字段(STRING).因为要经常使用到它,这时我们可以用STATIC.但是如果这时用非<em>静态的</em>话那就不合算了,因为每次调用到它时,又实例化一次.这样相比来说占用内存就比较大了.不划算. 像一个登录后台的方法,你
内存泄漏—出现情况,非静态内部类对外部类引用持有的泄漏复现
前言 本文为制造一个”非静态<em>内部类</em>对外部类的引用持有”泄漏并对其结果进行观察作为学习使用,手段是制造泄漏,目的是了解泄漏产生的原因并未解决提供一种思路。 本文只是对泄漏测试代码的一个讲解,并没有涉及到泄漏排查工具的使用,结合工具使用我会另开一片文章,链接我一会儿附上。 Code 俩个Activity,一个SplashActivity,一个LeakActivity。操作路径是从Spla...
android的内部类和静态内部类的区别
1.static静态修饰符 在程序中任何变量或者代码都是在编译时由系统自动分配内存来存储的。  static修饰表示<em>静态的</em>,在类加载时JVM会把它放到方法区,被本类以及本类中所有实例所公用。在编译后所分配的内存会在一直存在,直到程序退出内存才会释放这个空间。如果一个被所有实例公用的方法被申明为static,那么就可以节省空间了,不用每个实例初始化的时候都被分配到内存。2.<em>内部类</em> <em>定义</em>在一个类内...
为什么静态方法中不可以直接访问非静态方法
静态方法是属于类的,即静态方法是随着类的加载而加载的,在加载类时,程序就会为静态方法分配内存非静态方法是属于对象的,对象是在类加载之后创建的静态方法先于对象存在,当你创建一个对象时,程序为其在堆中分配内存,一般是通过this指针来指向该对象。静态方法不依赖于对象的调用,它是通过‘类名.静态方法名’这样的方式来调用的。而对于非静态方法,在对象创建的时候程序才会为其分配内存,然后通过类的对象去访问非静...
【面向对象】--静态类与非静态类的区别
静态类            静态类和非静态类重要的区别是在于静态类<em>不能</em>被实例化,也就是说<em>不能</em>使用  new 关键字创建静态类类型的变量。使用static关键字来声明静态类,这样的意义在于:首先,它防止程序员写代码来实例化该静态类;其次,它防止在类的内部声明任何实例字段或方法。  静态类的使用 关键字:  static 调用方式: 注意:   1.在静态类中只能访问静态<em>成员</em>;
C#中Main()函数为什么必须是静态的
假设没有static关键字,那意味着需要用生成一个实例后才可以调用这个Main方法,而Main方法是程序入口点,你没有进入Main方法,自然无法生成一个实例,既然没有实例,那就无法调用Main函数,岂不矛盾?所以Main函数被设置为static.  Main()函数在C#里非常特殊,它是编译器规定的所有可执行程序的入口点。由于其特殊性,对Main()函数我们有以下几条准则:  Main()函数必须...
Java中Static Class及静态内部类和非静态内部类与静态导包
上次有朋友问我,java中的类可以是static吗?我给他肯定的回答是可以的,在java中我们可以有静态实例变量、静态方法、静态块。当然类也可以是<em>静态的</em>,下面小编整理了些关于java中的static class相关资料分享在脚本之家平台供大家参考 java中的类可以是static吗?答案是可以。在java中我们可以有静态实例变量、静态方法、静态块。类也可以是<em>静态的</em>。 java允许我
C# 对象对于引用非静态字段、方法或属性是必需的
近期回顾三层架构知识,遇到了该问题,但是不想使用static静态方法解决问题。所以查阅了另外一种解决方法。 有图有真相。   “static都是在类初始化的时候加载的,而非<em>静态的</em>变量都是在对象初始化的时候加载。” 话是我偷的,真心是送给你的。 参考网址:https://blog.csdn.net/qq719365064/article/details/52925176...
关于Java内部类字段和方法不能使用static修饰的原因
昨天的文章中,遗留了一个问题就是,<em>为什么</em>Java<em>内部类</em>字段和方法<em>不能</em>使用static修饰。先下下面一段代码:class OuterClass { public int age=20; class InnerClass { static int i = 100; // compile error static void f() { } // compile error } } ...
.net 非静态的字段、方法或属性 要求对象引用
vs中如果出现错误提示“非<em>静态的</em>字段、方法或属性要求对象引用”时说明该类的中方法没有static  不是<em>静态的</em>.有非<em>静态的</em>字段、方法或属性,要求该类必须实例化。1.实例化类为对象:classT sl=new classT();2.非<em>静态的</em>方法或属性可以通过对象的属性来引用: sl.ff(); 静态方法中<em>不能</em>访问非静态<em>成员</em>在static  <em>静态的</em>方法函数中引用非<em>静态的</em>方法导致   <em>静态的</em>方法函数中只
接口中的方法不能声明为static
1如果可以<em>定义</em>抽象静态方法static,设 static abstract method(); 是抽象类A的方法 那么因为是静态方法那可以用A.method(); 而这个方法又是抽象的没有方法体,掉用了怎么执行呢?
避免使用非静态内部类,这会导致Context泄露
【转载:http://www.cnblogs.com/kissazi2/p/4121852.html】 思考下面代码 1 public class SampleActivity extends Activity { 2 3 private final Handler mLeakyHandler = new Handler() { 4 @Override 5
构造器是静态方法吗?
在thinking in java中,第96页提到,“即使没有显示地使用static关键字,构造器实际上也是静态方法“,对此我产生了疑惑,于是找相关资料进行确认,在一篇大神的博客中得到了答案,那就是构造器不是静态方法。 主要是以下几点原因: Java虚拟机规范第二版中<em>定义</em>了四种不同的字节码指令来处理Java程序中不同种类的方法的调用: · invokestatic - 用于调用类(静态)方法
C++回调函数必须为静态函数的原因
为了实现回调,我们必须把this指针给转换掉!可为了在该函数中可以直接操作该类中的<em>成员</em>,我们必须保留this指针!所以这是矛盾的。 在类封装回调函数:   a.回调函数只能是全局的或是<em>静态的</em>。   b.全局函数会破坏类的封装性,故不予采用。   c.静态函数只能访问类的静态<em>成员</em>,<em>不能</em>访问类中非静态<em>成员</em> 让静态函数访问类的非静态<em>成员</em>的方法: 在消息回
抽象方法不能是static或native或synchroniz 原因及误解
在网上看到过这么一篇文章,是关于抽象方法<em>不能</em>是static或native或synchroniz 的原因。其中提到了这些关键字的意义以及与 abstract 关键字的冲突,大体内容如下:
静态的字段,方法或属性。。。。。。要求对象引用
遇到C# 报错 “非<em>静态的</em>字段、方法或属性 要求对象引用”,一开始以为要加上ref或者out, 结果试过也不行。百度易一下才发现是这是因为类的静态方法规定的,类中<em>静态的</em>方法、<em>成员</em>函数只能访问<em>静态的</em>数据<em>成员</em>或者<em>静态的</em>方法。 static void Main(string[] args) //这使用了关键字static代表是静态方法,如果Main方法里面要调用外面的方法或者函数必须是<em>静态的</em>方法
简述内部类、静态内部类、匿名内部类的区别
<em>内部类</em>:    <em>成员</em><em>内部类</em>可访问外部类所有的方法和<em>成员</em>变量。    <em>不能</em>有<em>静态的</em>方法和<em>成员</em>变量。静态<em>内部类</em>:    只能访问外部类的静态<em>成员</em>变量与静态方法。    静态<em>内部类</em>的非静态<em>成员</em>可访问外部类的静态变量,而不可访问外部类的非静态变量。匿名<em>内部类</em>:    没有类名,没有class关键字也没有extends和implements等关键字修饰。    类的<em>定义</em>和实例化同时进行。...
Java中静态方法不能引用非静态变量
静态方法和静态变量都是属于类的,不需要初始化对象即可引用,而非静态方法或者变量都是要用类的对象来引用,当我们在一个静态方法,比如Java中的main函数中应用某个非静态变量,就会出现错误。          此时有两种方法解决: (1)将方法或变量<em>定义</em>为<em>静态的</em>; (2)<em>定义</em>一个对象,用此对象去引用相关的方法或者变量。
static方法中,不能访问类内非static成员变量和方法。
因为我们知道<em>静态的</em>方法可以在没有创建实例时使用,而申明为非<em>静态的</em><em>成员</em>变量是一个对象属性,它只有在对象存在时引用,因此如果在对象未创建实例时我们在静态方法中调用了非静态<em>成员</em>方法自然是非法的,所以编译器会在这种时候给各错误.   简单说来,静态方法可以不用创建对象就调用,非静态方法必须有了对象的实例才能调用.因此想在静态方法中引用非静态方法是不可能的,因为它究竟引用的是哪个对象的非静态方法呢
C++中类内成员定义,声明总结(静态和非静态成员
近学习到C++ primer中关于类中静态变量的部分,有一道课后题非常有意思。 题目是关于静态变量在类中的初始化。 首先判断下列代码的正误。 class example{ public: //static double rate=6.5; static const int size; std::vector vec(size); }; 代码是这样的。 当时我一看,觉得没有错误啊。
VS提示“非静态的字段、方法或属性要求对象引用”
VS提示“非<em>静态的</em>字段、方法或属性要求对象引用”时说明该类的中方法没有STATIC不是<em>静态的</em>.有非<em>静态的</em>字段、方法或属性,要求该类必须实例化。即:classA a=new classA();再a.f(); 
静态的字段、方法或属性 要求对象引用
遇到C# 报错 “非<em>静态的</em>字段、方法或属性 要求对象引用”,一开始以为要加上ref或者out, 结果试过也不行。百度易一下才发现是这是因为类的静态方法规定的,类中<em>静态的</em>方法、<em>成员</em>函数只能访问<em>静态的</em>数据<em>成员</em>或者<em>静态的</em>方法。  static void Main(string[] args) //这使用了关键字static代表是静态方法,如果Main方法里面要调用外面的方法或者函数必须是<em>静态的</em>方法或
为什么接口里边的属性是默认为final static 的
Q:<em>为什么</em>接口里边的属性是默认为final static 的? A: static:接口是无法被实例化的,所以接口里边的属性与对象无关,因此属性是<em>静态的</em>; final:   大家的疑惑点是:<em>为什么</em>接口的属性是final的。 有些答案:   类在创建对象的时候会给他开辟一个内存空间,并且初始化类变量和方法,对于类变量,会自动赋初值(例如int 0, Boolean false…)。而...
静态方法中不可直接new内部类实例对象问题
结论:静态方法中,是不可以直接new<em>内部类</em>实例对象和引用外部类的<em>成员</em>变量的。原因:1、外部类中的<em>成员</em>变量、方法以及<em>内部类</em>其实三者都在同一个级别上,三者都必须由外部类的实例对象才能调用(举例:当一个方法被调用时,此时肯定已经有了外部类的实例对象。),故而他们三者可以互相引用。2、而静态main方法因为其方法为静态,在类编译时,便生成了该静态方法,故而其运行不依赖于外部类的实例对象,因为<em>内部类</em>要依赖于...
抽象方法是否可以是静态的,是否可以是native,是否可以是synchronized
1.抽象方法<em>不能</em>是<em>静态的</em>,因为抽象方法要被子类实现,而静态方法属于一个类,<em>不能</em>同时属于两个类。 2.native方法表示该方法要用另外一种依赖平台的语言实现,不存在着被子类实现的问题,所以<em>不能</em>是抽象的,即abstract与native<em>不能</em>共存。 3.synchronized方法的锁对象为this,而抽象方法无法确定this是什么,所以<em>不能</em>共存。
java 内部类为什么不能用静态方法
java <em>内部类</em><em>为什么</em><em>不能</em>用静态方法非static的<em>内部类</em>,在外部类加载的时候,并不会加载它,所以它里面<em>不能</em>有静态变量或者静态方法。 static类型的属性和方法,在类加载的时候就会存在于内存中。 要使用某个类的static属性或者方法,那么这个类必须要加载到jvm中。 基于以上两点,可以看出,如果一个非static的<em>内部类</em>如果具有static的属性或者方法,那么就会出现一种情况:<em>内部类</em>未加载,但
JackSon和内部类,是的,你可以使用,但他们必须是静态的内部类
本文翻译于一片国外文章,原文链接如下:Tatu Saloranta JackSon和<em>内部类</em>,是的,你可以使用,但他们必须是<em>静态的</em><em>内部类</em>。 这是我直到今天没有意识到的东西:这显然是正确使用<em>内部类</em>在Java开发者社区的巨大的困惑。事实上有一些网页显示 JackSon<em>不能</em>使用<em>内部类</em>值。 这实际上是真实的和虚假的,原因就在于Java的<em>内部类</em>的特点。早在Java 1.1的时候就引
关于SpringBoot bean无法注入的问题(与文件包位置有关)
问题场景描述整个项目通过Maven构建,大致结构如下: 核心Spring框架一个module spring-boot-base service和dao一个module server-core 提供系统后台数据管理一个module server-platform-app 给移动端提供rest数据接口一个module server-mobile-api 其中server-platform-app 与
文章热词 非零系数Level值 卷积神经网络结构定义 tensorflow resnet网络定义 支持向量机数据定义 单位定义全局变量
相关热词 c++静态类 成员必须都是静态的吗 c++ 定义内部类 c#取出非公共成员 c#类的非序列化成员 为什么学python 非科班出身python
我们是很有底线的