面向对象进阶 | 深入探究 Java 静态成员与继承体系_java静态类

个人主页

文章专栏

文章目录

• • 个人主页
  • 文章专栏
• 一、static（静态）
• • 1.static 静态变量
  • • 代码展示
    • 内存图
  • 2.static 静态方法
  • • 工具类：
    • • 练习：
  • 3.static注意事项
  • 4.重新认识`main`方法
• 二、继承
• • 1.继承概述
  • 2.继承的特点
  • 3.子类到底能继承父类中的哪些内容
  • 4.继承中访问特点
  • • 继承中：成员变量的访问特点
    • 继承中：成员方法的访问特点
    • 继承中：构造方法的访问特点
    • this、super使用总结

一、static（静态）

static表示静态，是Java中的一个修饰符，可以修饰成员方法，成员变量。

1.static 静态变量

被static修饰的成员变量，叫做静态变量。

• 特点：

被该类的所有对象共享

不属于对象，属于类

随着类的加载而加载，优于对象存在

• 调用方式：

类名调用（推荐）

对象名调用

代码展示

需求：写一个JavaBean类来描述这个班级的学生属性：姓名、年龄、性别行为：学习

JAVA Bean 类

package staticdemo;public class Student { //属性：姓名，年龄，性别 //新增：老师的姓名 private String name; private int age; private String gender; public static String teacherName; public Student() { } public Student(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } /** * 获取 * @return name */ public String getName() { return name; } /** * 设置 * @param name */ public void setName(String name) { this.name = name; } /** * 获取 * @return age */ public int getAge() { return age; } /** * 设置 * @param age */ public void setAge(int age) { this.age = age; } /** * 获取 * @return gender */ public String getGender() { return gender; } /** * 设置 * @param gender */ public void setGender(String gender) { this.gender = gender; } //行为 public void study(){ System.out.println(name+\"正在学习\"); } public void show(){ System.out.println(name+\",\"+age+\",\"+gender+\",\"+teacherName); }}

测试类

package staticdemo;public class StudentTest { public static void main(String[] args) { //1.创建第一个学生对象 Student s1 = new Student(); s1.setName(\"张三\"); s1.setAge(20); s1.setGender(\"男\"); //公共类，但是s2没有创建对象，所以无法访问teacherName，为null //public String teacherName; //于是我们想了个方法，用static修饰teacherName，但是这样就变成了静态属性，所有对象共享 //public static String teacherName; s1.teacherName = \"王老师\"; //还可以用类名.属性名来访问 //Student.teacherName = \"王老师\"; s1.study(); s1.show(); //2.创建第二个学生对象 Student s2 = new Student(); s2.setName(\"李四\"); s2.setAge(21); s2.setGender(\"女\"); s2.study(); s2.show(); }}

内存图

• 栈内存
  • 方法调用时会在栈内存中创建栈帧。这里main方法首先入栈 ，在main方法执行过程中：
    • 执行 Student.teacherName = \"阿玮老师\"; ，这一步只是对静态变量赋值，在栈内存中记录这个操作。
    • 执行 Student s1 = new Student(); 时，在栈内存为引用变量 s1 分配空间，存放指向堆内存中 Student 对象的地址（假设为 0x0011 ） 。
    • 执行 s1.name = \"张三\"; 和 s1.age = 23; ，是通过 s1 引用操作堆内存中对象的实例变量。
    • 执行 s1.show(); 时，show 方法的栈帧入栈，在栈帧中记录方法内的局部变量（这里无额外局部变量）以及要操作的对象属性（通过 s1 找到堆内存对象属性）。
    • 执行 Student s2 = new Student(); ，在栈内存为引用变量 s2 分配空间，存放指向堆内存中另一个 Student 对象的地址（假设为 0x0022 ） 。
    • 执行 s2.show(); 时，show 方法栈帧再次入栈，通过 s2 引用操作其对应的堆内存对象属性。
• 堆内存
  • 当执行new Student()时，在堆内存创建Student对象实例。
    • 第一个 Student 对象（对应 s1 ），在堆内存中分配空间存储实例变量 name 值为 “张三” ，age 值为 23 。
    • 第二个 Student 对象（对应 s2 ），在堆内存中分配空间存储实例变量 name 初始值 null （字符串默认初始值） ，age 初始值 0 （整数默认初始值） 。
  • 静态变量 teacherName 存储在堆内存的静态存储位置（静态区），值为 “阿玮老师” ，所有 Student 类的对象共享这个静态变量。

注意：静态变量随类的出现而出现，优于变量。

2.static 静态方法

被static修饰的成员方法，叫做静态方法。

• 特点：

  多用在测试类和工具类中

  Javabean类中很少会用

• 调用方式：

  类名调用（推荐）

  对象名调用

工具类：

帮助我们做一些事情的，但是不描述任何事物的类

Javabean类：用来描述一类事物的类。比如：Student、Teather、Dog等

测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口

遵守的规范：

• 类名见名知意
• 私有化构造方法
• 方法定义为静态的

练习：

第一题：

需求：在实际开发中，经常会遇到一些数组使用的工具类

请按照如下要求编写一个数组的工具类：ArrayUtil

工具类：

package sta02;public class ArrayUtil { //私有构造方法，防止外部实例化 private ArrayUtil() {} public static String printArray(int[] arr) { StringBuilder sb = new StringBuilder(); sb.append( \"[\"); for (int i = 0; i < arr.length; i++) { sb.append(arr[i]); if (i < arr.length - 1) { sb.append(\", \"); }else { sb.append(\"]\"); } } return sb.toString(); } public static double getArray(double[] arr) { double sum = 0; for (int i = 0; i < arr.length; i++) { sum += arr[i]; //累加数组元素 } return sum/arr.length; }}

测试类

package sta02;public class Testdemo { public static void main(String[] args) { //测试printArray方法 int[] arr = {1, 2, 3, 4, 5}; String result = ArrayUtil.printArray(arr); System.out.println(result); //测试getArray方法 double[] arr2 = {1.0, 2.0, 3.0, 4.0, 5.0}; double average = ArrayUtil.getArray(arr2); System.out.println(average); }}

第二题：

需求：定义一个集合，用于存储3个学生对象

学生类的属性：name、age、gender

定义一个工具类，用于获取集合中最大学生的年龄

JavaBean类：

package sat03;public class Student { private String name; private int age; private String gender; public Student() { } public Student(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } /** * 获取 * @return name */ public String getName() { return name; } /** * 设置 * @param name */ public void setName(String name) { this.name = name; } /** * 获取 * @return age */ public int getAge() { return age; } /** * 设置 * @param age */ public void setAge(int age) { this.age = age; } /** * 获取 * @return gender */ public String getGender() { return gender; } /** * 设置 * @param gender */ public void setGender(String gender) { this.gender = gender; }}

方法类：

package sat03;import java.util.ArrayList;public class StudentUtil { //私有构造方法，防止外部实例化 private StudentUtil() {} //静态方法 public static int getMaxScore(ArrayList<Student> list ) { //1.定义一个参照物 int maxAge = list.get(0).getAge(); //2.遍历集合 for (int i = 1; i < list.size(); i++) { if (list.get(i).getAge() > maxAge) { maxAge = list.get(i).getAge(); } } return maxAge; }}

测试类：

package sat03;import java.util.ArrayList;public class testmax { public static void main(String[] args) { //1.创建一个集合来存储 ArrayList<Student> list = new ArrayList<Student>(); //2.创建3个学生对象 Student s1 = new Student(\"Zhangsan\", 20, \"男\"); Student s2 = new Student(\"lisi\", 23, \"男\"); Student s3 = new Student(\"wangwu\", 25, \"女\"); //3.将学生对象添加到集合中 list.add(s1); list.add(s2); list.add(s3); //4.调用方法 int max=StudentUtil.getMaxScore(list); System.out.println(max); }}

3.static注意事项

• 静态方法只能访问静态变量和静态方法
• 非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法
• 静态方法中是没有this关键字的

总结：

静态方法中，只能访问静态

非静态方法可以访问所有

静态方法中没有this关键字

4.重新认识main方法

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

• public : 被JVM调用，访问权限足够大

• static ：被JVM调用，不用创建对象，直接类名访问

  ​ 因为main方法是静态的，所以测试类中其他方法也是需要是静态的

• void : 被JVM调用，不需要给JVM返回值

• main : 一个通用的名称，虽然不是关键字，但是被JVM识别

• String[] args ：以前用于接受键盘录入数据的，现在没用

二、继承

面向对象三大特征：封装、继承、多态

封装：对象代表什么，就得封装对应的数据，并提供数据对应的行为。

我们发现在Student类与Teacher类中有重复的元素，于是为了使程序更加便捷便出现了”继承“

1.继承概述

• java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系

  public class Student extends Person{}

  • Student称为子类（派生类）,Person称为父类（基类或超类）

优点：

• 可以把多个子类中重复的代码抽取到父类中，提高代码的复用性
• 子类可以在父类的基础上，增加其他的功能，使子类更强大

什么时候用继承？

当类与类之间，存在相同（共性）的内容，并满足子类是父类中的一种，就可以考虑使用继承，来优化代码

2.继承的特点

java中只支持单继承，不支持多继承，但支持多层继承

单继承：一个子类只能继承一个直接父类

不支持多继承：子类不能同时继承多个父类

多层继承：子类A继承父类B，父类B可以继承父类C

C是A的间接父类

每一个类都直接或者间接的继承于Object

练习：

核心点：共性内容抽取，子类是父类中的一种

写代码是从父类开始写，最后写子类

JAVABean类

package st5;public class Animal { public void eat() { System.out.println(\"我会吃饭\"); } public void water (){ System.out.println(\"我会喝水\"); }}

package st5;public class Cat extends Animal { public void mice() { System.out.println(\"我会抓老鼠\"); }}

package st5;public class Dog extends Animal { public void lookhome() { System.out.println(\"我会看家\"); }}

package st5;public class Ragdoll extends Cat{}

package st5;public class Lihua extends Cat{}

package st5;public class Husky extends Dog{ public void breakhome() { System.out.println(\"我会拆家\"); }}

package st5;public class Teddy extends Dog{ public void Ceng(){ System.out.println(\"我喜欢蹭一蹭\"); }}

测试类：

package st5;public class Test { public static void main(String[] args) { //创建对象并调用方法 //创建布偶猫的对象 Ragdoll rd = new Ragdoll(); System.out.println(\"我是布偶猫\"); rd.mice(); rd.water(); rd.eat(); System.out.println(\"-------------------\"); //创建狸花猫的对象 Lihua lh = new Lihua(); System.out.println(\"我是狸花猫\"); lh.mice(); lh.water(); lh.eat(); System.out.println(\"-------------------\"); //创建泰迪的对象 Teddy td = new Teddy(); System.out.println(\"我是泰迪\"); td.lookhome(); td.water(); td.eat(); td.Ceng(); System.out.println(\"-------------------\"); //创建哈士奇的对象 Husky hs = new Husky(); System.out.println(\"我是哈士奇\"); hs.lookhome(); hs.water(); hs.eat(); hs.breakhome(); }}

试运行：

注意：子类只能访问父类中非私有的成员

3.子类到底能继承父类中的哪些内容

构造方法 非私有 不能 private 不能 成员变量 非私有 能 private 能 但不能直接用 成员方法 虚方法表 能 否则 不能

虚方法表：就是经常要用的方法，什么叫虚方法表呢？非private 非static非final

4.继承中访问特点

继承中：成员变量的访问特点

public class Fu{ String name = \"Fu\";}public class Zi extends Fu{ String name = \"Zi\"; public void ziShow(){ String name = \"ziShow\"; System.out.println(name); }}//就近原则:谁离我近，我就用谁//完整版就近原则：先在局部位置找，本类成员位置找，父类成员位置找，逐级往上//run:ziShow

如果出现了重名的成员变量怎么找：

System.out.println(name);//从局部位置开始往上找System.out.println(this.name);//从本类成员位置开始往上找System.out.println(super.name);//从父类成员位置开始往上找

public class Test{ public static void main (String [] args){ Zi z = new Zi(); z.ziShow(); }}public class Fu{ String name = \"Fu\";}public class Zi extends Fu{ String name = \"Zi\"; public void ziShow(){ String name = \"ziShow\"; System.out.println(name);//ziShow System.out.println(this.name);//Zi System.out.println(super.name);//Fu }}

继承中：成员方法的访问特点

直接调用满足就近原则：谁离我近，我就用谁

super调用，直接访问父类

package jicehng;public class test { public static void main(String[] args) { //创建一个对象 Student s = new Student(); s.lunch(); /* 吃面条 咖啡 吃米饭 喝水 */ }}class Person { public void eat(){ System.out.println(\"吃米饭\"); } public void water(){ System.out.println(\"喝水\"); }}class Student extends Person { public void lunch(){ this.eat();//就近读取子类吃面条 this.water();//就近读取子类咖啡 super.eat();//调用父类吃米饭 super.water();//调用父类喝水 } public void eat(){ System.out.println(\"吃面条\"); } public void water(){ System.out.println(\"咖啡\"); }}

方法的重写：

当父类的方法不能满足子类现在的需求时，需要进行方法重写

书写格式：

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

@Override重写体系

1. @Override是放在重写后的方法上，校验子类重写时语法是否正确
2. 加上注解后如果有红色波浪线，表示语法错误
3. 建议重写方法都加@Override注解，代码安全，优雅！

方法重写注意事项和要求：

1. 重写方法的名称、形参列表必须于父类中的一致
2. 子类重写父类方法时，访问权限子类必须大于等于父类（暂时了解：空着不写<protected<public）
3. 子类重写父类方法时，返回值类型必须小于等于父类
4. 建议：重写的方法尽量和父类保持一致
5. 只有被添加到虚方法表中的方法才能被重写

JAVABean类：

package jice;public class Dog { public void eat() { System.out.println(\"Dog is eating.\"); } public void drink() { System.out.println(\"Dog is drinking.\"); } public void lookhome() { System.out.println(\"Dog is lookhome.\"); }}

package jice;public class hashiqi extends Dog { public void breakhome() { System.out.println(\"hashiqi is breakhome.\"); }}

package jice;public class shapi extends Dog{ @Override public void eat() { super.eat();// 调用父类的eat方法 System.out.println(\"shapi is eating gouliang.\"); }}

package jice;public class chinesedog extends Dog{ @Override public void eat() { super.eat();// 调用父类的eat方法 System.out.println(\"Chinesedog is eating chinesefood.\"); }}

测试类

package jice;public class test { public static void main(String[] args) { hashiqi hashiqi = new hashiqi(); hashiqi.eat(); hashiqi.drink(); hashiqi.lookhome(); shapi shapi = new shapi(); shapi.eat(); shapi.drink(); shapi.lookhome(); chinesedog chinesedog = new chinesedog(); chinesedog.eat(); chinesedog.drink(); }}

继承中：构造方法的访问特点

• 父类中的构造方法不会被子类继承

• 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己

  为什么？

  • 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。
  • 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化

  怎么调用父类构造方法的？

  • 子类构造方法的第一行语句默认都是：super(),不写也存在，且必须在第一行
  • 如果想调用父类有参构造，必须手动写super进行调用

this、super使用总结

this：理解为一个变量，表示当前发给发调用者的地址值；

super：代表父类存储空间

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

 chinesedog chinesedog = new chinesedog(); chinesedog.eat(); chinesedog.drink();}

}

### 继承中：构造方法的访问特点- 父类中的构造方法不会被子类继承- 子类中所有的构造方法默认先访问父类中的无参构造，再执行自己 为什么？ - 子类在初始化的时候，有可能会使用到父类中的数据，如果父类没有完成初始化，子类将无法使用父类的数据。 - 子类初始化之前，一定要调用父类构造方法先完成父类数据空间的初始化 怎么调用父类构造方法的？ - 子类构造方法的第一行语句默认都是：`super()`,不写也存在，且必须在第一行 - 如果想调用父类有参构造，必须手动写`super`进行调用### this、super使用总结this：理解为一个变量，表示当前发给发调用者的地址值；super：代表父类存储空间| 关键字 | 访问成员变量  | 访问成员方法 | 访问构造方法  || ------ | -------------------------------- | -------------------------------------- | ---------------------------- || this | this.成员变量 访问本类成员变量 | this.成员方法（...） 访问本类成员方法 | this(...) 访问本类构造方法 || super | super.成员变量 访问父类成员变量 | super.成员方法（...） 访问父类成员方法 | super(...) 访问父类构造方法 |我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=8yhmagt33rj