java中static和non static到底区别在哪儿呢？

Posted 2023-05-10

求java中static和non static的区别。越详细越好，最好能有小例子。说得非常好的还有追加~ 谢谢！

1.首先是类中的数据，static的
class A
static int a;

class B
int b;

无论新建几个A对象，这几个对象公用一个int a，一个对象的a改变，另一个也会改变。
而B对象，不同对象之间的int b独立存在，互不影响，可以有多个值。

2.类中的方法
静态的方法，不需要建立对象就可以访问
如Math.abs()这个方法，我们没有建立Math的对象，就可以通过类名直接使用abs这个方法。
而非静态的方法，必须先建立对象，然后通过对象名，调用这个方法。
如JButton jb = new JButton();
jb.addActionListener(l);

ps:在静态方法的定义中，不能直接引用本类的其他非静态方法。例如。我们不能在main中直接引用，本类的其他方法。所以我们经常可以看见，在main方法中，先建立本类的一个对象，然后才通过对象调用本类的其他方法。

3.在初始化过程中，静态的总是先初始化。

还有不明白的请补充。 参考技术A <转http://yydy1983.javaeye.com/blog/259585>
java中static的作用

有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。

声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制：
·
它们仅能调用其他的static 方法。
·
它们只能访问static数据。
·
它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.

class UseStatic
static int a = 3;
static int b;

static void meth(int x)
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);



static
System.out.println("Static block initialized.");
b = a * 4;



public static void main(String args[])
meth(42);



一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。

注意：在一个static 方法中引用任何实例变量都是非法的。

下面是该程序的输出：

Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：

classname.method( )

这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。

下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。

class StaticDemo
static int a = 42;
static int b = 99;
static void callme()

System.out.println("a = " + a);



class StaticByName

public static void main(String args[])
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);




下面是该程序的输出：

a = 42
b = 99

static成员是不能被其所在class创建的实例访问的。

如果不加static修饰的成员是对象成员，也就是归每个对象所有的。

加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的 参考技术B 我给你做个通俗的比方，一个类就好比一个大帮派，这个大帮派里面是由很多小帮派组成的，就相当于这些小帮派就是这个大帮派的对象。然而，大帮派的老大也是每个小帮派的老大，他们是同一个人，这就相当于是静态的，而每个小帮派的老大之间互不干扰，都独立于其他帮派存在。这就相当于是非静态的。所以静态和非静态的区别就是：静态为大家所共有，非静态就是每个对象都有只属于自己的一个。所以既然为大家共有，静态的属性或者方法就可以通过类名直接调用，而非静态的只能通过具体的对象调用了。
例子如下：
class Person
public static int sex;
public int age;

public static int getSex()
return sex;

public int getAge()
return age;

public static void main(String[] args)
System.out.println(Person.sex);//sex静态，通过类名直接访问
Person p=new Person();
System.out.println(p.age);//age为非静态的，必须通过具体的对象才能访问
Person.getSex();
p.getAge();//方法的调用和属性类似



希望对你有所帮助，不明白的地方可以hi我！ 参考技术C 内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。一个非静态内部类不能脱离外部类实体被创建，一个非静态内部类可以访问外部类的数据和方法，因为他就在外部类里面。 参考技术D static是对象的共性，否者就是特性。
男人这个类，性别那就是static的，不管张三李四只要是男人，你性别就是男的。身高就是特性，张三李四个子身高是不一样的。
学东西要理论联系实际，理解起来就快了！

static关键字之内存分析

通常情况下，Java把内存分为栈内存、堆内存和方法区

栈内存用来存放一些基本类型的变量和数组（数组也是一种引用类型）及对象的引用变量

堆内存主要是来放置对象的，即我们在程序中new出来的对象。

static，意味为静态的，用static修饰的变量和方法，实际上是给这些变量和方法指定了在内存中的”位置“（这个位置也叫静态区、方法区、数据区和共享区）。既然在内存中指定了位置，那么他们的 “大小”似乎就是固定的了，有了位置和大小的特征，在栈中或堆中开辟空间那就是非常的方便了。对于静态的东西，JVM在加载类时，就在內存中开辟了这些静态变量的空间（内存空间），即编译时就为这些成员变量的实例分配了空间。

下面我们来看一段代码

 1 package demo;
 2 
 3 public class StaticDemo {
 4     public static void main(String[] args) {
 5         Visitor visitor1 = new Visitor();
 6         System.out.println("count : " + visitor1.count);// 1
 7         System.out.println("visitCount : " + Visitor.visitCount);// 1
 8 
 9         Visitor visitor2 = new Visitor();
10         System.out.println("count : " + visitor2.count);// 1
11         System.out.println("visitCount : " + Visitor.visitCount);// 2
12 
13         Visitor visitor3 = new Visitor();
14         visitor3.count = 5;
15         visitor3.visitCount = 0; // 归0
16         System.out.println("count : " + visitor1.count);// 1
17         System.out.println("count : " + visitor2.count);// 1
18         System.out.println("count : " + visitor3.count);// 5
19         System.out.println("visitCount : " + visitor1.visitCount);// 0
20         System.out.println("visitCount : " + visitor2.visitCount);// 0
21         System.out.println("visitCount : " + visitor3.visitCount);// 0
22     }
23 }
24 
25 class Visitor {
26     int count;
27     static int visitCount;
28 
29     public Visitor() {
30         count++;
31         visitCount++;
32     }
33 }

从上面代码来看，用static修饰的变量，每个类的实例改变的都是同一个副本，即在内存中static修饰的变量只有一份，而对于普通的成员变量，每个实例都有各自的副本，我们用图来简单的分析StaticDemo类的代码，首先JVM把Visit类与StaticDemo类编译完然后加载到方法区，在Visit方法区中，JVM检查到有个static修饰的变量visitCount，则又开辟了一块内存（叫做静态区）来存放，此时内存情况

接着JVM会自动寻找main方法并在栈中为其开辟一个空间，再看代码第5行

这时，来了一个访问者visitor1，JVM在栈中为visitor1开辟了一块内存，并且指向堆中的Visitor内存空间，由于count与visitCount为成员变量，所以有默认初始值0，根据代码

第6行与第7行的运行结果

我们可以得到count与visitCount变量在堆内存中的值

同理9，10，11行

与5，6，7行分析类似，此时内存情况及count与visitCount变量的值

接下来来了一个visitor3，把count与visitCount都重新赋值了

由于visitor1，visitor2，visitor3在堆空间中都有各自的count变量，所有当visitor3改变了count变量的值时，visitor1与visitor2的count变量值并没有受影响，而当visitor3对visitCount重新赋值了，因为visitor1，visitor2，visitor3的visitCount都为静态区中的0x0001，所以用visitor1，visitor2，visitor3访问的visitCount为最新的值0。可见，静态变量与具体的实例无关，属于整个类，在编程中，当所有对象共享某个数据的时候，我们就可以把这个成员变量定义为静态的，如上面的visitCount。