关键字private、static总结

傷城~ 2023-10-08 09:07 22阅读 0赞

#### 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();
        }
    }
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16

上面代码运行出来的结果是：  
![这里写图片描述][70]  
由运行结果看到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());
        }
    }
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
       29 
       30

![这里写图片描述][70 1]  
由上述代码可以看到使用了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();
        }
    }
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
       29 
       30 
       31 
       32

当用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();
        }
    }
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21

![这里写图片描述][70 2]  
从上面的运行结果来看，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();
        }
    }
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15 
       16 
       17 
       18 
       19 
       20 
       21 
       22 
       23 
       24 
       25 
       26 
       27 
       28 
       29 
       30 
       31 
       32 
       33 
       34 
       35 
       36 
       37 
       38

![这里写图片描述][70 3]  
从上面结果看出当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();
        }
    }
     
     
      
     
     
      
       1 
       2 
       3 
       4 
       5 
       6 
       7 
       8 
       9 
       10 
       11 
       12 
       13 
       14 
       15

![这里写图片描述][70 4]  
由上面的运行错误可知static修饰的方法里引用的变量也必须是静态的。  
所以 int c要改为static int c。

[70]: https://img-blog.csdn.net/20180723210521113?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTY2NjI0NA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 1]: https://img-blog.csdn.net/20180723212648294?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTY2NjI0NA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 2]: https://img-blog.csdn.net/20180723232144112?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTY2NjI0NA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 3]: https://img-blog.csdn.net/2018072323302054?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTY2NjI0NA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70
[70 4]: https://img-blog.csdn.net/20180723235103287?watermark/2/text/aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTY2NjI0NA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70