我想知道静态方法和非静态方法的区别
只要看下面的代码
代码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答案
静态方法属于类本身，而非静态（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(); Foo bar = new Foo(1); bar.method2();
如果您只有一个实例（情况，情况）要使用该方法，并且不需要多个副本（对象），则静态方法非常有用。 例如，如果您正在编写一种方法login到一个且只有一个网站，下载天气数据，然后返回值，则可以将其编写为静态，因为您可以在方法中硬编码所有必要的数据，你不会有多个实例或副本。 然后，您可以使用以下其中一种方法静态访问该方法：
MyClass.myMethod(); this.myMethod(); myMethod();
如果您要使用您的方法创build多个副本，则使用非静态方法。 例如，如果您想要从波士顿，迈阿密和洛杉矶下载天气数据，并且如果您可以从您的方法中这样做，而无需为每个单独的位置单独定制代码，则可以非静态地访问该方法：
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”引用单独访问的方法创build三个独立的对象和内存位置。 因为MyClass.myMethod（）;你不能访问上面的任何静态。 是该方法的通用引用，而不是非静态引用创build的单个对象。
如果遇到访问每个位置的方式或返回数据的方式，这种情况有很大的不同，所以如果不跳过大量的循环，就不能写出“一刀切”的方法。通过编写三个单独的静态方法来实现您的目标，每个位置一个。
在这里， 了解实例和类成员 ，其解释得非常好。
通常
静态 ：不需要创build对象我们可以直接调用使用
ClassName.methodname()
非静态 ：我们需要创build一个对象
ClassName obj=new ClassName() obj.methodname();
静态方法属于类，非静态方法属于类的对象。 也就是说，一个非静态方法只能在它所属的类的一个对象上被调用。 然而，一个静态方法可以在类和类的一个对象上被调用。 一个静态方法只能访问静态成员。 一个非静态方法可以访问静态和非静态成员，因为在调用静态方法时，类可能不会被实例化（如果它是在类本身上调用的话）。 在另一种情况下，只有在类已经实例化时才能调用非静态方法。 静态方法由类的所有实例共享。 这些是一些基本的差异。 我还想指出在这方面经常被忽略的差异。 每当在C ++ / Java / C＃中调用一个方法，一个隐含的参数（“this”引用）就会与其他参数一起传递。 在静态方法调用的情况下，“this”引用不作为静态方法属于一个类，因此没有“this”引用。
参考 ： Static Vs非静态方法
那么从技术上来说，静态方法和虚拟方法之间的区别就在于它们之间的联系。
在大多数非OO语言中，传统的“静态”方法在编译时被“静态地”链接/接线。 也就是说，如果在程序A中调用方法Y（），并将程序A与实现Y（）的库X链接，则XY（）的地址将被硬编码为A，并且不能更改该地址。
在像JAVA这样的OO语言中，“虚拟”方法在运行时解决“迟到”，并且需要提供一个类的实例。 因此，在程序A中，要调用虚拟方法Y（），则需要提供一个实例BY（）。 在运行时，每次调用BY（）实现时，调用的实现将取决于所使用的实例，所以BY（），CY（）等…都可能在运行时提供不同的Y（）实现。
为什么你会需要这个？ 因为这样你可以将你的代码从依赖关系中分离出来。 例如，说程序A正在做“draw（）”。 用静态语言，就是这样，但是用OO，你会做B.draw（），实际的绘图将取决于对象B的types，在运行时，它可以改变方形一个圆圈等。这样你的代码就可以即使在编写代码之后提供了新的typesB，也可以绘制多个东西而不需要改变。 漂亮 –
静态方法属于类，非静态方法属于类的对象。 我举一个例子，它是如何创造产出之间的差异。
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:
如果您的方法与对象的特征有关，则应将其定义为非静态方法。 否则，您可以将您的方法定义为静态，并且可以独立于对象使用它。
基本的区别是非静态成员使用关键字“静态”
所有的静态成员（包括variables和方法）在类名的帮助下被引用。 因此，类的静态成员也被称为类引用成员或类成员。
为了访问类的非静态成员，我们应该创build引用variables。 引用variables存储一个对象
静态方法的例子
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是：XYZ
第二个stringarg是：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(); } }
输出：
我是非静态的方法
总是通过使用类的对象来调用非静态方法，如上例所示。
关键点：
如何调用静态方法：直接或使用类名称：
StaticDemo.copyArg（s1，s2）; OR copyArg（s1，s2）;
如何调用非静态方法：使用类的对象：
testingobj = new Test（）;
简而言之，从用户的angular度来看，静态方法根本不使用variables，或者使用的所有variables都是方法的本地variables，或者它们是静态的。 将方法定义为静态方法会带来轻微的性能优势。
静态方法的另一个场景。
是的，静态方法是不是对象的类。 而当你不想让任何人初始化这个类的对象或者你不想要多个对象的时候，你需要使用Private构造函数和静态方法。
在这里，我们有私人的构造函数，并使用静态方法创build一个对象。
防爆::
public class Demo { private static Demo obj = null; private Demo() { } public static Demo createObj() { if(obj == null) { obj = new Demo(); } return obj; } }
演示obj1 = Demo.createObj（）;
在这里，一次只有一个实例存活。
“有时候，你想拥有所有对象共有的variables，这是通过静态修饰符来实现的。
即人类 – 人头（1）的数量是静态的，对于所有人类都是相同的，但是人类 – 头发颜色对于每个人是可变的。
请注意，静态variables也可以用于在所有实例之间共享信息
