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的执行。只执行一次。例如连接数据库的驱动等

同步代码块:多线程。

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

你可能感兴趣的:(JavaSE基础,java,开发语言)