static的特点、访问方式

好多鱼1

已于 2023-10-24 20:54:39 修改

阅读量283

点赞数 2

文章标签： java 开发语言 1024程序员节

于 2023-09-18 20:51:16 首次发布

本文链接：https://blog.csdn.net/sunyu7/article/details/132994506

版权

1. static 修饰成员变量

static修饰分为两种：

类变量：有static修饰属于类会被类的全部对象共享。

实例变量（对象的变量）：无static修饰属于每个对象。

public class Student{
        // 类变量
        static String name;
        // 实例变量
        int age;
}

静态变量是属于类的只需要通过类名就可以调用：类名.静态变量

实例变量是属于对象的，需要通过对象才能调用：对象.实例变量

代码演示：

public class Test{
    public static void main(String[] args){
        // 1.类变量的用法
        // 类名.变量名
        Student.name = "张三";
        System.out.print(Student.name);

        // 2.实例变量的用法    
        // 对象.实例变量
        s1.age = 23;
        s1.age = 18;
        System.out.print(S1.age);

        System.out.print(Student.age);    // 报错
    }    
}

2. static修饰成员方法

static修饰成员方法分为两种：

类方法：有static修饰的成员方法属于类。

实例方法：无static修饰的成员方法属于对象。

代码演示：

public class Student{
    double score;
    
    //类方法：
    public static void printHelloWorld{
        System.out.println("Hello World!");
        System.out.println("Hello World!");
    }
    
    //实例方法（对象的方法）
    public void printPass(){
        //打印成绩是否合格
        System.out.println(score>=60?"成绩合格":"成绩不合格");
    }
}

public class Test2{
    public static void main(String[] args){
        //1.调用Student类中的类方法
        Student.printHelloWorld();
        
        //2.调用Student类中的实例方法
        Student s = new Student();        
        s.printPass();
        
        //使用对象也能调用类方法【不推荐，IDEA连提示都不给你，你就别这么用了】
        s.printHelloWorld();
    }
}

有static修饰的方法，是属于类的，称为类方法；调用时直接用类名调用即可。

无static修饰的方法，是属于对象的，称为实例方法；调用时，需要使用对象调用。

3. static的注意事项

1.类方法中可以直接访问类的成员，不可以直接访问实例成员。

2.实例方法中既可以直接访问类成员，也可以直接访问实例成员。

3.实例方法中可以出现this关键字，类方法中不可以出现this关键字。

public class Student {
    static String schoolName; // 类变量
    double score; // 实例变量

    // 1、类方法中可以直接访问类的成员，不可以直接访问实例成员。
    public static void printHelloWorld(){
        // 注意：同一个类中，访问类成员，可以省略类名不写。
        schoolName = "黑马";
        printHelloWorld2();

        System.out.println(score); // 报错的
        printPass(); // 报错的

        ystem.out.println(this); // 报错的
    }
    
	// 类方法
    public static void printHelloWorld2(){

    }
    
    // 实例方法
    public void printPass2(){

    }
    
    // 实例方法
    // 2、实例方法中既可以直接访问类成员，也可以直接访问实例成员。
    // 3、实例方法中可以出现this关键字，类方法中不可以出现this关键字的
    public void printPass(){
        schoolName = "黑马2"; //对的
        printHelloWorld2(); //对的

        System.out.println(score); //对的
        printPass2(); //对的

        System.out.println(this); //对的
    }
}

4. static应用（代码块）

代码块根据有无static分为静态代码块，实例代码块。

静态代码块

格式：static{}

特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。

作用：完成类的初始化。例如：对类变量的初始化赋值。

public class Student {
    static int number = 80;
    static String schoolName = "黑马";
    // 静态代码块
    static {
        System.out.println("静态代码块执行了~~");
        schoolName = "黑马";
    }
}

静态代码块不需要创建对象就能够执行

public class Test {
    public static void main(String[] args) {
        // 目标：认识两种代码块，了解他们的特点和基本作用。
        System.out.println(Student.number);
        System.out.println(Student.number);
        System.out.println(Student.number);

        System.out.println(Student.schoolName); // 黑马
    }
}

实例代码块

格式：{ }

特点：每次创建对象时，执行实例代码块，并在构造器前执行。

作用：和构造器一样，都是用来完成对象的初始化。例如对实例变量进行初始化赋值。

实例代码块的作用和构造器的作用是一样的，用来给对象初始化值；而且每次创建对象之前都会先执行实例代码块。

public class Student{
    //实例变量
	int age;
    //实例代码块：实例代码块会执行在每一个构造方法之前
    {
        System.out.println("实例代码块执行了~~");
        age = 18;
        System.out.println("有人创建了对象：" + this);
    }

    public Student(){
        System.out.println("无参数构造器执行了~~");
    }

    public Student(String name){
        System.out.println("有参数构造器执行了~~");
    }
}

// 测试
public class Test {
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student("张三");
        System.out.println(s1.age);
        System.out.println(s2.age);
    }
}

5. static应用（单例设计模式）

单例设计模式：

单个实例，保证在整个系统中，当前对象只能有一个实例（只能new一次）。

常见分类：饿汉式，懒汉式

饿汉式：

类在加载后，就已经进行实例化了。

public class Singleton {
    // 2.提供一个私有成员变量 类型为当前类 且需要实例化（在这个地方运行唯一一次new）
    private static Singleton singleton = new Singleton();
    // 1.提供一个【私有】的无参构造（在类的外面不能通过new创建实例）
    private Singleton() {
    }
    // 3.提供一个公共方法 用于 获取唯一实例
    public static Singleton getInstance(){
        return singleton;
    }
}

public class TestSingleton {
    public static void main(String[] args) {
        // 获得单例
        Singleton s1 = Singleton.getInstance();
        Singleton s2 = Singleton.getInstance();

        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 == s2);

        /** 创建Singleton的实例 异常 在Singleton外面不能new 构造私有 */
				// Singleton s3 = new Singleton();
    }
}

懒汉式：

类在加载后没有进行实例化，在需要的时候进行实例化。

public class Singleton {
    //2.提供一个私有的成员变量 类型为当前类
    private static Singleton singleton;
    // 1.提供一个私有的无参构造（在类的外面不能通过new创建实例）
    private Singleton(){}
    //3.提供一个公共方法 如果没有实例 创建一个实例 如果有实例 返回即可
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}