Java基础语法(九)

class类修饰 - static

static 称为静态,可以用来修饰属性或者方法。

如果属性或者方法的前面加上了static,那么属性或者方法就变成了静态属性或者静态方法。

一般来说,属于实例对象的属性或者方法属于每个类实例化产生的实例化对象,因为每个对象在堆内存中相互独立,所以一个对象身上的属性或者方法与其他对象的属性或者方法也独立于彼此。

当给属性或者方法的身上加上static修饰之后,这个属性和方法将不再属于实例化对象而是属于类本身。

所有的通过类实例化得到的对象都可以通过类本身使用静态属性或者方法。

image.png

例如:

public class Student {
    public String name;
    public int age;
    static String info = "测试静态属性";
}

使用这个类:

public class Demo1 {
    public static void main(String[] args) {
        Student s1 = new Student();
        // 属于对象的属性可以通过对象.属性来操作
        s1.name = "张三";
        s1.age = 20;
        System.out.println(s1.name + " -- " + s1.age); // 张三 -- 20
        // 静态属性可以通过类来进行访问
        System.out.println(Student.info); // 测试静态属性
    }
}

image.png

在上图中,可以通过实例对象.静态属性的方式访问和修改,之所以可以这样做,是因为实例对象在堆中,除了存储对象属性和方法以外,还存储了类的地址,当访问一个静态属性时就会立刻通过类的地址访问类中的静态属性,从而对静态属性或者方法进行操作。

类变量(静态属性)的应用场景

在开发中,如果某个数据只需要一份,且希望能够被共享(访问、修改),则该数据可以定义 成类变量来记住。

例如:

public class Count {

    public static int num;

    public Count() {
        // 每一次实例化的时候,都会执行这个Count构造器,构造器每次执行都会让num静态属性递增
        // Count.num++;
        // 如果使用的是自身类的静态属性,也可以直接调用,而不需要加类名
        num++;//和上面的Count.num++等同
    }
}

操作Count类:

public static void main(String[] args) {
    Count c = new Count();
    new Count();
    new Count();
    System.out.println(Count.num); // 3
}

使用类方法和实例方法时需要注意:

  • 类方法(静态方法)可以直接访问类的成员,不可以直接访问实例成员。
  • 实例方法中既可以直接访问类成员,也可以直接方法实例成员。
  • 实例方法中可以出现this关键字,类方法中不能出现this关键字。

代码块

image.png

代码块无论是静态代码块还是实例代码块,都相当于是在类当中加上一段自动执行的代码,执行的时机还在构造器之上。

在代码块中可以执行对属性的初始化,也可以进行一些其他操作,但是这种操作在开发中使用频率较低。

单例设计模式

所谓的单例设计模式,指的是确保一个类只能有一个对象。

实现单例模式的写法:

  • 把类的构造器私有
  • 定义一个类变量记录类的一个对象
  • 定义一个类方法,返回对象

例如:

public class Single {
    private static Single obj = new Single();

    private Single() {}

    public static Single getSingle() {
        return obj;
    }
}

使用方式如下:

public class Demo4 {
    public static void main(String[] args) {
        Single obj1 = Single.getSingle();
        Single obj2 = Single.getSingle();
        System.out.println(obj1 == obj2); // true
    }
}

上面这种写法叫做饿汉式单例模式,表示的是当调用方法获取类实例时,类实例已经创建成功了。

除了上面说的饿汉式单例模式外,还有一种单例模式,就是懒汉式单例模式,指的是在类第一次执行的时候才去获取实例化对象,后续获取则根据类中是否已经存储了实例化对象,如果没有存储则进行实例化,否则返回已经实例化好的对象。

懒汉式单例的写法:

  • 把类的构造器私有
  • 定义一个类变量用来存储对象
  • 提供一个方法,保证返回的是同一个对象

例如:

public class Single2 {
    // 懒汉式单例模式
    private static Single2 obj;

    private Single2() {}

    public static Single2 getInstance() {
        if (obj == null) {
            obj = new Single2();
        }
        return obj;
    }
}

使用代码如下:

public static void main(String[] args) {
    Single2 obj = Single2.getInstance();
    Single2 obj2 =Single2.getInstance();

    System.out.println(obj == obj2); // true
}
如果单例模式使用频率频繁,建议使用饿汉式单例,如果使用频率不高,可以使用懒汉式单例。

继承

Java中提供了一个关键字extends, 利用这个关键字,可以让一个类和另外一个类建立起父子关系。

继承之后,子类能够继承父类的非私有成员(成员变量、成员方法)。同时在使用继承后要注意,子类的对象是由子类和父类共同完成的。

public class Human {
    public String name;
    public int age;
    private String info; // 私有化的属性,子类无法调用

    public void say() {
        System.out.println("你好");
    }
}

public class Student extends Human{
    public String grade;

    public void run() {
        // System.out.println(info); // info为父类私有化属性,无法直接访问
        System.out.println("运动");
    }
}

使用子类进行实例化:

public class Demo1 {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.run(); // 调用自身的方法
        s1.say(); // 调用父类的方法
    }
}

评论

暂无评论