Java中 public、private、protected 访问权限的区别_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
评价文档：
Java中 public、private、protected 访问权限的区别
上传于||文档简介
&&J​a​v​a​中​ ​p​u​b​l​i​c​、​p​r​i​v​a​t​e​、​p​r​o​t​e​c​t​e​d​ ​访​问​权​限​的​区​别
大小：2.76KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢Java 中，为什么在静态方法中可以调用的方法、可以使用的成员变量必须是静态的？
有这样一段话，“由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。” 怎么深层次理解这句话呢？如果允许调用其他非静态变量，会引起什么后果么？
按投票排序
不仅仅在Java中，在任何面向对象的语言中都是这样一个个回答你的疑问有这样一段话，“由于静态方法可以不通过对象进行调用，因此在静态方法里，不能调用其他非静态变量，也不可以访问非静态变量成员。” 怎么深层次理解这句话呢？深层次的解释是，“静态方法可以不通过对象进行调用”也就是说这个方法在对象尚未创建的时候就可以调用，而此时对象尚未创建，（非静态）成员变量根本都还不存在，何谈访问？如果允许调用其他非静态变量，会引起什么后果么？不是允许不允许的问题，是这个时候非静态成员变量都还不存在（他是伴随着对象的创建而创建的），根本无法访问一点额外补充
我也是Java初学者。前几天在Core Java这本书里面看到的解释是：静态方法实际是类的方法，而不是关于对象的方法。所以不是“可以不通过对象调用方法”，而是恰恰应该使用类来调用，而且鼓励这种写法，而不是通过对象调用。即：静态方法不和对象相关，而是仅仅和类相关。为啥呢？解释是这样的：在一般的类中定义的方法中，非静态类其实不仅仅有他们后面括号里面的显式参数（比如 public int getField(String param1, int param2)这个方法，显式参数是param1和param2），还包括一个隐式参数：即这个调用方法的对象（即this）。而静态方法，则没有这个隐式的参数，仅仅就只有括号中的显式参数。既然是因为静态方法不和对象关联，那么它就只能用同样仅仅和类关联而不和对象关联的实例域，毕竟不是静态的实例域在不同对象中基本上都是不同的嘛。而理解这个道理，最最关键的一点是：java中的“static”和C++中的“static”含义并不完全一样！！！C++中的关键字static被复写了三次，有三种含义，分别为：变量一直存在；不能被其他文件访问的全局变量和函数；属于类且不属于对象的全局变量和函数。在一大部分人心中可能只把它理解为“静态”的意思，实际上Java仅仅取了C++中static的最后一个含义：即，不与类的实例相关联，仅与类相关联。这样一看是不是觉得好理解多了？
public class HelloWorld{
private String name="123";
public static void test(){
System.out.print(name);
}}假如上面正确，仔细思考一下：所有的静态方法可以通过类直接调用的，比如HelloWorld.test()。当这个方法调用的时候，会发生什么？name 从哪儿来？它是一个HelloWorld对象的私有属性，没有HelloWorld的实例，自然也就没有name啊！静态方法和变量定义在类中，本质上只是把类当作＂名空间＂而已，它不是一个这个类对象"特有的＂方法或属性。
public static String property = "Class";
public String instanceProp = "Object";
+----------+
| property |
+----------+
T t = new T ();
+-----------+
|instantProp|
+-----------+
T t2 = new T ();
+-----------+
|instantProp|
+-----------+
当 T 类被加载（并被静态初始化）之后，第一个方块中的 property 就被创建完成。之后，每一个新的 T 类对象被建立，都会新建立一个下面的方块。所有对象以及所有静态方法都可以访问第一个方块（静态成员），但除非有一个相关联的 T 类实例，Java 找不到一个对应的实例区域去访问，因此静态类中没有办法直接引用到非静态成员。——除非通过参数或者其它方式可以访问到的实例，如class T {
public static String property = "Class";
public static void printProperty (T t) {
System.out.println (t.property); // 通过参数访问实例属性
这就好比你很饿，想要拿个馒头，可就是没馒头
最近刚学java，的确我看到的说法是静态方法不能直接调用动态方法，在同一个类中静态方法可以直接相互调用。这里的“直接”我认为是不加限定名称的，也就是直接调用方法名称。至于你说的不能直接调用动态方法和实例变量，书上的解释是这样的，动态方法或实例变量是在这个对象创建后才能调用的，如果静态方法能直接调用动态方法或实例变量的话，如果这个对象有多个的话，直接调用动态方法（这里还要说明java类中的每个方法都只维护一个副本，也就是说这些对象们共用一个方法，你直接调用这个方法就说不清到底是调用具体哪个实例对象的方法了），还有万一这个对象没创建呢？我个人认为，你在静态方法里如果直接通过“对象名称.方法”来调用动态方法的话，这个对象名称你是掌握不了的。以上回答如果有错误的地方还请大家指正，本人刚学Java，希望互相学习。
因为 main 方法本来就是静态方法。二次元同好交流新大陆
扫码下载App
汇聚2000万达人的兴趣社区下载即送20张免费照片冲印
扫码下载App
温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
在java中声明的JNI的静态方法（native static）和非静态方法，对于底层的C/C++代码来说是有区别的：JNI函数的参数也由三部分组成：首先是JNIEnv*，是一个指向JNI运行环境的指针；第二个参数随本地方法是静态还是非静态而有所不同一一非静态本地方法的第二个参数是对对象的引用，而静态本地方法的第二个参数是对其Java类的引用；其余的参数对应通常Java方法的参数，参数类型需要根据一定规则进行映射。2. 在C++代码中调用Java类中的方法：jclass clazz = NULL;JNIEnv* env = NULL;//1、JNI回调静态方法： 不需要对象实例，只需要拿到class即可void jniCallUnStaticMethod(){&& getJNIEnv(&env);&& clazz = env-&FindClass("com.test.Test");&&& jmethodID method = env-&GetStaticMethodID(clazz, "staticTestMethod", "(I)V"); && env-&CallStaticVoidMethod(clazz, method, channel);}//2、JNI回调非静态方法： 需要class及其一个实例，可通过如下方式注册一个实例。jobject initedObj = NULL;jboolean com_test_Test_nInit(JNIEnv *env, jobject thiz){&& initedObj =&&}void jniCallUnStaticMethod(){&& getJNIEnv(&env);&& clazz = env-&FindClass("com.test.Test");&& jmethodID method = env-&GetMethodID(clazz, "unStaticTestMethod", "(I)V");&& env-&CallVoidMethod(initedObj, method, channel);}
阅读(1775)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_',
blogTitle:'JNI: Java类中静态和非静态方法的区别',
blogAbstract:'\n\t
1. 用C++实现Java类中的方法：\n\t\t
在java中声明的JNI的静态方法（native static）和非静态方法，对于底层的C/C++代码来说是有区别的：JNI函数的参数也由三部分组成：首先是JNIEnv*，是一个指向JNI运行环境的指针；第二个参数随本地方法是静态还是非静态而有所不同一一非静态本地方法的第二个参数是对对象的引用，而静态本地方法的第二个参数是对其Java类的引用；其余的参数对应通常Java方法的参数，参数类型需要根据一定规则进行映射。2. 在C++代码中调用Java类中的方法：jclass clazz = NULL;JNIEnv* env = NULL;//1、JNI回调静态方法： 不需要对象实例，只需要拿到class即可',
blogTag:'jni,静态方法,java,区别',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:9,
publishTime:9,
permalink:'blog/static/',
commentCount:0,
mainCommentCount:0,
recommendCount:0,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'',
hmcon:'0',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}（一）java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的. 静态方法在类加载的时候 就已经加载 可以用类名直接调用 比如main方法就必须是静态的 这是程序入口 两者的区别就是:静态代码块是自动执行的; 静态方法是被调用的时候才执行的.
静态方法 （1）在Java里，可以定义一个不需要创建对象的方法，这种方法就是静态方法。要实现这样的效果，只需要在类中定义的方法前加上static关键字。例如：
public static int maximum(int n1,int n2)
使用类的静态方法时，注意：a在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。
b 静态方法不能以任何方式引用this和super关键字，因为静态方法在使用前不用创建任何实例对象，当静态方法调用时，this所引用的对象根本没有产生。
（2）静态变量是属于整个类的变量而不是属于某个对象的。注意不能把任何方法体内的变量声明为静态，例如： fun() { static int i=0;//非法。 }
（3）一个类可以使用不包含在任何方法体中的静态代码块，当类被载入时，静态代码块被执行，且只被执行一次，静态块常用来执行类属性的初始化。例如： static { }
类装载步骤 在Java中，类装载器把一个类装入Java虚拟机中，要经过三个步骤来完成：装载、链接和初始化，其中链接又可以分成校验、准备和解析三步，除了解析外，其它步骤是严格按照顺序完成的，各个步骤的主要工作如下：
装载：查找和导入类或接口的二进制数据； 链接：执行下面的校验、准备和解析步骤，其中解析步骤是可以选择的； 校验：检查导入类或接口的二进制数据的正确性； 准备：给类的静态变量分配并初始化存储空间； 解析：将符号引用转成直接引用； 初始化：激活类的静态变量的初始化Java代码和静态Java代码块。 初始化类中属性是静态代码块的常用用途，但只能使用一次。
（二）静态代码块的初始化顺序
class Parent{
static String name = "hello";
System.out.println("parent block");
System.out.println("parent static block");
public Parent(){
System.out.println("parent constructor");
} class Child extends Parent{
static String childName = "hello";
System.out.println("child block");
System.out.println("child static block");
public Child(){
System.out.println("child constructor");
} public class StaticIniBlockOrderTest { public static void main(String[] args) {
new Child();//语句(*)
问题：当执行完语句(*)时，打印结果是什么顺序？为什么？ 解答：当执行完语句(*)时，打印结果是这样一个顺序 :
parent static block child static block parent block parent constructor child block child constructor
分析:当执行new Child()时，它首先去看父类里面有没有静态代码块，如果有，它先去执行父类里面静态代码块里面的内容，当父类的静态代码块里面的内容执行完毕之后，接着去执行子类(自己这个类)里面的静态代码块，当子类的静态代码块执行完毕之后，它接着又去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法，这个就是一个对象的初始化顺序。
总结: 对象的初始化顺序:首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块，父类的非静态代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，然后执行子类非静态代码块和构造方法。
注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。
阅读(...) 评论()java中main方法里面调用非静态方法。_百度知道
java中main方法里面调用非静态方法。
应该用super调用，不过super不能用在静态方法里，可以在本类中写一个非静态的方法，再在main方法中调用public void superFun(){
super.test();} public static void main(String[] args){本类名 t = new 本类名();t.superFun(); }
其他类似问题
为您推荐：
super.t.方法例如class TestTest t = new Test()先new一个类再调用这个变量的.a()
public class TT{ public static void main(String[] args){
TT t = new TT();
t.fun(); }
void fun(){
System.out.println(&hehe&); }}如果想调用本类中的非静态方法可以这么来写。请采纳答案，支持我一下。
静态方法的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁}