static

                                                   static

static（静态）

静态属性总结：

静态属性是类的所有对象共享的，不管创建了多少个对象，静态属性的内存只有一个（所以静态数据成员不在类中定义，是在类外定义的。也就是在程序一执行就被存放到了数据区了，它比对象先生成。）、

静态属性可以直接赋值，也可以在构造方法中中赋值

例子： 

   public class Employee {
    String name;  //员姓名
    double salary; //员工工资
    static int count; // 静态变量 员工数量
    int myCount = 0; //成员变量

    //无参构造
    public Employee() {
    }

    //有参构造
    public Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
        count++;  //员工数量自加1
        myCount++; //自增1
    }

    //测试方法
    public static void main(String[] args) {
        Employee e1 = new Employee("lily", 9000);    //创建lily的对象
        System.out.println("name:" + e1.name + "\tsalary:" + e1.salary + "\tmyCount:" + e1.myCount + "\tcount:" + Employee.count); // lily 9000 1 1
        Employee e2 = new Employee("alice", 3000);   //创建alice的对象
        System.out.println("name:" + e2.name + "\tsalary:" + e2.salary + "\tmyCount:" + e2.myCount + "\tcount:" + e2.count); //alice  3000  1  2
    }
}

 

可以理解实例变量和静态变量的区别。静态的属性与对象没有关系，是所有对象共享的，只与类有关。

 

静态方法总结：

1.静态方法中只能直接访问类中的静态成员（变量、方法），不能访问类中的非静态成员。非静态成员必须要创建实例之后才能访问
    （1）如果希望在静态方法中调用非静态变量，可以通过创建类的（实例）对象，然后通过对象来访问非静态变量
    （2）在普通成员方法中，则可以直接访问同类的非静态变量和静态变量
2.静态方法不能引用this和super关键字，因为静态方法不需要创建实例，在引用this或super时可能引用对象还没创建。
静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
子类只能继承、重载、隐藏父类的静态方法，不能重写，也不能把非静态方法写成静态方法

例子：

 

//测试静态方法   卖票
//(1)静态成员方法只能对方法的局部变量或类的静态成员变量进行操作
//(2)静态成员方法没有this引用
public class TicketSeller {
    private static int count = 11;  //静态属性
    private int a;
    //卖票的静态方法
    public static void sellTicket() {
        int b = 10;
        count = count-1;
        System.out.println("卖票的静态方法"+count);
    }
    
    public static void main(String[] args) {
        TicketSeller.sellTicket();  //直接通过类名调用方法，也可以对象名调用
        System.out.println(Math.abs(-1));
    }
}

 

• 本类的方法之间的调用

  • 静态方法可以被任何方法(静态方法和非静态方法)直接调用；

  • 非静态方法可以被非静态方法直接调用；

  • 非静态方法不能被静态方法直接调用，需要创建对象，用对象名调用。

• 不用类方法之间的调用

  • 调用静态方法，使用类名直接调用 ;

  • 非静态方法不能直接调用，需要创建对象，用对象名调用。

例题：

public class StaticTest {
    //测试本来之间静态方法和非静态方法之间的调用
    //静态方法
    public static void f() {
        StaticTest test = new StaticTest();
        test.a();  //静态----非静态    创建对象，通过对象名调用

        StaticTest.g();  // 静态---静态   直接通过类名调用

    }
    //静态方法
    public static void g() {

    }
    //非静态方法
    public void a() {
        StaticTest.g();   //非静态---静态   直接类名调用
        b();    //非静态--非静态    直接调用
    }
    //非静态方法
    public void b() {
    }
    //不同类之间的调用   调用静态方法---使用类名  调用非静态方法---创建对象，通过对象名调用
}

静态代码块：

随着类的加载而加载，只执行一次，用于给类进行初始化

看JVM类加载的过程：装载、连接、初始化

static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。

static代码块和构造代码块同时出现时优先级：静态代码块>构造代码块>构造方法

例题：

//父类和子类 ，优先父类的初始化
class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }
    //在实例化对象过冲程中，早于构造方法执行
    {
        System.out.println("I'm A class");
    }
    //static块的执行发生在“初始化”的阶段。初始化阶段，jvm主要完成对静态变量的初始化，静态块执行等工作。在实例化对象之前
    static {
        System.out.println("static A");
    }
}  

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    {
        System.out.println("I'm B class");
    }

    static {
        System.out.println("static B");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}  

//输出结果，debug调试
static A
static B
I'm A class
HelloA
I'm B class
HelloB

什么时候用静态？
加静态和不加静态的区别就是：不加静态是在对象里面而且方法是特有的，加了静态是在方法区里面而且方法是共有的。
什么时候使用静态变量：在对象中对于同一个成员变量的数值都一样时就没必要再每一个对象中存一份了，可以把数据抽离出来用静态修饰。也就是说当分析对象中所具备的成员变量的值都是相同的。这时这个成员就可以被静态修饰，注意的是当数据需要是要被修改或被改变就不能用静态修饰了，只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态。如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，这样会对空间有效利用，就可以定义成静态的。

什么时候使用静态函数：函数可以给用户直接给调用。函数就是一种功能，是每个对象具备的功能，在调用函数我们可以用对象来调用，也可以用类名来调用，那么我们怎样去区分什么时候用对象什么时候用类名来调用呢？就参考一点，看看这个函数功能有没有访问到对象里面特有数据的数据，有没有访问到特有数据也是对函数是否要使用静态修饰。简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的，如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，但是非静态需要被对象调用，而仅创建对象调用非静态的。如果方法没有访问特有数据，对象创建是没有意义的，这就是在浪费内存空间了。

用static关键字就是静态成员变量了，静态成员变量就可以使用静态函数