【JAVA】static、工具类、代码块、单例、继承

1 static修饰成员变量

• static是静态的意思，可以修饰成员变量和成员方法
• static修饰成员变量表示该成员变量只在内存中存储一份，可以被共享访问、修改

• 静态成员变量（有static修饰，属于类，内存中只加载一次）常表示需要被共享的信息，可以被共享访问（信息需要共享，只需要一份的时候使用）

public class Student{
    //静态成员变量
    public static String name="ABC";
    //实例成员变量
    private int age;

}

//访问静态成员变量
//类名.静态成员变量（推荐）
String name = Student.name;
// 也可以通过对象.静态成员变量（不推荐）
Student stu = new Student();
String n1 = stu.name;

• 实例成员变量（无static修饰，属于对象）：常表示姓名name、年龄等属于每个对象的信息

//实例成员变量的引用
//对象名.实例成员变量
Student s = new Student();
s.age = 1;

• 同一个类中，静态成员的访问可以省略类名
• 两种成员变量各自在什么情况下定义

静态成员变量	表示在线人数等需要被共享的信息
实例成员变量	属于每个成员，且每个成员的该信息不同时，如姓名，年龄等

2 static修饰成员方法

• 成员方法分类

静态成员方法	有static修饰，类和对象共享	建议用类名访问（推荐），也可以用对象访问（但不推荐）
实例成员方法	无static修饰，归属于对象	只能用对象触发访问

• 表示对象自己的行为的，且方法中需要直接访问实例成员，则该方法必须声明成实例方法
• 如果该方法时以执行一个通用功能为目的，或者需要方便访问，则可以声明为静态方法

• 静态成员方法

public class Student {
    // 实例成员变量，无static修饰，属于对象
    private int age;
    private String name;

    // 静态成员方法
    // 有static修饰，归属于子类，可以被共享访问，用类名或对象名都可以访问
    public static int getMax(int age1, int age2){
        return age1 > age2 ? age1 : age2;
    }
}

public static void main(String[] args) {
        // 静态成员方法的访问：类名.静态成员方法
        System.out.println(Student.getMax(18, 23));
        // 也可以对象.静态成员方法访问(但不推荐）
        Student stu = new Student();
        System.out.println(stu.getMax(18, 23));
    }

• 实例成员方法

public class Student {
    // 实例成员变量，无static修饰，属于对象
    private int age;
    private String name;

    // 实例方法，只能用对象触发访问
    public void study(){
        // 实例方法可以直接访问当前实例变量，因为实例方法也是属于对象
        System.out.println(name);
    }
}

public static void main(String[] args) {
        // 实例方法访问：对象.实例方法
        Student stu = new Student();
        stu.name = "ABC";
        stu.study();
    }

3 static其它知识点

• 静态方法只能访问静态的成员，不能直接访问实例成员（因为静态成员属于类，都可以共享，实例成员属于对象，必须用对象触发）
• 实例方法可以访问静态成员，也可以访问实例成员（静态成员可以共享，实例成员和实例方法都属于对象），也可出现this关键字（实例方法是对象调用的）
• 静态方法中是不可以出现this关键字（因为this关键字代表当前对象，静态方法可能不是用对象调用）

4 static工具类

工具类：类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用。（同一个功能多处开发，会出现代码重复度过高）

好处：调用方便，提高代码复用（工具类会把这些重复的功能，抽象成静态的方法）

为什么工具类不用实例方法做？

1. 实例方法需要创建对象调用
2. 此时用对象只是为了调用方法，会浪费内存

由于工具类里面都是静态方法，直接用类名就可以访问，所以，工具类无需创建对象，建议将工具类的构造器进行私有

public static Util{
    //将构造器设置为私有
    private Util(){
    }
    // 静态方法
    public static String createVerifyCode(int n){
        return n
    }
}

访问工具类，无需创造对象 

