Java：static关键字，this关键字

﹏ヽ暗。殇╰゛Y 2023-10-14 09:02 31阅读 0赞

## static关键字 ##

static翻译为“静态的”。  
所有static关键字修饰的都是类相关的，类级别的。  
所有static修饰的，都是采用“类名.”的方式访问。  
static修饰的变量：静态变量  
static修饰的方法：静态方法  
变量根据声明的位置进行划分：  
在方法体当中声明的变量叫做：局部变量。  
在方法体外声明的变量叫做：成员变量。  
成员变量又可以分为：实例变量和静态变量  
静态的都是类相关的，访问时采用“类名.”的方式访问。不需要new对象。  
不需要对象的残血即可访问，没有空指针异常的发生。  
实例相关的，必须先有对象，才能访问，可能会出现空指针异常。  
静态变量在类加载时初始化，不需要new对象，静态变量的空间开出来了。  
静态变量存储在方法区。

![7cd880774351420199544c31eabfb999.webp][]

**什么时候变量声明为实例的，什么时候声明为静态的？**  
如果这个类型的所有对象的某个属性值都是一样的，不建议定义为实例变量，浪费内存空间。建议定义为类级别特征，定义为静态变量，在方法区中只保留一份，节省内存开销。  
一个对象一份的是实例变量。  
所有对象一份的是静态变量。  
实例的：一定需要使用“引用.”来访问。  
静态的：建议使用“类名.”来访问，但使用“引用.”也行（不建议使用“引用.”）。  
静态的如果使用“引用.”来访问会让程序员产生困惑：程序员以为是实例的呢。  
空指针异常只有在“空引用”访问“实例”相关的，都会出现空指针异常。  
**关于方法来说，什么时候定义为实例方法，什么时候定义为静态方法？**  
此方法一般都是描述了一个行为，如果说该行为必须由对象去触发。那么该方法定义为实例方法。  
参考标准：  
当这个方法体当中，直接访问了实例变量，这个方法一定是实例方法。  
我们以后开发中，大部分情况下，如果是工具类的话，工具类当中的方法一般都是静态的。（静态方法有一个优点，是不需要new对象，直接采用类名调用，极其方便，工具类就是为了方便，所以工具类中的方法一般都是static的。）  
工具类就是为了方便编程开发的一些类。

### 静态代码块 ###

使用static关键字可以定义：静态代码块  
静态代码块，语法：  
static \{  
java语句;  
java语句;  
\}  
static静态代码块在类加载时执行，并且只执行一次，静态代码块有这样的特征/特点。  
注意：静态代码块在类加载时执行，并且在main方法之前执行。  
静态代码块一般是按照自上而下的顺序。  
**静态代码块有什么用？**  
第一：静态代码块不是那么常用 。（不是每一个类当中都要写的东西。）  
第二：静态代码块这种语法机制实际上时SUN公司给我们java程序员的一个特殊的事课/时机。  
这个时机叫做：类加载时机。  
静态代码块和静态变量都是在类加载的时候执行的，时间相同，执行的顺序还是要看代码的先后顺序来决定谁先谁后。  
**到目前为止，遇到的所有的java程序，有哪些是有顺序要求的？**  
第一：对于一个方法来说，方法体中的代码是有顺序的，遵循自上而下的顺序执行。  
第二：静态代码块1和静态代码块2是由先后顺序的。  
第三：静态代码块和静态变量是有先后顺序的。

## 实例代码块 ##

除了静态代码块之外，还有实例语句块。  
实例语句块在类加载时并没有执行。  
实例语句块语法：  
\{  
java语句;  
java语句;  
\}  
只要是构造方法执行没必然在构造方法执行之前，自动执行“实例语句块”中的代码。  
实际上这也是SUN公司为Java程序员准备一个特殊的时机，叫做对象构建时机。

## this关键字 ##

this是一个关键字，全部小写。是一个引用，保存内存地址指向自身。  
一个对象一个this。  
this是一个变量，是一个引用。this保存当前对象的内存地址，指向自身。  
所以，严格意义上来说，this代表的就是“当前对象”  
this存储在堆内存当中对象的内部。

![format_png][]

