【大数据】学习笔记 1 Java SE 第5章面向对象基础(上) 5.10 静态

Bertha 。 2024-03-22 11:14 27阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第5章 面向对象基础(上)
             *   *  5.10 静态
                 *   *  5.10.1 静态关键字(static)
                     *  5.10.2 静态变量
                     *  5.10.3 静态方法
                     *  5.10.4 静态和非静态的区别
                     *  5.10.5 静态导入

![在这里插入图片描述][cae404fa10a340ff9ffd43ac9da6af91.png_pic_center]

#### 1 Java SE ####

##### 第5章 面向对象基础(上) #####

###### 5.10 静态 ######

###### 5.10.1 静态关键字(static) ######

在类中声明的实例变量，其值是每一个对象独立的。但是有些成员变量的值不需要或不能每一个对象单独存储一份，即有些成员变量和当前类的对象无关。

在类中声明的实例方法，在类的外面必须要先创建对象，才能调用。但是有些方法的调用和当前类的对象无关，那么创建对象就有点麻烦了。

此时，就需要将和当前类的对象无关的成员变量、成员方法声明为静态的（static）。

###### 5.10.2 静态变量 ######

【1】语法格式

有static修饰的成员变量就是静态变量。

【修饰符】 class 类{
        
    	【其他修饰符】 static 数据类型  静态变量名;
    }

【2】静态变量的特点

*  静态变量的默认值规则和实例变量一样。
 *  静态变量值是**所有对象共享。**
 *  静态变量的值存储在方法区。
 *  静态变量在本类中，可以在任意方法、代码块、构造器中直接使用。
 *  如果权限修饰符允许，在其他类中可以通过“类名.静态变量”直接访问，也可以通过“对象.静态变量”的方式访问（但是更推荐使用类名.静态变量的方式）。
 *  静态变量的get/set方法也静态的，当局部变量与静态变量重名时，使用“类名.静态变量”进行区分。

<table> 
 <thead> 
  <tr> 
   <th>分类</th> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>基本类型</td> 
   <td>整数（byte，short，int，long）</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>浮点数（float，double）</td> 
   <td>0.0</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>字符（char）</td> 
   <td>‘\u0000’</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>布尔（boolean）</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td></td> 
   <td>数据类型</td> 
   <td>默认值</td> 
  </tr> 
  <tr> 
   <td>引用类型</td> 
   <td>数组，类，接口</td> 
   <td>null</td> 
  </tr> 
 </tbody> 
</table>

演示：

