关键字private、static总结

private

private在英文中是私有的意思，在Java中它用来修饰成员变量，是成员变量私有化，下面先举个列子。

class Film{
    private String name;
    private int price;

    public void show(){
        System.out.println(name+"------"+price);
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s = new Film();
        s.name="动物世界";
        s.price=35;
        s.show();
    }
}

上面代码运行出来的结果是：

由运行结果看到private访问受控，所以private只能在本类中进行运用操作。

下面是正确操作的代码：

class Film{
    private String name;
    private int price;

    public Film(){}

    public String getName(){
        return name;
    }

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

    public int getPrice(){
        return price;
    }

    public void setPrice(int price){
        this.price=price;
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s = new Film();
        s.setName("动物世界");
        s.setPrice(35);
        System.out.println(s.getName()+"-----"+s.getPrice());
    }
}

由上述代码可以看到使用了setXXX()/getXXX()来操作private修饰的成员变量，setXXX()方法是是带参的，将变量传进来，getXXX()将赋值了的变量传出来。因此private只能在本类中进行运用。

class Film{
    private String name;
    private int price;
    static String country;

    public Film(String name,int price){
        this.name=name;
        this.price=price;
    }

    public Film(String name,int price,String country){
        this.name=name;
        this.price=price;
        this.country=country;
    }

    public void show(){
        System.out.println(name+"----"+price+"----"+country);
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s1 = new Film("动物世界",35,"中国");
        s1.show();

        Film s2 = new Film("心理罪",30);
        s2.show();

        Film s3 = new Film("南极之恋",25);
        s3.show();
    }
}

当用private修饰成员变量时，也可以使用带参的构造方法。上面两种方法都可以使用。

static

static在英文中的意思是静止的，不变的。static修饰的变量成为静态变量。
下面是static修饰的变量的例子：

class Film{
    private String name;
    private int price;
    static String actor;

    public Film(String name,int price,String actor){
        this.name=name;
        this.price=price;
        this.actor=actor;
    }

    public void show(){
        System.out.println(name+"----"+price+"----"+actor);
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s1 = new Film("动物世界",35,"李易峰");
        s1.show();
    }
}

从上面的运行结果来看，static的作用相当于c语言中的全局变量，当给它赋值后，后面再出现它修饰的变量值一律为第一次赋的初值。

class Film{
    private String name;
    private int price;
    static String country;

    public Film(String name,int price){
        this.name=name;
        this.price=price;
    }

    public Film(String name,int price,String country){
        this.name=name;
        this.price=price;
        this.country=country;
    }

    public void show(){
        System.out.println(name+"----"+price+"----"+country);
    }
}
public class CsdnPrivate {
    public static void main(String[] args) {
        Film s1 = new Film("动物世界",35,"中国");
        s1.show();

        Film s2 = new Film("心理罪",30);
        s2.show();

        Film s3 = new Film("南极之恋",25);
        s3.show();
        System.out.println("-----------------------");
        Film s4 = new Film("暮光之城",28,"美国");
        s4.show();

        Film  s5 = new Film("超人总动员",38);
        s5.show();
    }
}

从上面结果看出当static修饰的成员变量变化时，后面出现的变量都发生了改变。

　　在所有程序编译运行的过程中，变量都是由系统自动分配内存进行存储的。 在这个存储过程中，static所修饰的变量(也就是静态变量)，它所被分配的空间是一直伴随程序运行的，空间将会保持到程序的结束关闭，才会被释放。换句话说：程序运行时，系统分配给静态变量的内存是一直存在的，除非程序被终止。根据这一点来看，假若在定义一个类的过程中，定义了一个static修饰的变量，那么这个类在被加载的同时，被static修饰的变量就存在于内存当中了，这样一来就独立于该类的所有对象，被该类所有对象共享，将对象相关的变成了类相关，所以静态变量也可以称之为类变量。假设一个类中某个属性被static所修饰，那么就可以通过”类名.属性名“来访问。

下面是static修饰的变量，通过类名.属性名来访问的例子。

class Arrary{
    static int a=10;
    static int b=20;
    int c;
    public static void add(){
        c=a+b;
        System.out.println(c);
    }

}
public class StaticDemo {
    public static void main(String[] args) {
        Arrary.add();
    }
}

由上面的运行错误可知static修饰的方法里引用的变量也必须是静态的。
所以 int c要改为static int c。