Java SE static，final关键字及继承的使用

Static关键字

static 关键字 : 修饰符, 可以修饰成员变量, 成员方法

static 成员变量：共享数据

static 成员方法：常用于工具类

特点:

      1. 被类的所有对象所共享
      2. 多了一种调用方式, 可以通过类名进行调用 (推荐使用类名调用)
      3. 随着类的加载而加载, 优先于对象存在

内存图示意：

解释：new创建对象的堆内存地址中会链接到静态成员变量区，这样调用该对象时就可以使用 static 成员变量了。

注意事项：

static 方法中, 只能访问静态成员 (直接访问)
static 中不允许使用 this 关键字

原因：static是在代码加载时就生成了，不需要生成对象再使用。所以static方法中无法调用还没生成对象的非静态成员，同样this关键字是属于对象的，没创建对象前无法使用。

static 成员方法

成员方法什么时候加入 static
- 常用于制作工具类
工具类: 用来实现某种功能，而不是描述事物的类
如果一个类中的所有方法都是 static 所修饰的

则——私有该类的构造方法 目的 : 为了不让其他类再创建该类对象，如 System类

示例：ArrayTools用来做数组的操作，这里仅写了一个求最大值的。

public class ArrayTools {
    private ArrayTools(){}   //私有构造方法
    
    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        return max;
    }
// 主方法中调用ArrayTools.printArray(arr);

main 方法详细分析

1
2
3

public static void main(String[] args) {
	System.out.println("HelloWorld");
}

public：被JVM调用，访问权限足够大
static：被JVM调用，不用创建对象

注：因为main方法是静态的，故测试类中其他方法也需要是静态的
void：被JVM调用，不需要给JVM返回值
main：一个通用的名称，虽然不是关键字，但是被JVM识别
String[] args: 以前用于接收键盘录入数据的，现在无作用

继承

继承：让类与类之间产生关系（子父类关系），子类可以直接使用父类中非私有的成员；[私有成员变量通过调用公有方法使用，get()，set()]

格式：public class 子类名 extends 父类名 { }

使用时机：当类与类之间，存在相同 (共性) 的内容，并且产生了 is a 的关系，就可以考虑使用继承，来优化代码。

方法重写

子父类中, 出现了方法声明一模一样的方法 (方法名, 参数, 返回值)

在创建子类对象, 调用方法的时候, 会优先使用子类的方法逻辑
这虽然是就近原则的现象, 但其实是子类的方法, 对父类的方法, 进行了重写操作

使用场景:

当子类需要父类的方法, 但父类的方法逻辑不合适 (需要进行修改 | 增强) 就需要对父类的方法进行重写

this，super的使用

public class Fu {
	int num = 10;
}

class Zi extends Fu {
	int num = 20;
	public void method(){
		int num = 30;
		System.out.println( num  );           // 30    
        System.out.println( this.num );       // 20        
        System.out.println( super.num );      // 10    
	}
}

子类重写父类方法，需要保证方法声明完全一致（方法名，参数，返回值类型需要保持一致）

@Override：识别出方法是不是重写的

方法重载 & 方法重写比较

方法重载(Overload) : 在同一个类中, 方法名相同, 参数不同(类型不同, 个数不同, 顺序不同), 与返回值无关
方法重写(Override) : 在子父类当中, 出现了方法声明一模一样的方法 (方法名, 参数, 返回值)

注意事项

父类中私有方法不能被重写
子类重写父类方法时，访问权限必须大于等于父类

private[最高]
(default)
protected
public

protected详述：

public class Fu {
    protected void show(){
        System.out.println("fu");
    }
}

import ***.Fu;
/*
    和Fu是不同包的
 */
public class Zi extends Fu {
    public void method(){
        super.show();     //用super调用Fu中的protected方法
    }
}

/*
    Zi类 和 Test类是同包下的
 */
public class Test {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();      //通过调用method()方法，间接调用show()，很麻烦，通常不用
    }
}

继承的特点

Java只支持单继承，不支持多继承，但支持多层继承

解释：

如果是多继承：若父类A,B有相同的方法，子类C不知道调用哪个；

多层继承：有方法重写的机制，继承只有一个，是唯一的；可以实现类似”爷-父-子”的多级继承关系；

构造方法