public static void main(String[] args) {
        
        System.out.println(Util.createVerifyCode(6);
}

5 代码块

• 代码块是类的五大成分之一（成员变量、构造器、方法、代码块、内部类），定义在类中方法外
• 在java类下，使用放在类中单独{}括起来的代码称为代码块

代码块	格式	特点	作用
静态代码块	static{}	需要通过static关键字修饰，随着类的加载而加载，并且自动触发，只执行一次	在类加载的时候做一些静态数据初始化的操作，以便后续使用
构造代码块	{}	每次创建对象调用构造器执行时，都会执行该代码块中的代码，并且在构造器执行前执行	初始化实例资源

6 单例设计模式

设计模式：开发中经常遇到一些问题，一个问题通常有n种解法，但其中肯定有一种是最优解，这个最优解被人总结出来，成为设计模式

• 设计模式共有20多种，对应20多种软件来发中会遇到的问题
• 学设计模式需要明白这种模式用来解决什么问题？遇到这种问题该模式怎么写？和如何解决这个问题

单例模式：可以保证系统中应用这种模式的这个类永远只有一个实例，即一个类永远只能创建一个对象

• 例如，任务管理器对象，只需要一个任务管理器就可以解决问题，这样可以节省内存空间
• 饿汉单例：在类获取对象时，对象已经提前创建好（速度更快，内存有点浪费）
• 懒汉单例：在真正需要该对象的时候，才会去创建一个对象（延迟加载对象）（更节省内存）

饿汉单例

设计步骤：

• 定义一个类，把构造器私有
• 定义一个静态变量（静态变量只加载一次）存储一个对象

public class SingleInstance {
    // 2 饿汉单例获取对象，对象已经提前准备好
    // 因为对象只能是一个，所以定义静态成员变量，因为静态成员变量只会加载一次
    public static SingleInstance ins = new SingleInstance();
    // 1 把构造器私有化
    private SingleInstance(){

    }
}

public static void main(String[] args) {
        SingleInstance si = SingleInstance.ins;
        SingleInstance si2 = SingleInstance.ins;
        System.out.println(si == si2);//true,两个拿的是同一个地址

    }

懒汉单例

设计步骤：

• 定义一个类，把构造器私有
• 定义一个静态变量存储一个对象
• 提供一个返回单例对象的方法

public class SingleInstance {
    // 2 定义一个静态成员变量负责一个对象，只加载一次，内存只有一份
    // ！！！！！！不能new，只能等到用的时候才能new
    //public static SingleInstance ins = new SingleInstance();
    // 不能用public，因为用的时候会出现null
    private static SingleInstance inst;
    // 3 提供一个方法，对外返回单例对象
    public static SingleInstance getInstance(){
        if (inst == null){
            inst = new SingleInstance();
        }
        return inst;
    }
    // 1 把构造器私有化
    private SingleInstance(){

    }
}

public static void main(String[] args) {
        SingleInstance si = SingleInstance.getInstance();
        SingleInstance si2 = SingleInstance.getInstance();
        System.out.println(si == si2);//true,两个拿的是同一个地址
    }

7 继承

java中提供一个关键字extends，用这个关键字，可以让一个类与另一个类建立起父子关系

// Student称为子类，People称为父类
public class Student extends People{}

• 子类继承父类后，可以直接使用父类公共的属性和方法
• 子类们相同的特征（共性属性、共性方法）放在父类中定义，子类独有的属性和行为应该定义在子类自己里面。
• 好处：提高代码的复用性，减少代码冗余，增强类的功能扩展性

• 子类可以继承父类的私有成员，但是不能直接访问
• 子类可以访问父类的静态成员，只是共享，不算继承
• 子类可以继承父类的属性和行为，但子类不能继承父类的构造器
• 不支持多继承，可以多层继承
• java中所有类，要么直接继承Object类，要么默认继承Object类，要么间接继承Object类，Object是祖宗类

继承后访问成员

子类方法访问成员方法、成员变量：就近原则，先子类局部范围找，然后在子类成员范围找，最后父类成员范围找，如果父类范围没有找到则报错

• 如果子父类中，出现了重名的成员，会优先使用子类的，若一定要在子类中使用父类成员，可以通过super关键字

// 访问子类中局部的name
String na = name;
// 访问子类对象的name
String name = this.name;
// 访问父类name
String name1 = super.name;

方法重写

在继承体系中，子类出现了和父类中一模一样的方法声明，则称子类的这个方法是重写的方法

重写注解：@Override

• 子类重写父类方法时，访问权限必须大于等于父类（缺省<protected<public）
• 子类不能重写父类的静态方法，如果写了就会报错

继承后构造器特点

• super调用父类构造器的作用：通过调用父类有参构造器来出的实话继承自父类的数据
• 子类所有的构造器默认都会先访问父类中无参构造器，再执行自己

super();

• super调用父类有参构造器作用：初始化继承子父类的数据

super(x,y);

• 如果父类没有无参构造器，子类会报错，因为子类默认调用父类无参构造器

this、super使用总结

• 子类通过this(...)去调用本类的其它构造器，被雷其它构造器会通过super去手动调用父类的构造器，最终还是会调用父类构造器
• this(...)super(...)都只能放在构造器的第一行，所以二者不能共存在一个构造器中

关键字	访问成员变量	访问成员方法	访问构造方法
this访问本类成员	this.成员变量	this.成员方法(...)	this(...)访问本类兄弟构造器
super访问父类成员	super.成员变量	super.成员方法(...)	super(...)访问父类构造器

 this访问本类构造器

public student(String name){
        this(name, 18);
    }    
    public student(String name, String age){
        this.name = name;
        this.age = age;
    }

public static void main(String[] args) {
        student stu1 = new student("A", 12);
        // 这时候年龄就为18了
        student stu2 = new student("B");

    }