package com.dingjiaxiong.keyword;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Employee
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 16:34
     */
    
    public class Employee {
        
        private static int total;//这里私有化，在类的外面必须使用get/set方法的方式来访问静态变量
        static String company; //这里缺省权限修饰符，是为了演示在类外面演示“类名.静态变量”的方式访问
        private int id;
        private String name;
    
        {
        
            //两个构造器的公共代码可以提前到非静态代码块
            total++;
            id = total; //这里使用total静态变量的值为id属性赋值
        }
    
        public Employee() {
        
        }
    
        public Employee(String name) {
        
            this.name = name;
        }
    
        public void setId(int id) {
        
            this.id = id;
        }
    
        public int getId() {
        
            return id;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public static int getTotal() {
        
            return total;
        }
    
        public static void setTotal(int total) {
        
            Employee.total = total;
        }
    
        @Override
        public String toString() {
        
            return "Employee{company = " + company + ",id = " + id + " ,name=" + name + "}";
        }
    }

测试类：

package com.dingjiaxiong.keyword;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestStaticVariable
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 16:35
     */
    
    public class TestStaticVariable {
        
        public static void main(String[] args) {
        
            //静态变量total的默认值是0
            System.out.println("Employee.total = " + Employee.getTotal());
    
            Employee c1 = new Employee("张三");
            Employee c2 = new Employee();
            System.out.println(c1);//静态变量company的默认值是null
            System.out.println(c2);//静态变量company的默认值是null
            System.out.println("Employee.total = " + Employee.getTotal());//静态变量total值是2
    
            Employee.company = "尚硅谷";
            System.out.println(c1);//静态变量company的值是尚硅谷
            System.out.println(c2);//静态变量company的值是尚硅谷
    
            //只要权限修饰符允许,虽然不推荐，但是也可以通过“对象.静态变量”的形式来访问
            c1.company = "超级尚硅谷";
    
            System.out.println(c1);//静态变量company的值是超级尚硅谷
            System.out.println(c2);//静态变量company的值是超级尚硅谷
        }
    }

![在这里插入图片描述][69403ae624ac477e8be7810c57c31ebe.png_pic_center]

【3】静态类变量和非静态实例变量、局部变量

*  静态类变量（简称静态变量）：存储在方法区，有默认值，所有对象共享，生命周期和类相同，还可以有权限修饰符、final等其他修饰符
 *  非静态实例变量（简称实例变量）：存储在堆中，有默认值，每一个对象独立，生命周期每一个对象也独立，还可以有权限修饰符、final等其他修饰符
 *  局部变量：存储在栈中，没有默认值，每一次方法调用都是独立的，有作用域，只能有final修饰，没有其他修饰符

###### 5.10.3 静态方法 ######

【1】语法格式

有static修饰的成员方法就是静态方法。

【修饰符】 class 类{
        
    	【其他修饰符】 static 返回值类型 方法名(形参列表){
        
            方法体
        }
    }

【2】静态方法的特点

*  静态方法在本类的任意方法、代码块、构造器中都可以直接被调用。
 *  只要权限修饰符允许，静态方法在其他类中可以通过“类名.静态方法“的方式调用。也可以通过”对象.静态方法“的方式调用（但是更推荐使用类名.静态方法的方式）。
 *  **静态方法可以被子类继承，但不能被子类重写。**
 *  静态方法的调用都只看编译时类型。

package com.dingjiaxiong.keyword;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Father
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 16:37
     */
    
    public class Father {
        
        public static void method() {
        
            System.out.println("Father.method");
        }
    
        public static void fun() {
        
            System.out.println("Father.fun");
        }
    }

package com.dingjiaxiong.keyword;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Son
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 16:37
     */
    
    public class Son extends Father {
        
        //    @Override //尝试重写静态方法，加上@Override编译报错，去掉Override不报错，但是也不是重写
        public static void fun() {
        
            System.out.println("Son.fun");
        }
    }

测试类

package com.dingjiaxiong.keyword;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestStaticMethod
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 16:38
     */
    
    public class TestStaticMethod {
        
        public static void main(String[] args) {
        
            Father.method();
            Son.method();//继承静态方法
    
            Father f = new Son();
            f.method();//执行Father类中的method
        }
    }

![在这里插入图片描述][0381113be31a441e9d2ae74d13af325b.png_pic_center]

###### 5.10.4 静态和非静态的区别 ######

【1】本类中的访问限制区别

静态的类变量和静态的方法可以在本类的任意方法、代码块、构造器中直接访问。

非静态的实例变量和非静态的方法只能在本类的非静态的方法、非静态代码块、构造器中直接访问。

即：

*  静态直接访问静态，可以
 *  非静态直接访问非静态，可以
 *  非静态直接访问静态，可以
 *  静态直接访问非静态，不可以

【2】在其他类的访问方式区别

静态的类变量和静态的方法可以通过“类名.”的方式直接访问；也可以通过“对象.“的方式访问。（但是更推荐使用==”类名.”==的方式）

非静态的实例变量和非静态的方法只能通过“对象."方式访问。

【3】this和super的使用

静态的方法和静态的代码块中，不允许出现this和super关键字，如果有重名问题，使用“类名.”进行区别。

非静态的方法和非静态的代码块中，可以使用this和super关键字。

###### 5.10.5 静态导入 ######

如果大量使用另一个类的静态成员，可以使用静态导入，简化代码。

import static 包.类名.静态成员名;
    import static 包.类名.*;

演示：

package com.dingjiaxiong.keyword;
    
    import static java.lang.Math.*;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestStaticImport
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 16:42
     */
    
    public class TestStaticImport {
        
        public static void main(String[] args) {
        
            //使用Math类的静态成员
            System.out.println(Math.PI);
            System.out.println(Math.sqrt(9));
            System.out.println(Math.random());
    
            System.out.println("----------------------------");
            System.out.println(PI);
            System.out.println(sqrt(9));
            System.out.println(random());
        }
    }

![在这里插入图片描述][9ab24c4474a544bca8b798606d61ee2d.png_pic_center]

[cae404fa10a340ff9ffd43ac9da6af91.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/4385d32df9224344a549c050c543fe38.png
[69403ae624ac477e8be7810c57c31ebe.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/adfefc9f7c9640fc9e2273f00e6154d4.png
[0381113be31a441e9d2ae74d13af325b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/8058cdd1a7e24039abe2d5bacd0e6675.png
[9ab24c4474a544bca8b798606d61ee2d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9310a6017823448497fe7c7e3f435bd4.png