static关键字，代码块，Math类的使用，成员变量和静态变量的区别

static关键字：

1. static修饰成员变量或者成员方法。

   • 修饰格式：权限修饰符 static 变量名

2. static关键字的特点：

   • 随着类的加载而加载，
   • 优先于对象存在，
   • 被static修饰之后的变量被类的所有对象所共享。

3. 对于静态所修饰的成员属于类，推荐使用类名调用（类名.成员名）。new出来对象可以调用，但是不推荐。

4. 静态修饰成员注意事项：

   • 静态方法中访问不到非静态，只能访问静态修饰的成员。

     • 静态修饰的成员随着类的加载而加载，优先于对象存在，先存在的访问不到后存在的（非静态的对象还没有，所以静态方法访问不到

   • 非静态的方法中：既可以调用非静态方法，也可以调用静态方法

   • 静态方法中不能出现this关键字

     • this代表调用方法的对象，对象是后来才有的，静态优先对象存在。

   • 主方法是静态修饰的，所以调用时，可以调用用静态变量和方法，非静态的需要先创建对象，通过对象调用。

     示例：

     public class Test3 {
              
         public static void main(String[] args) {
              
             Teacher te = new Teacher();
             te.age=20;
             te.name="老李";
             Teacher te2=new Teacher(34);
             te2.name="老赵";
             System.out.println(te.name);
             System.out.println(Teacher.name);
             System.out.println(te.age);
             System.out.println(te2.name);
             System.out.println(Teacher.name);
             System.out.println(te2.age);
         }
     }
     class Teacher{
              
     //    private static String name="老王";
         public static String name="老王";
         public int age;
     
         public Teacher() {
              
         }
     
         public Teacher(int age) {
              
             this.age = age;
         }
     }
     

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

1. 成员变量：
   • 属于对象，随着对象的创建而产生，
   • 也称为实例变量（对象变量）
   • 存储在堆内存
   • 通过对象来调用
2. 静态变量：
   • 属于类，随着类的加载而产生
   • 也叫做内变量
   • 存储在方法区的静态区
   • 通过类名调用（也可以通过对象调用，不推荐）

static内存图

特点：静态变量存放在方法区的静态区，不管创建几个对象，静态变量只有一个，所有成员共享它。

Math类的使用：

1. Math类是Java给提供的一个类，包含一些基本的数学匀运算方法。

2. Math在Java.lang 包下，所以在使用时不用导包。

3. 没有构造方法，因为Math的成员都是静态的，直接用类名.方法名调用，所以也不用创建对象。

   示例：随机获取数字(猜数字游戏)

   import java.util.Scanner;
   
   public class Test {
          
       public static void main(String[] args) {
          
           Scanner sc = new Scanner(System.in);
           int f1 = (int) (Math.random() * 100) + 1;
           System.out.println("你一共有五次机会");
           int fr = 4;
           for (int i = 0; i < 5; i++) {
          
               System.out.println("请输入1--100之间的数");
               int num = sc.nextInt();
               if (f1 == num) {
          
                   System.out.println("你猜对了");
                   break;
               } else if (num > f1) {
          
                   System.out.println("你输入的数大了");
               } else {
          
                   System.out.println("你输入的数小了");
               }
               if ((cishu-i)!=0) {
          
                   System.out.println("你还有" + (fr - i) + "次机会");
               } else {
          
                   System.out.println("游戏结束");
               }
           }
       }
   }
   

代码块：

1. 代码块：就是被一对大括号括起来的内容
2. 代码块根据位置不同分为：
   • 局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率。
   • 构造代码块：在类中方法外。
     • 创建对象时，构造代码块和构造方法执行 ，并且在构造方法之前执行。
   • 静态代码块（常用）:在类中方法外，加了static修饰。
     • 在类的加载的时候执行，用于给类进行初始化，并且只执行一次。
     • 常常在类加载的时候在静态代码块中写准备工作的代码。
     • 只有JVM才能调用。

示例：
public class Test4 {
     
    public static void main(String[] args) {
     
        System.out.println("我是main方法");
        Student s1 = new Student();
        Student s2 = new Student();
    }
}
class Student {
     
//    静态代码块只执行一次.在类加载时执行
    static {
     
        System.out.println("Student1 静态代码块");
    }

    {
     
        System.out.println("Student2 构造代码块");
    }

    public Student() {
     

        System.out.println("Student3 构造方法");
        {
     
            System.out.println("我是局部代码块");
        }
    }
 构造代码块");
    }

    public Student() {
     

        System.out.println("Student3 构造方法");
        {
     
            System.out.println("我是局部代码块");
        }
    }