❶ java 在static方法内,如何才能访问非static 数据成员和非static方法
方法可以直接调用静态属性或方法
静态方法可直接调用静态属性或方法
静态方法可通过对象调用非静态属性或方法
非静态方法可用this/super.（本类的）非静态属性或非静态方法调用
非静态方法可用对象.非静态属性或非静态方法调用
参考资料：http://..com/question/26812933.html
❷ 某类文件中新建一方法，访问修饰符为public static，同类中的其他方法可以被调用，唯独这个不可以
static的成员属于类，调用时要用类.名；而动态成员是属于对象的调用时要先实例化成对象再调用。因为static的成员属于类，类就一个所以它永远只有一个，所以用static成员时要慎重；而一个类可以实例化出多个对象，所以动态成员可以有很多个。
❸ {java}public static 的小用法，请进
public定义的可以在另一个java文件中访问，static是静态修饰符。
为什么一定要A点activityS1，这样告诉你
A里边有个activityS1 C、D里边也有activityS1，
那么你在 B里边调用的话 如果不用类名，jvm就不知道你调用的是哪个方法。
❹ jsp页面如何去调用java里面public static String T（）方法，进行测试，然后在页面上显示
首先你得导入你的java的有这个T方法的类
加入是A.java
默认包路径比方是:com.abc.A
com包下的abc包下的A.java
<%@ page language="java" import="com.abc.A" %>
或
<jsp:Usebean id="a" class ="com.abc.A"></jsp:Usebean>
<% 在这里就可以使用a了 ，不过你的是静态方法，故而第一个就可以了 %>
❺ “public static”和“public”有什么区别
“public static”和“public”有区别：
1、public static 表示公共的静态方法；public 表示公共的方法。
static：静态。可以设置：静态类、静态变量、静态方法。 没有使用static修饰的成员为实例成员。静态成员的使用：通过类名。
不加static修饰的成员是对象成员，归每个对象所有。
加static修饰的成员是类成员，可以由一个类直接调用，为所有对象共有。
用static关键字标识的程序元素是静态的,不用static标识的程序元素是非静态。
2、静态的东西是在类型加载初始时初始化的,并且与类相关；非静态东西一般放在实例的构造函数中初始化,它是与特定类的实例相关的。
public:公共。在类名前边用的话，说明这个类是公共类。可以设置：public方法， public属性， 和public类
表示在其它任何类或方法中都可以访问。要访问其它类中的public的属性、public方法,则必须必对那个类进行实例化。
public : 公共成员，完全公开，没有访问限制。private : 私有成员, 在类的内部才可以访问。protected : 保护成员，该类内部和继承类中可以访问。internal: 在同一命名空间内可以访问。
❻ PHP请问在static的function中如何访问变量
静态方法只能访问其他的静态方法或属性，比如
classA{
privatestatic$url;
($url){
self::$url=$url;
}
(){
returnself::$url;
}
}
//或者在你的静态方法中获得实例，当然这样的话可能达不到你预期的效果，推荐你还是使用上面的方法。
classA{
private$url='demo';
publicstaticfunctiongetUrl(){
$obj=newself();
return$obj->url;
}
}
❼ 怎么调用静态方法
静态方法不能访问非静态的实例变量和实例方法。实例方法可以访问静态成员和非静态成员。
1在本来中直接调用静态方法
2可以通过类名来调用该类的静态方法
3通过实例调用静态方法
// 外部类，不能是静态的
public class OuterClass {
// 静态方法，又称为类方法，属于Test类
public static void staticFun() {
}
// 非静态方法，又称为实例方法，属于Test类的具体实例
public void nonStaticFun() {
}
// 静态内部类，静态类只能是内部类
public static class StaticInnerClass {
// 静态方法，属于StaticInnerClass类
public static void staticFun() {
}
// 非静态方法，属于StaticInnerClass类的实例
public void nonStaticFun() {
}
}
// 非静态内部类，不能有静态方法
public class NonStaticInnerClass {
// 非静态方法，属于NonStaticInnerClass的实例
public void nonStaticFun() {
}
}
// 测试代码如下：
public static void main(String[] args) {
// 对于静态方法，使用类直接访问
OuterClass.staticFun();
StaticInnerClass.staticFun();
// 对于非静态方法，需要使用类的实例访问
new OuterClass().nonStaticFun();
new StaticInnerClass().nonStaticFun();
// 对于非静态内部类，必须创建外部类后才能使用
OuterClass outerClass = new OuterClass();
NonStaticInnerClass nonStaticInnerClass = outerClass.new NonStaticInnerClass();
nonStaticInnerClass.nonStaticFun();
}
}
❽ java中static的用法
1.静态方法
通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法
声明为static的方法有以下几条限制：
·它们仅能调用其他的static 方法。
·它们只能访问static数据。
·它们不能以任何方式引用this 或super。
class Simple {
staticvoid go() {
System.out.println("Welcome");
}
}
publicclass Cal {
publicstaticvoid main(String[] args) {
Simple.go();
}
}
调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。
2.静态变量
声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间，当然对于final则另当别论了
class Value {
staticintc = 0;
staticvoid inc() {
c++;
}
}
publicclass Count2 {
publicstaticvoid prt(String s) {
System.out.print(s);
}
publicstaticvoid main(String[] args) {
Value v1, v2;
v1 = new Value();
v2 = new Value();
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1.inc();
prt(" v1.c=" + v1.c + " v2.c=" + v2.c);
}
}
结果为：v1.c=0 v2.c=0 v1.c=1 v2.c=1
由此可以证明它们共享一块存储区。static变量有点类似于C中的全局变量的概念。
值得探讨的是静态变量的初始化问题。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
class Value3 {
staticintc = 0;
Value3() {
c = 15;
}
Value3(int i) {
c = i;
}
staticvoid inc() {
c++;
}
}
publicclass Count {
publicstaticvoid prt(String s) {
System.out.println(s);
}
Value3 v = new Value3(10);
static Value3 v1, v2;
static {//此即为static块
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1 = new Value3(27);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v2 = new Value3(15);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
}
publicstaticvoid main(String[] args) {
Count ct = new Count();
prt("ct.c=" + ct.v.c);
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
v1.inc();
prt("v1.c=" + v1.c + " v2.c=" + v2.c);
prt("ct.c=" + ct.v.c);
}
}
结果为：
v1.c=0 v2.c=0
v1.c=27 v2.c=27
v1.c=15 v2.c=15
ct.c=10
v1.c=10 v2.c=10
v1.c=11 v2.c=11
ct.c=11
这个程序展示了静态初始化的各种特性。如果你初次接触Java，结果可能令你吃惊。可能会对static后加大括号感到困惑。首先要告诉你的是，static定义的变量会优先于任何其它非static变量，不论其出现的顺序如何。正如在程序中所表现的，虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面。在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一次，且在类被第一次装载时。如果你能读懂并理解这段代码，会帮助你对static关键字的认识。在涉及到继承的时候，会先初始化父类的static变量，然后是子类的，依次类推。
3．静态类
通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类。
publicclass StaticCls {
publicstaticvoid main(String[] args) {
OuterCls.InnerCls oi = newOuterCls.InnerCls();
}
}
classOuterCls {
publicstaticclass InnerCls {
InnerCls() {
System.out.println("InnerCls");
}
}
}
结果为：InnerCls