不能被继承：构造方法要和类名保持一致，继承下来父类的构造方法名不匹配；

子类初始化之前，要先完成

特点：

除了Object类（最顶层的类）, 在所有构造方法的第一行代码, 都默认隐藏了一句代码——super();
// 通过这句代码, 访问父类的空参数构造方法

总结： Java当中所有的类, 都直接或者间接的继承到了 Object 类

1
2
3

public A() {
    super();
}

具体案例实现

需求:
Person：姓名, 年龄

Teacher: 姓名, 年龄, teach()

Student: 姓名, 年龄, 成绩,study()

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Teacher extends Person {

    public Teacher() {
    }

    public Teacher(String name, int age) {
        super(name, age);   //重点：super调用父类
    }

    public void teach() {
        System.out.println("姓名：" + super.getName() + ", 年龄：" + super.getAge());
    }
}

public class Student extends Person {

    private double score;

    public Student() {
    }

    public Student(String name, int age, double score) {
        super(name, age);     //重点：super调用父类
        this.score = score;   // 初始私有成员变量
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public void study() {
        System.out.println("姓名：" + super.getName() + ", 年龄：" + super.getAge() + "岁, 成绩：" + score );
    }
}

上述代码的堆内存中的存储情况：

new一个Student对象时，会同时又父类Person(super)，存放其成员变量；

父类的私有成员变量其实是继承到的，只是不能直接访问

this，super

this：代表本类对象的引用
super：代表父类存储空间的标识

super 调用父类成员的省略规则 :

super.父类成员变量 | super.父类成员方法() <实际上，是this的使用可以省略，子类继承父类的这些变量/方法>

-> 被调用的变量和方法, 在子类中不存在, super.可以直接省略的

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

注意：this() 和 super() 都在争夺构造方法第一行的位置 —> 二者不能共存;

IDEA中的提示：’super()’ / ‘this()’ 调用必须是构造函数主体中的第一条语句

this()的使用场景

1	`开闭原则 : 对功能扩展做开放, 对修改代码做关闭`

示例

项目Version1.0版本 : 有3个成员变量

public A(int a, int b, int c) {
    super();
    this.a = a;
    this.b = b;
    this.c = c;
}
// 使用时
A a = new A(1, 2, 3);

项目Version1.1版本 : 新增一个成员变量

//新增构造方法
public A(int a, int b, int c, int d) {
    this(a, b, c);
    this.d = d;
}
//原本代码A a = new A(1, 2, 3);使用不变
A a = new A(1, 2, 3 , 4);

此时内部不掉用super(),因为不能共存，在this(a,b,c)调用的构造方法中使用super();

final关键字

final 关键字是最终的意思，修饰符，可用于修饰方法，类，变量

final 修饰的特点

修饰方法：表明该方法是最终方法，不能被重写
修饰类：表明该类是最终类，不能被继承（可以有父类） | 如String类
修饰变量：表明该变量是常量，不能再次被赋值

修饰变量的细节

变量是基本数据类型：数据值不能发生改变
变量是引用数据类型：引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

1
2
3

final int[] arr = {1,2,3};
// arr = new int[3];   报错
arr[0] = 100;   //成功编译

成员变量如果被 final 修饰，需要在构造方法结束之前完成赋值

final修饰成员变量的注意事项

final修饰成员变量, 不允许修饰默认值

1	`final int num ; //只有这一条默认值语句的话，会报错；必须初始化赋值`

final修饰成员变量的初始化时机

1). 在定义的时候直接赋值
2). 在构造方法中完成赋值

final int num ;   //final int num = 20;  构造语句中不能再赋值
public Student (){
	num = 20；
}

final修饰变量的命名规范

如果变量名是一个单词：所有字母大写 max MAX
如果变量名是多个单词：所有字母大写, 中间使用下划线分割 maxValue MAX_VALUE

JAVA > JAVA SE学习记录

#JAVA SE #static #final

10_JavaSE学习笔记[static，final关键字及继承的使用]

http://example.com/2023/02/09/JavaSE学习笔记-static，final关键字及继承的使用/

作者

zhanghao

发布于

2023年2月9日

许可协议

11_Package包，抽象类，接口，多态上一篇

9_List集合的使用,学生管理系统的实现下一篇