static 静态关键字

java中，static是一个修饰符，用于修饰类的成员方法、类的成员变量，还可以修饰代码块。被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

静态static关键字修饰成员变量

如果一个成员变量使用了static关键字,那么这个变量不再属于自己,而属于所在的类,多个对象共享一份数据。

public class 学生类 {
    private int id; //学号
    private String name; //姓名
    private int age; //年龄
    static String room; //所在教室
    private static int idCounter=0; //学号计数器，每当new了一个新对象的时候，计数器++

    public 学生类() {
        this.id=++idCounter;
    }

    public 学生类(String name, int age) {
        this.name = name;
        this.age = age;
        this.id=++idCounter;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

接着下一个

public class 修饰成员变量 {
    public static void main(String[] args) {
        学生类 one = new 学生类("郭靖",19);
        one.room="101教室";
        System.out.println("姓名："+one.getName()+",年龄："+one.getAge()+"，教室是"+one.room+",学号是："+one.getId());
        学生类 two = new 学生类("黄蓉",17);
        //只对one里面的room进行赋值，two跟one用的同一个room，因为room所在教室通过了static关键字进行了修饰
        //所以多个对象共享同一个数据
        System.out.println("姓名："+two.getName()+",年龄："+two.getAge()+"，教室是"+two.room+",学号是："+two.getId());
    }
}

静态static关键字修饰成员方法

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。

无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量:类名称.静态变量；
静态方法:类名称.静态方法()；

注意事项:
1.静态不能直接访问非静态。
原因:因为在内存当中是【先】有的静态内容，【后】有的非静态内容。“先人不知道后人，但是后人知道先人。"
2.静态方法当中不能用this。 原因，this代表当前对象，通过谁调用的方法，谁就是当前对象。"

public class 修饰成员方法 {
    int num; //成员变量
    static int num1;//静态变量

    //成员方法
    public void method(){
        System.out.println("这是一个普通的方法");
        System.out.println(num); //成员方法可以访问成员变量
        System.out.println(num1); //成员方法可以访问静态变量
    }

    //静态方法
    public static void methodStatic(){
        System.out.println("这是一个静态方法");
        System.out.println(num1);//静态方法可以访问静态变量
        //System.out.println(num);//静态方法不可以直接访问非静态【重点】
        //System.out.println(this); 静态方法中不能使用this关键字

    }
}

第二个
public class 修饰成员方法2 {
    public static void main(String[] args) {
        修饰成员方法 obj = new 修饰成员方法();
        //首先创建对象，才能使用没有static关键字的内容
        obj.method();

        //对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用
        obj.methodStatic(); //正确，不推荐，这种写法在编译之后也会被翻译成“类名称.静态方法名”
        修饰成员方法.methodStatic(); // 正确 推荐

        //对于本类当中的静态方法，可以省略类名称
        aa();
        修饰成员方法2.aa();//完全等效
    }
    public static void aa(){
        System.out.println("自己的方法");
    }
}

静态代码块

静念代码块的格式是: public class 类名称{ static{ //静态代码块的内容 } }

特点:当第一次用到本类时，静态代码块执行唯一的一次。
静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途: 用来一次性地对静态成员变量进行赋值。

public class 静态代码块1 {
    static {
        System.out.println("静态代码块执行");
    }
    public 静态代码块1(){
        System.out.println("构造方法执行");
    }
}

第二个
public class 静态代码块2 {
    public static void main(String[] args) {
        静态代码块1 one = new 静态代码块1(); //第一次用到那个类时，静态代码块执行唯一一次
        静态代码块1 two = new 静态代码块1(); //静态代码块不执行了，只执行构造方法
    }
}

final 关键字

概述

final关键字代表最终、不可改变的。

常见四种用法:
1.可以用来修饰一个类
2.可以用来修饰一个方法
3.还可以用来修饰一个局部变量
4.还可以用来修饰一个成员变量

final关键字用于修饰类

概述：当final关键字用来修饰一个类的时候。

格式: public final class 类名称{ // ... }

含义:当前这个类不能有任何的子类。(太监类)

注意:一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。
final类可以继承父类，可以重写覆盖父类方法；但他没有子类，那么他的方法不能被覆盖重写。

public final class MyClass {
    public void method(){
        System.out.println("方法执行!");
    }
}

final关键字用于修饰成员方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。

格式:
修饰符 final 返回值类型 方法名称(参数列表){ //方法体 }

注意事项: 对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

public abstract class Fu {
    public final void method(){
        System.out.println("父类方法执行!");
    }

    public abstract /*final*/ void methodAbs() ; 
}



public class zi extends Fu {
    @Override
    public void methodAbs(){
    }
    
    //错误写法!不能覆盖重写父类当中final的方法
    // @Override 
    // public void method(){ 
    // System.outprintln("子类覆盖重写父类的方法!"); 
    //
}

final关键字用于修饰局部变量

public static void main(String[] args){
    int num1=10;
    System.out.println(num1);//10 num1 =20;
    System.out.println(num1);// 20
    //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
    //“一次赋值，终生不变” 
    final int num2=200;
    System.out.println(num2);// 200
    num2=250;//错误写法!不能改变! 
    num2=200; // 错误写法!
    //正确写法!只要保证有唯一一次赋值即可 
    final int num3;
    num3=30;

    //对于基本类型来说，不可变说的是变量当中的数据不可改变
    //对于引用类型来说，不可变说的是变量当中的地址值不可改变 
    Student stu1 = new Student(name:"赵丽颖"); 
    System.outprintln(stu1);
    System.out.println(stu1.getName());//赵丽颖 
    stu1 =new Student(name:"霍建华"); 
    System.out.println(stu1);
    System.out.println(stu1.getName());//霍建华 
    final Student stu2 = new Student(name:"高圆圆");
    //错误写法!final的引用类型变量，其中的地址不可改变
    //stu2=newStudent("赵又廷”);
    System.out.println(stu2.getName());//高圆圆 
    stu2.setName("高圆圆圆圆圆圆");
    System.out.println(stu2.getName());//高圆圆圆圆圆圆
}

public class student {
    private String name;
    
    public Student(){
    }
    
    public Student(String name){
        this.name =name;
    }
    
    public String getName(){
        return name;
    }
    
    public void setName(Stringname){
        this.name =name;
    }
}

final关键字用于修饰成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

public class Person {
    private final String name/*=鹿晗"*/;
    public Person(){
    name ="关晓彤";
    }
    public Person(String name){
        this.name =name;
    }
    public String getName(){
        return name;
    }
    

总结

final关键字
1.1、final修饰的类无法继承。
1.2、final修饰的方法无法覆盖。
1.3、final修饰的变量只能赋一次值。
1.4、final修饰的引用一日指向某个对象，则不能再重新指向其它对象，但该引用指向的对象内部的数据是可以修改的。
1.5、final修饰的实例变量必须手动初始化，不能采用系统默认值。
1.6、final修饰的实例变量一般和static联合使用，称为常量。 public static final doublePI=31415926;