请参阅下面的代码段：
代码1
public class A {
static int add(int i, int j) {
return(i + j);
}
}
public class B extends A {
public static void main(String args[]) {
short s = 9;
System.out.println(add(s, 6));
}
}
代码2
public class A {
int add(int i, int j) {
return(i + j);
}
}
public class B extends A {
public static void main(String args[]) {
A a = new A();
short s = 9;
System.out.println(a.add(s, 6));
}
}
这些代码段之间有什么区别？两者都输出15作为答案。
答案 0 :(得分：138)
静态方法属于类本身，非静态（aka实例）方法属于从该类生成的每个对象。如果您的方法执行的操作不依赖于其类的各个特征，请将其设置为静态（这将使程序的占用空间更小）。否则，它应该是非静态的。
示例：
class Foo {
int i;
public Foo(int i) {
this.i = i;
}
public static String method1() {
return "An example string that doesn't depend on i (an instance variable)";
}
public int method2() {
return this.i + 1; // Depends on i
}
}
您可以调用这样的静态方法：Foo.method1()。如果您尝试使用method2，它将失败。但这可行：Foo bar = new Foo(1); bar.method2();
答案 1 :(得分：29)
如果您只有一个实例（情境，环境），您将要使用该方法，并且您不需要多个副本（对象），则静态方法很有用。例如，如果您正在编写一个登录到一个且只有一个网站的方法，下载天气数据，然后返回值，您可以将其写为静态，因为您可以在方法中硬编码所有必要的数据，你不会有多个实例或副本。然后，您可以使用以下方法之一静态访问该方法：
MyClass.myMethod();
this.myMethod();
myMethod();
如果您要使用您的方法创建多个副本，则使用非静态方法。例如，如果要从波士顿，迈阿密和洛杉矶下载天气数据，并且如果您可以在方法中执行此操作而无需为每个单独的位置单独自定义代码，则可以非静态地访问该方法：
MyClass boston = new MyClassConstructor();
boston.myMethod("bostonURL");
MyClass miami = new MyClassConstructor();
miami.myMethod("miamiURL");
MyClass losAngeles = new MyClassConstructor();
losAngeles.myMethod("losAngelesURL");
在上面的示例中，Java使用相同的方法创建三个单独的对象和内存位置，您可以使用“boston”，“miami”或“losAngeles”引用单独访问这些对象。你无法静态访问上述任何内容，因为MyClass.myMethod（）;是对方法的通用引用，而不是非静态引用创建的单个对象。
如果您遇到访问每个位置的方式或数据返回方式的情况，那么您就无法编写“一刀切”的方法而不会跳过很多箍，您可以通过编写三个单独的静态方法来更好地实现目标，每个方法对应一个位置。
答案 2 :(得分：11)
一般
静态：无需创建我们可以使用
直接调用的对象ClassName.methodname()
非静态：我们需要创建一个像
这样的对象ClassName obj=new ClassName()
obj.methodname();
答案 3 :(得分：8)
静态方法属于该类 并且非静态方法属于 一个阶级的对象。这是一个 非静态方法只能被调用 在一个类的对象上它 属于。静态方法可以 然而，在课堂上被称为 以及作为班级的对象。一个 静态方法只能访问静态 成员。非静态方法可以 访问静态和非静态 因为在当时的成员 调用静态方法，类 可能没有实例化（如果是的话） 呼唤班级本身）。在里面 其他情况下，非静态方法即可 只有在班级有人时才会被召唤 已经实例化了。静止的 方法由所有实例共享 班级。这些是一些基本的 差异。我也想要 指出经常被忽视的差异 在这种背景下。每当方法是 在C ++ / Java / C＃中调用，是隐含的 参数（'this'参考）是 随着/不同而传递 参数。在静态方法的情况下 打电话，'this'参考不是 传递为静态方法属于a 上课，因此没有'这个' 参考
答案 4 :(得分：6)
嗯，从技术上讲，静态方法和虚方法之间的区别在于链接的方式。
大多数非OO语言中的传统“静态”方法在编译时“静态”链接/连接到其实现。也就是说，如果在程序A中调用方法Y（），并将程序A与实现Y（）的库X链接，则X.Y（）的地址被硬编码为A，并且您无法更改它。
在像JAVA这样的OO语言中，“虚拟”方法在运行时“迟到”解决，您需要提供类的实例。因此，在程序A中，要调用虚方法Y（），您需要提供一个实例，例如B.Y（）。在运行时，每次A调用B.Y（）时，调用的实现将取决于所使用的实例，因此B.Y（），C.Y（）等......都可能在运行时提供不同的Y（）实现。
为什么你需要那个？因为这样，您可以将代码与依赖项分离。例如，假设程序A正在执行“draw（）”。使用静态语言就是这样，但是使用OO你会做B.draw（），而实际绘图将取决于对象B的类型，在运行时，它可以改变为方形圆等。这样你的代码可以即使在编写代码之后提供了新类型的B，也无需更改即可绘制多个内容。 Nifty -
答案 5 :(得分：4)
静态方法属于该类，非静态方法属于类的对象。 我举一个例子说明它如何在输出之间产生差异。
public class DifferenceBetweenStaticAndNonStatic {
static int count = 0;
private int count1 = 0;
public DifferenceBetweenStaticAndNonStatic(){
count1 = count1+1;
}
public int getCount1() {
return count1;
}
public void setCount1(int count1) {
this.count1 = count1;
}
public static int countStaticPosition() {
count = count+1;
return count;
/*
* one can not use non static variables in static method.so if we will
* return count1 it will give compilation error. return count1;
*/
}
}
public class StaticNonStaticCheck {
public static void main(String[] args){
for(int i=0;i<4;i++) {
DifferenceBetweenStaticAndNonStatic p =new DifferenceBetweenStaticAndNonStatic();
System.out.println("static count position is " +DifferenceBetweenStaticAndNonStatic.count);
System.out.println("static count position is " +p.getCount1());
System.out.println("static count position is " +DifferenceBetweenStaticAndNonStatic.countStaticPosition());
System.out.println("next case: ");
System.out.println(" ");
}
}
}
现在输出将是:::
static count position is 0
static count position is 1
static count position is 1
next case:
static count position is 1
static count position is 1
static count position is 2
next case:
static count position is 2
static count position is 1
static count position is 3
next case:
答案 6 :(得分：3)
如果您的方法与对象的特征相关，则应将其定义为非静态方法。否则，您可以将方法定义为静态，并且可以独立于对象使用它。
答案 7 :(得分：2)
基本区别是非静态成员使用关键字'static'
声明所有静态成员（包括变量和方法）都在类名的帮助下引用。 因此，类的静态成员也称为类引用成员或类成员..
为了访问类的非静态成员，我们应该创建引用变量。 引用变量存储对象..
答案 8 :(得分：2)
静态方法的另一种情况。
是的，静态方法不是对象的类。当你不希望任何人初始化类的对象或者你不想要多个对象时，你需要使用私有构造函数以及静态方法。
这里，我们有私有构造函数，并使用静态方法创建一个对象。
实施例::
public class Demo {
private static Demo obj = null;
private Demo() {
}
public static Demo createObj() {
if(obj == null) {
obj = new Demo();
}
return obj;
}
}
Demo obj1 = Demo.createObj（）;
此处，一次只有1个实例存活。
答案 9 :(得分：2)
静态方法示例
>>> any([0,0,1,0])
True
>>> any([0,0,0])
False
输出：
class StaticDemo
{
public static void copyArg(String str1, String str2)
{
str2 = str1;
System.out.println("First String arg is: "+str1);
System.out.println("Second String arg is: "+str2);
}
public static void main(String agrs[])
{
//StaticDemo.copyArg("XYZ", "ABC");
copyArg("XYZ", "ABC");
}
}
正如您在上面的示例中所看到的，对于调用静态方法，我甚至没有使用对象。它可以在程序中直接调用，也可以使用类名。
非静态方法示例
First String arg is: XYZ
Second String arg is: XYZ
输出：
class Test
{
public void display()
{
System.out.println("I'm non-static method");
}
public static void main(String agrs[])
{
Test obj=new Test();
obj.display();
}
}
总是使用类的对象调用非静态方法，如上例所示。
要点：
如何调用静态方法：直接或使用类名：
I'm non-static method
或
StaticDemo.copyArg(s1, s2);
如何调用非静态方法：使用类的对象：
copyArg(s1, s2);
答案 10 :(得分：2)
简单地说，从用户的角度来看，静态方法要么全部不使用变量，要么使用的所有变量都是方法本地的，或者它们是静态字段。将方法定义为静态可以带来轻微的性能优势。
答案 11 :(得分：0)
有时，您希望拥有所有对象共有的变量。这是通过静态修饰符完成的。
即。 class human - 头部数量（1）是静态的，对所有人来说都是一样的，然而人类 - 发色对每个人来说都是可变的。
请注意，静态变量也可用于跨所有实例共享信息
答案 12 :(得分：0)
- First we must know that the diff bet static and non static methods
is differ from static and non static variables :
- this code explain static method - non static method and what is the diff
public class MyClass {
static {
System.out.println("this is static routine ... ");
}
public static void foo(){
System.out.println("this is static method ");
}
public void blabla(){
System.out.println("this is non static method ");
}
public static void main(String[] args) {
/* ***************************************************************************
* 1- in static method you can implement the method inside its class like : *
* you don't have to make an object of this class to implement this method *
* MyClass.foo(); // this is correct *
* MyClass.blabla(); // this is not correct because any non static *
* method you must make an object from the class to access it like this : *
* MyClass m = new MyClass(); *
* m.blabla(); *
* ***************************************************************************/
// access static method without make an object
MyClass.foo();
MyClass m = new MyClass();
// access non static method via make object
m.blabla();
/*
access static method make a warning but the code run ok
because you don't have to make an object from MyClass
you can easily call it MyClass.foo();
*/
m.foo();
}
}
/* output of the code */
/*
this is static routine ...
this is static method
this is non static method
this is static method
*/
- this code explain static method - non static Variables and what is the diff
public class Myclass2 {
// you can declare static variable here :
// or you can write int callCount = 0;
// make the same thing
//static int callCount = 0; = int callCount = 0;
static int callCount = 0;
public void method() {
/*********************************************************************
Can i declare a static variable inside static member function in Java?
- no you can't
static int callCount = 0; // error
***********************************************************************/
/* static variable */
callCount++;
System.out.println("Calls in method (1) : " + callCount);
}
public void method2() {
int callCount2 = 0 ;
/* non static variable */
callCount2++;
System.out.println("Calls in method (2) : " + callCount2);
}
public static void main(String[] args) {
Myclass2 m = new Myclass2();
/* method (1) calls */
m.method();
m.method();
m.method();
/* method (2) calls */
m.method2();
m.method2();
m.method2();
}
}
// output
// Calls in method (1) : 1
// Calls in method (1) : 2
// Calls in method (1) : 3
// Calls in method (2) : 1
// Calls in method (2) : 1
// Calls in method (2) : 1