this只能使用在实例方法中。谁调用这个实例方法，this就是谁。所以this代表 的是当前对象。  
“this.”在大部分情况下是可以省略的。  
this可以使用在实例方法中，不能使用在静态方法中，因为，this代表当前对象，静态方法中不存在当前对象。  
在实例方法中，或者构造方法中，为了区分局部变量和实例变量，这种情况下：this. 是不能省略的。  
this除了可以使用在实例方法中，也可以使用在构造方法中。  
新语法：通过当前的构造方法去调用零一个本类的构造方法，可以使用以下格式：  
this(实际参数列表);  
this();的作用是，代码复用  
通过一个构造方法1去调用构造方法2，可以做到代码复用。  
但需要注意的是：“构造方法1”和“构造方法2”都是在同一个类中 。  
对于this()的调用只能出现在构造方法的第一行。

**以后的代码都是封装，所有的类都是属性私有化，对外提供setter和getter方法。**  
**构造方法无参数构造方法和有参数构造方法都定义。**

## 对面向对象这的内容做一下总结： ##

/*
        到目前为止一个类当中可以出现的：
        类体{
            实例变量;
            实例方法;
    
            静态变量;
            静态方法;
    
            构造方法;
    
            静态代码块;
            实力语句块;
    
            方法(){
                局部变量
            }
        }
    */
    public class ZongJie{
        //类加载机制中，是这样的：在程序执行之前，凡是需要加载的类全部加载到JVM当中。
        //先完成加载才会执行main方法。
        static{
            System.out.println("ZongJie类加载时执行！");
        }
        //入口
        //静态方法
        public static void main(String[] args){
            //局部变量
            int i = 100;
    
            //完成一个对象的一连串动作。
            //一个学生在教室先学习，学习完成后去餐厅吃饭。
            Student s1 = new Student();
    
            //先学习，所以调用学习这个实例方法。
            s1.study();
    
            Student s2 = new Student();
        }
    }
    
    //学生类
    class Student{
        //静态代码块
        static{
            System.out.printlc("Student类加载时执行！");
        }
    
        //学号
        private int no;//实例变量
        //姓名
        private String name;//实例变量
        //静态变量 类级别的谁能够
        static String job = "学习";
    
        //实例语句块
        {
            System.out.println("实例语句块，构造方法执行一次，这里就执行一次！");
        }
    
        //构造方法
        //无参数构造方法
        public Student(){
            //假设调用无参数的构造方法，默认创建的学生学号是100，名字是张三
            this(100,"张三");//这里使用了this()
        }
        //有参数构造方法
        public Student(int no,String name){
            this.no = no;
            this name = name;
        }
    
        //封装
        //setter and getter 方法
        public void setName(String name){
            this.name = name;
        }
        public String getName(String name){
            return name;
        }
        public void setNo(int no){
            this.no = no;
        }
        public int getNo(int no){
            return no;
        }
    
        //提供两个实例方法
        public void study(){
            //私有的是可以在本类中访问的。在其他类中必须使用set和get方法。
            //System.out.println(this.name + "正在努力学习！");
            //System.out.println(name + "正在努力学习！");
    
            //在实例方法中调用本类的其他实例方法
            System.out.println(this.getName() + "正在努力学习！");
            //System.out.println(getName + "正在努力学习！");
    
            //方法执行到此处表示学习完成了，接下来去吃饭。
            //this.eat();
            //this. 可以省略
            //编译器检测到eat()方法是实例方法，会自动在eat()方法前添加this.
            eat();
        }
    
        public vodi eat(){//实例方法
            System.out.println(this.getName() + "在餐厅吃饭呢！");
    
            //调用静态m1()方法
            //静态方法使用“类名.”的方式访问
            //Student. m1()
    
            //类名. 可以省略么？可以
            //java编译器会自动在m1()方法之前加“类名.”，因为检测到m1()方法是一个静态方法
            m1();
        }
    
        //提供两个静态方法
        public static void mi(){
            System.out.println("Student's m1 method execute!");
            //调用m2方法
            //Student.m2();
            m2();
        }
        public static vodi m2(){
            System.out.println("Student's m2 method execute!");
            System.out.println("工作性质：" + job);
            //编译器检测到job是一个静态变量，所以这里会自动在job前添加：Student.
            //System.out.println("工作性质：" + Student.job);
        }
    
    
    }

程序再怎么变化，万变不离其宗，有一个固定的规律：  
所有的实力相关的都是先创建对象，通过“引用.”来访问。  
所有的静态相关的都是直接采用“类名.”来访问。

只要负责调用的方法a和被调用的方法b在同一个类当中：  
this. 可以省略  
类名. 可以省略

[7cd880774351420199544c31eabfb999.webp]: https://img-blog.csdnimg.cn/7cd880774351420199544c31eabfb999.webp
[format_png]: https://img-blog.csdnimg.cn/img_convert/cd4abce4b27bf8f318735338e2452e43.webp?x-oss-process=image/format,png