【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工具类
工具类：类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的，这个类用来给系统开发人员共同使用。（同一个功能多处开发，会出现代码重复度过高）
好处：调用方便，提高代码复用（工具类会把这些重复的功能，抽象成静态的方法）
为什么工具类不用实例方法做？
- 实例方法需要创建对象调用
- 此时用对象只是为了调用方法，会浪费内存
由于工具类里面都是静态方法，直接用类名就可以访问，所以，工具类无需创建对象，建议将工具类的构造器进行私有
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
- 子类重写父类方法时，访问权限必须大于等于父类（缺省
- 子类不能重写父类的静态方法，如果写了就会报错
继承后构造器特点
- 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");
}