java中static的用法

Bertha 。 2023-01-13 09:55 106阅读 0赞

[java访问权限控制][java]

### 文章目录 ###

*  java中static的用法
 *   *   *  static修饰成员变量
         *   *   *  类的成员变量
         *  static修饰方法
         *  static修饰代码块

# java中static的用法 #

在java中static可以用来修饰以下内容:

*  成员变量

> 静态变量，可以直接通过类名去访问

*  成员方法

> 静态方法，可以直接通过类名去访问

*  代码块

> 静态代码块，当java虚拟机加载类时，就会执行该代码块

### static修饰成员变量 ###

*  成员变量

> 静态变量，可以直接通过类名去访问

##### 类的成员变量 #####

类的成员变量包括

*  类变量(静态变量)

> 被static修饰的变量  
> 在内存中只有一个拷贝  
> 类内部，可以在任何方法内直接访问静态变量  
> 其它类中，可以直接通过类名访问

*  实例变量

> 没有被static修饰的变量  
> 没创建一个实例，就为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响

package cn.zhz.Kind.dh;
    
    public class Person04 { 
        //属性 成员变量 全局变量 实例变量
        public int age;
        public String name;
        //静态变量 调用时用类名调用
        public static String email;
    }

package cn.zhz.Case.dh;
    
    import cn.zhz.Kind.dh.Person04;
    
    public class Person04Test { 
        public static void main(String[] args) { 
            //调用类的普通成员变量 (属性) 创建对象(实例) 通过对象去调用-->实例变量
            Person04 person04 = new Person04();
            person04.age = 18;
            person04.name = "张三";
            //静态变量直接通过类名去调用
            Person04.email = "zhansan@gmail.com";
        }
    }

*  static变量的作用:

> 可以被类的所有的实例共享，可以作为实例之间进行交流的共享数据  
> 如果类的所有实例都包含一个相同的常量属性，可以把这个属性定义为静态常量属性，从而节省内存空间。

package cn.zhz.Case.dh;
    
    public class StaticTest { 
        static int num;
        public static void main(String [] args){ 
            num++;
            StaticTest staticTest = new StaticTest();
            staticTest.num++;
            StaticTest staticTest1 = new StaticTest();
            staticTest1.num++;
            StaticTest.num++;
            System.out.println(num);
        }
    }

编写程序模拟实现选民投票过程，一群选民进行投票，每一个选民只允许进行一次投票，并且当投票总数达到100时，就停止投票

package cn.zhz.Kind.dh;
    
    //模拟实现选民投票过程，一群选民进行投票，每一个选民只允许进行一次投票，并且当投票总数达到100时，就停止投票
    public class Voter { 
        //目前投票数 被所有的选民实例共享
        static int count;
        //投票的最大值
        static final int MAX_COUNT = 100;
        //选民名称
        private String name;
    
        public Voter() { 
    
        }
    
        public Voter(String name) { 
            this.name = name;
        }
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public void vote() { 
            if (count == MAX_COUNT) { 
                System.out.println("投票总数达到100，无法继续投票");
            } else { 
                count++;
                System.out.println(this.name + "投票成功当前票数为" + count);
            }
        }
    }

package cn.zhz.Case.dh;
    
    import cn.zhz.Kind.dh.Voter;
    
    public class VoterTest { 
        public static void main(String[] args) { 
            Voter voter1 = new Voter("张三");
            voter1.vote();
            Voter voter2 = new Voter("李四");
            voter2.vote();
            Voter voter3 = new Voter("王五");
            voter3.vote();
            Voter voter4 = new Voter("赵六");
            voter4.vote();
            for (int i = 1;i <= 97;i++){ 
                Voter v = new Voter("v"+ i);
                v.vote();
            }
            Voter voter = new Voter("小尾巴");
            voter.vote();
        }
    }

### static修饰方法 ###

*  成员方法

> 静态方法，可以直接通过类名去访问  
> 静态方法中不可以使用this和super  
> 不可以直接访问所属类的实例变量和实例方法  
> 可以直接访问类的静态变量和静态方法

*  实例方法:通过实例进行访问

> 可以直接访问所属类的静态变量、静态方法、实例变量和实例方法

注意:静态方法必须被实现

package cn.zhz.Kind.dh;
    
    public class Person04 { 
        //属性 成员变量 全局变量 实例变量
        public int age;
        public String name;
        //静态变量 调用时用类名调用
        public static String email;
    
        public void m2() { 
            System.out.println("实例方法m2");
        }
    
        //成员方法:实例方法->可以调用实例变量 实例方法 静态变量 静态方法
        public void m1() { 
            System.out.println(this.age);
            System.out.println(email);
            m2();
            m3();
        }
    
        //静态方法
        public static void m3() { 
            //在静态方法中不可以使用this
    // System.out.println(this.age);
    // m1();//在静态方法中不可以调用实例方法
            //在静态方法中不可以调用实例变量
    // System.out.println(age);
            System.out.println("静态方法m3");
            //在静态方法中可以直接访问静态变量
            System.out.println(email);
            m4();
        }
    
        public static void m4() { 
            System.out.println("这是一个静态方法");
        }
    }

package cn.zhz.Case.dh;
    
    import cn.zhz.Kind.dh.Person04;
    
    import java.util.Arrays;
    
    public class Person04Test { 
        public static void main(String[] args) { 
            //调用类的普通成员变量 (属性) 创建对象(实例) 通过对象去调用-->实例变量
            Person04 person04 = new Person04();
            person04.age = 18;
            person04.name = "张三";
            //静态变量直接通过类名去调用
            Person04.email = "zhansan@gmail.com";
            //通过实例调用实例方法
            person04.m1();
            //可以通过类名调用静态方法
            Person04.m3();
    // Math.random();
    // Arrays.sort();
    // Arrays.binarySearch();
        }
    }

其实java程序的入口main()方法就是最常用的静态方法

public static void main(String [] args){ 
    
    }

### static修饰代码块 ###

> 静态代码块，当java虚拟机加载类时，就会执行该代码块

当程序中有多个静态代码块时，程序会依次向下执行，按照顺序加载，并且每一个静态方法块只可以执行一次

package cn.zhz.Kind.dh;
    
    public class Static01 { 
        static int num = 100;
    
        static { 
            num += 100;
            System.out.println(num);
        }
    
        static { 
            num += 100;
            System.out.println(num);
        }
    
        public static void main(String[] args) { 
            Static01 static01 = new Static01();
            Static01 static02 = new Static01();
            System.out.println(Static01.num);
        }
    }

[java面向对象之二 继承][java_]

[java]: https://blog.csdn.net/qq_45671732/article/details/115762406
[java_]: https://blog.csdn.net/qq_45671732/article/details/115800489