JavaSE基础(17) static 关键字

static 关键字

静态（static）可以修饰属性和方法。

称为静态属性（类属性）、静态方法（类方法）。

静态成员是全类所有对象共享的成员。

在全类中只有一份，不因创建多个对象而产生多份。

不必创建对象，可直接通过类名访问。

示例：

Person p1 = new Person();
p1.name = "小明";
p1.age = 23;
//p1.city = "广州";

Person p2 = new Person();
p2.name = "晓东";
p2.age = 28;
//p2.city = "广州";

//.......
p1.print();
p2.print();

// Person.city = "深圳";//静态属性的访问：类名.属性名

// System.out.println("城市："+Person.city);

p1.city = "苏州";
p1.printCity();
p1.print();
p2.print();

//调用静态的方法：类名.方法名
Person.printCity();

/**
  * 静态变量，属于类，和对象无关，
  */
public class Person {
    String name;
    int age;
    static String city;//静态的,属于类，对象也可以访问，但是所有的对象共享着一份数据；

    static final double PI = 3.14;//表示静态的常量，运行的过程数据不能改变，同时属于类，可以用类名直接调用

    public void eat(){
        System.out.println("吃东西.....");
    }

    public static void test(){
        System.out.println("test()........");
    }

    /**
      * 静态的方法
      */
    public static void printCity(){
        test();
        //System.out.println("name:"+name);
        // eat();
        System.out.println("城市："+Person.city);
    }

    public void print(){
        printCity();
        eat();
        System.out.println("name:"+this.name+",age:"+age+",city:"+city);
    }
}

静态属性

形成静态属性，不再属于对象。非静态属性（实例属性）属于对象，随着对象的创建而产生，每个对象的属性值都是独立的。

静态属性是属于类的，只有一份(节省内存)。应该由类来访问，但是对象也可以访问，所有的对象共享着一份数据。

非静态属性由对象访问：对象.属性-->赋值，取值

静态属性由类访问：类名.静态属性-->赋值，取值

静态属性可以和final搭配使用，形成静态常量。

静态方法

形成了静态方法。属于类而不再属于对象了，应该由类来访问，但是对象也可以访问。

普通的方法由对象调用。

静态方法中：只能访问属于类，不能访问属于对象。

        A：访问静态属性

        B：访问静态方法

        C：不能直接访问非静态属性

        D：不能直接访问非静态方法

非静态方法中：属于类，属于对象都可以访问

        A：访问静态属性

        B：访问静态方法

        C：访问非静态属性

        D：访问非静态方法

    public void eat(){
        System.out.println(this.name+",吃东西啦。。。"); //非静态方法，可以访问非静态属性
        System.out.println("城市："+Person.city); //非静态方法，可以访问静态属性
        this.showInfo(); // 非静态方法，可以调用非静态方法。
        Person.printCity(); //非静态方法，可以调用静态方法。
    }

    public static void test1(){ //属于类的
        System.out.println(Person.city); //静态方法中，可以访问静态属性。
        Person.printCity();//静态方法中，可以访问静态方法。
        // System.out.println(name); //静态方法中，不能访问非静态的属性
        // this.showInfo(); //静态方法中，不能调用非静态的方法。
    }

    public void eat(){
        System.out.println(this.name+",吃东西啦。。。"); //非静态方法，可以访问非静态属性
        System.out.println("城市："+Person.city); //非静态方法，可以访问静态属性
        this.showInfo(); // 非静态方法，可以调用非静态方法。
        Person.printCity(); //非静态方法，可以调用静态方法。
    }

    public static void test1(){ //属于类的
        System.out.println(Person.city); //静态方法中，可以访问静态属性。
        Person.printCity();//静态方法中，可以访问静态方法。
        // System.out.println(name); //静态方法中，不能访问非静态的属性
        // this.showInfo(); //静态方法中，不能调用非静态的方法。
    }

静态代码块

代码块，就是一块代码。使用{}包裹起来的。

public class Person {

    private String name;
    private int age;

    static String city;//用static修饰的属性，只有一份数据，被所有的对象共享

    //static修饰属性的时候，一般和final一起使用,形成静态常量
    static final double PI = 3.1415;

    //直接写的类里面的，每次创建对象都会执行，而且是在构造函数之前执行
    {
        System.out.println("构造代码块......");
    }

    public Person(){
        System.out.println("这是无参的构造函数......");
    }

    public Person(String name,int age){
        System.out.println("有参构造函数.........");
        this.name = name;
        this.age = age;
    }

    //生成了setter,getter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    public void test(){
        System.out.println("test().......");
    }

    public void print(){
        //可以访问成员变量，类变量
        System.out.println("name:"+name+";"+"age:"+age+";city:"+city);
        //可以访问成员方法，类方法
        staticDemo();
        test();

    }

    public static void staticDemo(){
        System.out.println("staticDemo()......");
    }


    //静态的方法，也叫类方法
    public static void staticMethod(){
        //不能直接访问成员变量
//        System.out.println("name:"+name);
//        System.out.println("age:"+age);
        //可以访问静态属性
        System.out.println("city:"+city);

        //不能直接访问成员方法
//        print();
        //可以访问静态的方法
        staticDemo();
    }
}

普通代码块：{}包裹起来一段代码。注意作用域。

构造代码块：写在类里，方法外的代码块，就叫构造代码块。当创建对象的时候，随着构造函数的调用而执行。而且优先于构造函数执行。构造函数被多次调用，那么构造代码块也被多次调用。

静态代码块：用static关键字修饰的代码块。在类第一次使用的时候执行，优先于main的执行。只执行一次。例如连接数据库的驱动等

同步代码块：多线程。

优先级别：静态代码块 > 构造代码块 >构造方法