static

一：静态函数：用于变量前，表示每次重新使用该变量所在的方法，类，变量的值为程序这次运行最后一次为变量赋值时的值。

1.：首先在java中被申明为静态的。JVM会把这个属性或者是方法的内存开辟在静态常量池，而不是存放在所申明类中的堆中。所以不能通过对象名来访问。

private void s()
{
static int a=1;
a++;
}//方法第一次调用结束后a在内存内值为2；
//方法在第二次调用结束后a在内存内值为3；


//static的一个应用:使用静态的变量可以实现“累加”的效果。因为静态的变量在内存中独一份！
public class TestCircle {
    public static void main(String[] args) {
        Circle c1 = new Circle(2.0);
        Circle c2 = new Circle(2.1);
        System.out.println(Circle.getTotal());
        Circle.show();
        c1.setInfo("我是一个漂亮的圆");
        Circle.show();
    }
}
class Circle{
    private double radius;//半径
    private static String info = "我是一个圆";
    private static int total = 0;//因为total是static的，在内存中独一份，所以可以用来记录创建的对象的个数
    
    public Circle(double radius){
        this.radius = radius;
        total++;
    }
    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public static String getInfo() {
        return info;
    }

    public static void setInfo(String info) {
        Circle.info = info;
    }

    public static int getTotal() {
        return total;
    }

    public static void show(){
        System.out.println(info);
    }
    
    @Override
    public String toString() {
        return "Circle [radius=" + radius + "]";
        
    }
    
}

public class TestNew {  
    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) {  
        // TODO Auto-generated method stub  
        meth(42);  
    }  
} 

结果：
static block initialized
x=42;a=3;b=3*4=12;
上述class TestNew的执行顺序是：
首先static 块执行(打印一条消息)，a被设置为3，最后b被初始化为a*4 成12。
然后调用main()，main () 调用meth() ，把值42传递给x。
3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。

 

二：静态方法：在方法（函数）前用static修饰，表示此方法为所在类或所在的自定义类所有，而不是这个类的实例所有。静态方法是使用公共内存空间的，就是说所有对象都可以直接引用，不需要创建对象再使用该方法。

例如，创建一个类，里面有一个静态方法和非静态方法：

class Test{
public static int z(int xx,int yy){
return xx+yy;
}
public int zz(int xx,int yy){
return xx+yy;
}
} 

 

然后在含有main方法的类中使用这个类时，对与以上非静态和静态方法的引用方式是不同的，如下：

 1 import Test;
 2 public class mainClass{
 3 int sum;
 4 public static void main(String args[]){
 5 
 6 sum=Test.z(1,2); //直接用类.方法或者属性就可以使用该方法或属性。
 7 
 8 System.out.println(sum);
 9 Test t=new Test();
10 sum=t.zz(1,2); //因为zz不是静态方法，所以只能只能用Test类创建一个t对象，然后调用该对象的方法。
11 System.out.println(sum);
12 }
13 } 

三：静态类（非静态内部类也可以定义静态成员但需要同时有final关键词修饰，静态方法鉴于无法用final修饰，仍必须是在静态内部类 或者非内部类中定义。）：静态内部类是指在一个类的内部，又定义了一个用static修饰的类。可以用C中的结构体内嵌结构体来理解。

1:首先，用内部类是因为内部类与所在外部类有一定的关系，往往只有该外部类调用此内部类。所以没有必要专门用一个Java文件存放这个类。

2:静态方法、静态成员变量。它唯一的作用就是随着类的加载（而不是随着对象的产生）而产生，以致可以用类名+静态成员名直接获得。这样静态内部类就可以理解了，它可以直接被用 外部类名+内部类名 获得。举例如下：

public class Build {

       ..............

     public static class VERSION {

            ................

            public static final String RELEASE = getString("ro.build.version.release");

            ................

      }

      ................

}

在外部可以直接通过Build.VERSION.RELEASE来访问。

public class YourClass{
    public static int arg0=0;    //这是个静态成员

    {
        //这是个静态块

    }

    public static void doSomething(){

        //这是个静态方法

    }

}

 

 

转载于:https://www.cnblogs.com/klstime/p/7277459.html