面向对象(8-1)：static关键字(静态修饰)

面向对象(8)：static关键字(静态修饰)

定义一个人，成员变量有姓名、年龄、国籍

//创建类
class Person{
    //定义成员变量
    private String name;
    private int age;
    private String nationality;
	//创建无参构造方法
    public Person() {
    }
	//创建带参构造方法
    public Person(String name, int age, String nationality) {
        this.name = name;
        this.age = age;
        this.nationality = nationality;
    }
	//创建公共的setXxx()方法和getXxx()方法
    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 String getNationality() {
        return nationality;
    }

    public void setNationality(String nationality) {
        this.nationality = nationality;
    }
	//创建show方法输出所有成员变量
    public void show(){
        System.out.println("姓名："+name+",年龄："+age+",国籍："+nationality);
    }
}
	//创建测试类
public class PersonDemo {
    public static void main(String[] args) {
        //创建第一个对象
        Person p1 = new Person("宋轶",26,"中国");
        p1.show();

        //创建第二个对象
        Person p2 = new Person("胡歌",30,"中国");
        p2.show();

        //创建第三个对象
        Person p3 = new Person("钱学森",18,"中国");
        p3.show();
        
        执行结果为：
                姓名：宋轶,年龄：26,国籍：中国
                姓名：胡歌,年龄：30,国籍：中国
                姓名：钱学森,年龄：18,国籍：中国

                Process finished with exit code 0

由上面可知，国籍都一样，都是中国，每次创建的时候，都会在堆内存开辟一个这样的变量空间，有点浪费。 针对多个对象拥有共同的成员变量，值是一样的时候，Java提供了一个关键字给我们处理这样的情况，这个关键字叫做：static

可以修饰成员变量和成员方法，修饰成员变量的时候，可以让多个对象共用一个成员变量的值

在测试类中，三个对象，只需要输入一个中国就可以了，然后用static修饰一下成员变量国籍即可，打印的结果和之前也是一样的，如下：

//创建类
class Person{
    //定义成员变量
    private String name;
    private int age;
    private static String nationality;//只需要在此处加个static就行，习惯加在private后面
    .......
    .......(为方便，中间内容省略一下不写)
     //创建第一个对象
        Person p1 = new Person("宋轶",26,"中国");//第一个对象的“中国”不可去掉
        p1.show();

        //创建第二个对象
        Person p2 = new Person("胡歌",30);//从第二个对象开始，“中国”可以去掉
        p2.show();

        //创建第三个对象
        Person p3 = new Person("钱学森",18);//“中国”可以去掉
        p3.show();
        
        执行结果为：
                姓名：宋轶,年龄：26,国籍：中国
                姓名：胡歌,年龄：30,国籍：中国
                姓名：钱学森,年龄：18,国籍：中国

                Process finished with exit code 0

什么时候使用static关键字呢？
    如果说明某个成员变量是被所有对象共享的，那么它就应该被定义为静态的。
举例：
    哈罗单车：（可以被static修饰）
    自己的水杯：（不可以被static修饰）

static的特点：它可以修饰成员变量和成员方法
1、随着类的加载而加载
    运行之前会将class类文件加载到方法区中，而被static修饰的成员是随着
    类的加载而加载，所以被static修饰的成员在方法区存放（回想一下main方法）
2、优先于对象存在（在测试类创建对象之前就存在了）
3、被类所有的对象共享
			举例：所有的中国人的国籍信息都一样
4、被静态修饰的成员变量可以在另外一个类中，直接通过类名调用

我们今后开发的时候，只要看到类中有静态的成员变量或者成员方法，
今后调用的时候，一律用  类名.静态成员  这样的方式去调用
推荐使用类名的方式调用，这也是规范
通过调用的方式不同，区分不同的成员
被静态修饰的成员，一般情况下被称之为：类成员，与类相关的

特点4案例如下：

class Demo2{
    //定义一个非静态的成员变量
    int a = 10;

    //定义一个静态的成员变量
    static int b = 20;
}

public class StaticDemo1 {
    public static void main(String[] args) {
    //想要在测试类中调用Demo2中的a，必须创建对象
 		Demo2 x = new Demo2();
		System.out.println(x.a);
		//被static修饰的，可以直接通过类名调用（特点4）
        System.out.println(Demo2.b);
    }
}
        执行结果为：
                10
                20

                Process finished with exit code 0

静态成员访问的问题

1、static可以修饰成员变量和成员方法
2、非静态的成员方法，可以访问静态的成员变量/方法，也可以访问非静态的成员变量/方法
3、静态的成员方法，只能访问静态的成员，不可以访问非静态的成员变量/方法

静态变量和成员变量的区别

1、所属不同
	静态变量属于类，也称之为类变量
	成员变量属于对象，也称之为对象变量（实例变量）
2、内存位置不同
	静态变量存储于方法区的静态区
	成员变量存储于堆内存
3、内存出现时间不同
	静态变量随着类的加载而加载，随着类的消失而消失
	成员变量随着对象的创建而存在，随着对象的消失而消失
4、调用不同
	静态变量可以通过类名调用，也可以通过对象调用
	成员变量只能通过对象名调用