类变量（静态变量），类方法，main

1. 类.方法（）调用，没有创建对象在调用，因为当一个方法是static时，就是一个静态方法，静态方法可以直接通过类名调用。public static void cry(){}
2. 类变量也叫静态变量/静态变量，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。
3. 静态变量（static），会被该类创建的对象共享。不管static变量在哪里，static变量是同一个类所有对象共享static类变量，在类加载的时候就生成了。
4. 定义语法：访问修饰符 static 数据类型 变量名；
5. 访问类变量：（推荐）类名.类变量名，对象名.类变量名

6. package com.hspedu.static_;
   
   public class VisitStatic {
       public static void main(String[] args) {
           //类变量是随着类的加载而创建的，所以即使没有创建对象实例也可以访问。
   
           System.out.println(A.name);//北京大学
           //通过对象名访问
           A a = new A();
           System.out.println(a.name);//北京大学
       }
   }
   class A{
       //类变量
       //类变量的访问，必须遵守相关的访问权限
       public static String name = "北京大学";
   }
   
   

   如果是私有的private普通变量要用getter和setter方法访问

7. 类变量的注意事项

   1. 什么时候需要使用类变量：当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）

   2. 类变量与实例变量区别：类变量是该类的所有对象共享，而实例变量是每个对象独享。

   3. 实例变量不能通过，类名.变量名  方式访问

   4. 类变量的生命周期是随着类的加载开始，随着类的消亡而摧毁

8. 类方法也叫静态方法

   1. 形式：访问修饰符 static 数据返回类型 方法名（）{}//推荐这种形式

   2. 类方法调用：类名.类方法名，或者对象名.类方法名

   3. package com.hspedu.static_;
      
      public class StaticMethod {
          public static void main(String[] args) {
              Stu stu = new Stu("tom");
              stu.payFee(100);
              //Stu.payFee(100);//当你用这种形式调用方法时，该方法必须是静态方法才能用这种形式。
              //要不然报错
      
              Stu jack = new Stu("jack");
              jack.payFee(100);
      
              //输出当前收到的学费
              Stu.showFee();
          }
      }
      class Stu{
          private String name;//普通成员
          //定义静态变量，来积累学生的学费
          private static double fee = 0;
      
          public Stu(String name) {
              this.name = name;
          }
          //1.当方法使用了static修饰后，该方法就是静态方法
          //2.静态方法就可以访问静态属性/变量
          public static void payFee(double fee){
              //传进来的参数fee累计到Stu.fee
              Stu.fee += fee;
          }
          public static void showFee(){
              System.out.println("总学费有："+Stu.fee);
          }
      
      
      
      
      }
      

      //Stu.payFee(100);//当你用这种形式调用方法时，该方法必须是静态方法才能用这种形式。

9. 类方法使用场景
   1. 当方法中不涉及到任何对象相关的成员，则可以将方法设计成静态方法，提高开发效率。（如果希望不创建实例，也可以调用某个方法。类名.类方法名）
   2. 开发自己的工具类时，可以将方法做成静态的，方便调用。

   3. package com.hspedu.static_;
      
      public class AAAA {
          public static void main(String[] args) {
              System.out.println(MyTools.calSum(12,13));//25.0
          }
      }
      
      
      class MyTools{
          public static double calSum(double n1,double n2){
              return n1+n2;
          }
      }
      

      定义自己的工具类

10. 类方法注意事项

    1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区。类方法中无this的参数，普通方法中隐含着this的参数

    2. 普通方法调用需要通过对象名调用。

    3. 类方法中不允许使用和对象有关的关键字，比如this和super，普通方法可以。

    4. 类方法中只能访问静态变量或静态方法。

    5. 普通成员方法，既可以访问 普通变量（方法），也可访问静态变量（方法）。

    6. package com.hspedu.static_;
       
       public class MethodClass {
           public static void main(String[] args) {
               D.hi();//ok
               //D.say();//不ok。
               //Non-static method 'say()' cannot be referenced from a static context
       
       
           }
       }
       //静态方法只能访问静态成员
       class D{
           private int n1 = 100;
           private static int n2 = 200;
           public void say(){//非静态方法
       
           }
           public static void hi(){//静态方法
               //类方法中不允许使用和对象有关的关键字，比如this和super，普通方法可以。
               //System.out.println(this.n1);
               //'com.hspedu.static_.D.this' cannot be referenced from a static context
           }
           //类方法中只能访问静态变量或静态方法
           public static void hello(){
               System.out.println(n2);//ok
               System.out.println(D.n2);//ok
               //Non-static field 'n1' cannot be referenced from a static context
               //System.out.println(n1);//not
               hi();//ok
               //say();//不能使用，静态不能访问非静态方法
       
       
           }
       }
       

       静态方法只能访问静态成员，非静态的方法，可以访问静态成员和非静态成员。

11. main方法

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

    2. main方法是虚拟机调用

    3. java虚拟机需要调用类的main方法，所以该方法的访问权限必须是public

    4. java虚拟机在执行main（）方法时不必创建对象，所以该方法必须是static

    5. 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数（就是执行java命令时，会传几个参数，正好保存在args数组中）。

    6. java 运行的类名   第一个参数   第二个参数（命令行里的传参方式）

12. 在main方法中，我们可以直接调用main方法所在类的静态方法或静态属性

13. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例化对象后，才能通过这个对象去访问该类中的非静态 成员。

    1. package com.hspedu.main_;
       
       public class Main01 {
           private static String name = "韩顺平教育";
           private int n1 = 100;
           //静态方法
           public static void hi(){
               System.out.println("Main01的 hi方法");
           }
           //非静态方法
           public void cry(){
               System.out.println("Main01的  cry方法");
           }
       
           public static void main(String[] args) {
               //可以直接使用name
               //1.静态方法可以访问本类的静态成员
               System.out.println("name="+name);
               Main01.hi();
               //System.out.println("n1="+n1);//错误，静态方法不能访问非静态成员
       
               //cry();//错误，静态方法不能调用非静态方法
               //要访问本类的非静态成员，要先创建对象
               Main01 main01 = new Main01();
               main01.cry();//ok
               System.out.println(main01.n1);//ok
       
       
       
           }
       }
       

       访问权限问题

14. main动态传参

    1. package com.hspedu.main_;
       
       public class Main02 {
           public static void main(String[] args) {
               for (int i = 0; i < args.length; i++) {
                   System.out.println("args["+i+"]="+args[i]);
               }
           }
       }
       /*
       args[0]=北京
       args[1]=上海
       args[2]=天津
        */
       

    2. 

    这里是在idea里 传参