Java——面向对象进阶（一）

于 2024-06-07 19:11:04 发布
阅读量1.6k 收藏 22
点赞数 35
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73551991/article/details/139531247
版权

在这里插入图片描述

前言
面向对象进阶(一)：static，继承，this和super关键字

文章目录

一、static

在 Java 中，static 关键字用于声明类中的静态成员（包括字段、方法、内部类和代码块）。静态成员属于类本身，而不是类的实例。

1.1 静态变量

静态变量（也称为类变量）是在类中使用 static关键字声明的变量。

特性

  1. 类级别共享：静态变量属于类本身，而不是类的实例。所有实例共享同一个静态变量。意味着静态变量不依赖于实例而存在。
  2. 单一存储：在内存中只有一份静态变量，无论创建了多少个类的实例。
  3. 生命周期：静态变量在类加载时初始化，并在程序结束时销毁。
  4. 访问方式：可以通过类名直接访问，也可以通过实例访问（但不推荐）。

用法

声明静态变量

静态变量在类体中用 static 关键字声明。通常在类的顶部声明。

public class MyClass {
    public static int staticVar = 0;
}

访问静态变量

静态变量可以通过类名直接访问，也可以通过实例访问。

public class Main {
    public static void main(String[] args) {
        // 通过类名访问静态变量
        MyClass.staticVar = 5;
        System.out.println(MyClass.staticVar); // 输出: 5

        // 通过实例访问静态变量（不推荐）
        MyClass obj1 = new MyClass();
        MyClass obj2 = new MyClass();
        obj1.staticVar = 10;
        System.out.println(obj2.staticVar); // 输出: 10，因为obj1和obj2共享同一个静态变量
    }
}

示例：计数器

静态变量的一个常见用法是作为计数器，记录创建的实例数量。

public class Counter {
    public static int count = 0;

    public Counter() {
        count++;
    }

    public static void displayCount() {
        System.out.println("Number of instances: " + count);
    }
}

public class Main {
    public static void main(String[] args) {
        Counter obj1 = new Counter();
        Counter obj2 = new Counter();
        Counter obj3 = new Counter();

        Counter.displayCount(); // 输出: Number of instances: 3
    }
}

在这个例子中，每次创建 Counter 类的实例时，静态变量 count 都会增加1。由于 count 是静态变量，它在所有实例中共享，因此可以准确记录创建的实例数量。

1.2 静态方法

静态方法（Static Methods）是用 static 关键字修饰的方法，属于类本身，而不是类的实例。它们在类加载时就被初始化，可以不通过实例对象而直接调用。静态方法在很多情况下都非常有用，特别是在工具类中。

特性

  1. 类级别方法：静态方法属于类，可以直接通过类名调用，而不需要创建类的实例。
  2. 不能访问实例成员：静态方法不能直接访问类的实例变量和实例方法，因为它们不属于任何具体的实例。
  3. 可以访问静态成员：静态方法可以访问类的静态变量和其他静态方法。
  4. 无需对象：静态方法在调用时不需要创建对象，可以通过类名直接调用。

用法

声明静态方法

静态方法在类体中使用 static 关键字声明。

public class MyClass {
    public static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

访问静态方法

静态方法可以通过类名直接调用，也可以通过实例调用（但不推荐）。

public class Main {
    public static void main(String[] args) {
        // 通过类名调用静态方法
        MyClass.staticMethod();

        // 通过实例调用静态方法（不推荐）
        MyClass obj = new MyClass();
        obj.staticMethod();
    }
}

示例：实用工具类

静态方法非常适合用来实现实用工具类中的一些方法。例如，数学运算方法、字符串处理方法等。

工具类（Utility Class）是在编程中常用的一种类，专门用于封装一组静态方法，这些方法通常是与特定任务相关的通用功能。工具类的主要特点是它们不需要实例化，可以直接通过类名调用其方法。常见的工具类包括用于字符串处理、数学运算、日期时间操作等功能的类。

public class MathUtils {
    public static int add(int a, int b) {
        return a + b;
    }

    public static int multiply(int a, int b) {
        return a * b;
    }
}

public class Main {
    public static void main(String[] args) {
        int sum = MathUtils.add(5, 3);
        int product = MathUtils.multiply(4, 2);

        System.out.println("Sum: " + sum);        // 输出: Sum: 8
        System.out.println("Product: " + product); // 输出: Product: 8
    }
}

静态方法不能直接访问实例变量和实例方法，举例：

public class Example {
    // 实例变量
    private int instanceVar = 42;

    // 实例方法
    public void instanceMethod() {
        System.out.println("Instance method called. Instance variable: " + instanceVar);
    }

    // 静态方法
    public static void staticMethod() {
        // 试图访问实例变量 - 这会导致编译错误
        // System.out.println("Instance variable: " + instanceVar);

        // 试图调用实例方法 - 这会导致编译错误
        // instanceMethod();

        // 正确的访问方式：静态方法只能访问静态变量和静态方法
        System.out.println("Static method called.");
    }

    // 静态变量
    public static int staticVar = 84;

    // 另一个静态方法
    public static void anotherStaticMethod() {
        System.out.println("Another static method called. Static variable: " + staticVar);
    }
}

public class Main {
    public static void main(String[] args) {
        // 调用静态方法
        Example.staticMethod();

        // 创建类的实例
        Example example = new Example();

        // 调用实例方法
        example.instanceMethod();

        // 调用另一个静态方法
        Example.anotherStaticMethod();
    }
}

解释：在 staticMethod 中，尝试直接访问 instanceVar 和 instanceMethod 会导致编译错误，因为 instanceVar 和 instanceMethod 都是属于实例的，而不是类的。静态方法没有 this 引用，因此无法引用实例成员。

1.3 静态变量和静态方法在内存中

静态变量和静态方法都存储在方法区（Method Area）中

方法区是 JVM 内存的一部分，用于存储类结构信息（如类元数据、常量池）和静态变量。

内存简易图

在这里插入图片描述

二、继承

2.1 概念

继承（Inheritance）是面向对象编程中的重要概念之一，继承是一种类之间的关系，其中一个类（称为子类或派生类）根据规则可以继承另一个类（称为父类或基类）的属性和方法。继承可以避免重复编写相同的代码，更好地组织和管理类之间的关系。

例如，我们要实现学生类和老师类，学生和老师之间必然存在共性，比如都有名字，年龄等成员变量，以及可能有吃饭，睡觉等成员方法，那么就极有可能存在代码重复实现的情况。那我们就可以定义一个父类，比如person类，在类中有名字，年龄成员变量，以及一些成员方法，然后学生类和老师类再继承person类。

在这里插入图片描述

2.2 继承的特点和能继承什么

特点

  1. Java只支持单继承，不支持多继承，但支持多层继承
  2. 多层继承：子类A继承父类B，子类B继承父类C…
  3. 另外，所有其他类都直接或间接地继承自 Object类，因为Object 类是所有类的根类,Object 类定义了几个核心方法，包括 toString(), equals(), hashCode()

能够继承什么？
在这里插入图片描述

我们来挨个解释：
对于构造方法：无论构造方法是否是私有的，它都不能被继承，这是为了保证对象在创建过程中的合理初始化，以及遵循面向对象编程中的封装和可见性原则。

对于成员变量：

  • 子类继承父类时，会继承父类的成员变量。
  • 子类可以继承父类的 public 和 protected 访问权限的成员变量。如果成员变量被声明为 private，则子类无法直接访问该成员变量，需要借助继承自父类的 get/set 方法。
  • 如果子类定义了与父类同名的成员变量，那么父类的成员变量会被子类的成员变量隐藏。这种情况下，可以使用 super 关键字访问父类被隐藏的成员变量。(super 关键字在 Java 中用于调用父类的构造方法和访问被隐藏的父类成员变量或方法。)

子类定义了与父类同名的成员变量，用 super 关键字

class Parent {
    public int number = 10;

    public void display() {
        System.out.println("Parent's number: " + number);
    }
}

class Child extends Parent {
    public int number = 20;

    public void display() {
        super.display(); // 调用父类的 display 方法
        System.out.println("Child's number: " + number);
        System.out.println("Parent's number: " + super.number); // 访问父类的成员变量
    }
}

对于成员方法:

  • 子类可以继承父类的非私有成员方法。private 方法不可继承，因为它们对子类不可见。
  • 子类可以提供自己的实现来覆盖从父类继承的同名方法（重写）。
  • final 修饰的方法不能被子类重写，因此不能继承。
  • static 方法属于类级别的方法，不属于实例，不能被继承。

2.3 继承中的重写

方法的重写（Override）是子类覆盖父类中具有相同名称和参数的方法。

重写的规则

  1. 必须是被子类继承的父类成员方法，才能是重写

  2. 方法签名：子类重写父类方法时，方法名、参数列表必须与父类方法完全相同。

  3. 访问修饰符：子类重写父类方法时，访问修饰符不能更严格。例如，如果父类方法是 protected，子类重写时可以使用 protected 或者 public，但不能使用 private 或者默认的（package-private）修饰符。

  4. 返回类型：重写方法的返回类型必须与被重写方法的返回类型相同，或者是其子类。

  5. @Override 注解可以帮助编译器验证是否成功重写了父类方法。

示例

下面是一个展示方法重写的示例：

// 父类
class Parent {
    // 父类方法
    public void display() {
        System.out.println("Parent's display method");
    }
}

// 子类继承自父类
class Child extends Parent {
    // 重写父类的 display() 方法
    @Override
    public void display() {
        System.out.println("Child's overridden display method");
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建子类对象
        Child child = new Child();

        // 调用子类重写的方法
        child.display(); // 输出: Child's overridden display method
    }
}

2.4 this和super关键字

this 和 super 是两个关键字，用于引用当前对象和父类对象。它们在面向对象编程中有着不同的用途和作用域。

this 关键字

  1. 访问当前对象的属性和方法：

    • 可以通过 this 关键字访问当前对象的属性和方法，避免命名冲突或者明确指出正在使用的对象是当前对象。
    class MyClass {
    private int number;

    public void setNumber(int number) {
        this.number = number; // 使用this访问当前对象的number属性
    }

    public int getNumber() {
        return this.number; // 使用this访问当前对象的number属性
    }
}

  2. 在构造方法中调用其他构造方法：

    • 可以使用 this() 调用本类的其他构造方法（必须位于构造方法的第一行）。
    class MyClass {
    private int number;

    // 构造方法1
    public MyClass() {
        this(0); // 调用另一个构造方法
    }

    // 构造方法2
    public MyClass(int number) {
        this.number = number;
    }
}

super 关键字

  1. 访问父类的属性和方法：

    • 可以使用 super 关键字访问父类中的属性和方法，特别是在子类中覆盖（重写）父类方法时，可以使用 super 调用父类的方法。
    class Parent {
    private int number;

    public Parent(int number) {
        this.number = number;
    }

    public void display() {
        System.out.println("Number: " + number);
    }
}

class Child extends Parent {
    public Child(int number) {
        super(number); // 调用父类的构造方法
    }

    @Override
    public void display() {
        super.display(); // 调用父类的display方法
        System.out.println("Child's display method");
    }
}

  2. 调用父类的构造方法：

    • 可以使用 super() 调用父类的构造方法，必须位于子类构造方法的第一行。
    class Parent {
    private int number;

    public Parent(int number) {
        this.number = number;
    }
}

class Child extends Parent {
    public Child(int number) {
        super(number); // 调用父类的构造方法
    }
}

  3. 避免子类和父类同名字段的歧义：

    • 在子类和父类中有同名字段时，可以使用 super 关键字访问父类中的字段，以避免歧义。
    class Parent {
    protected int number = 10;
}

class Child extends Parent {
    private int number = 20;

    public void display() {
        System.out.println("Child's number: " + number); // 输出20
        System.out.println("Parent's number: " + super.number); // 输出10
    }
}

区别和总结

  • this 关键字用于引用当前对象，可以访问当前对象的属性、方法和构造方法。
  • super 关键字用于引用父类对象，可以访问父类的属性、方法和构造方法。

在这里插入图片描述
如果你喜欢这篇文章，点赞👍+评论+关注⭐️哦！
欢迎大家提出疑问，以及不同的见解。

拉普达的城
关注
  • 35
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
面向对象进阶，面向对象进阶
09-10
1. 封装：封装是面向对象的基础，它将数据和操作数据的方法绑定在一起，形成一个独立的单元——对象。在Java中，我们通过访问修饰符（如public、private、protected）来控制类的成员对外的可见性，实现数据的安全...
JAVA静态变量是什么
林中明月间丶
05-15 4439
java静态变量是什么-Java基础-PHP中文网 在java中，静态变量指的是被static修饰的类的变量；静态变量被所有类实例对象所共享，在内存中只有一个副本，当且仅当在类初次加载时会被初始化。 本教程操作环境：windows7系统、java8版、DELL G3电脑。 1. JVM运行时数据区域 Java堆存放几乎所有的对象实例，被所有线程共享 方法区（永久代）与Java堆一样，是各个线程共享的内存区域，它用于存储已经被虚拟机加载类的类信息、常量、静态变量（static varia
java中static的特点&&静态变量和静态方法分别有什么特点
MindMrWang的blog
10-13 5981
来源：百度知道http://zhidao.baidu.com/question/5912766 一、static 请先看下面这段程序：public class Hello{ public static void main(String[] args){ //(1) System.out.println("Hello,world!"); //(2) } }
JAVA静态变量的使用
davidmeng6628的专栏
04-14 1万+
很多的地方建议把一个一个不变的变量使用static表明，然后所有的变量字母都是用大写来表示。这样的优点    是在读代码的时候我们知道这个字母代表什么，    当这个字母变化的时候，我们只需要修改一个地方就可以修改所有地方了public static String GENDER_MAN = "M". if (GENDER_MAN.equals(gender)){ ... }大量的这种变量存在于...
Java类变量（静态变量）
A29jhltds的博客
02-28 4160
-类变量也称为静态变量，在类中以static关键字声明，但必须在方法、构造方法和语句块之外。 -无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。 -静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。 http://www.iis7.com/a/lm/fwqdq/ IIS7服务器大全 -静态变量储存在静...
java中什么是静态_java中静态变量和静态方法分别有什么特点？
weixin_42516040的博客
02-18 1325
基础真重要啊一、static请先看下面这段程序：Java代码 publicclassHello{publicstaticvoidmain(String[]args){//(1)System.out.println("Hello,world!");//(2)}}public class Hello{public static void main(String[] args){ ...
JAVA-SE入门学习——第六讲面向对象进阶
06-08
在Java SE的学习过程中，面向对象进阶是一个重要的环节，它涵盖了案例驱动模式、分类思想、分包思想以及在实际项目中的应用。下面将详细阐述这些知识点。 首先，案例驱动模式是一种有效的学习和编程方法。它的核心...
java实现的教学管理系统——适合java进阶入门者
10-12
1. **面向对象编程**：Java是一种典型的面向对象编程（OOP）语言。在这个教学管理系统中，可以预见到会有不同的类，如“学生”（Student）、“任务”（Task）、“分数”（Score）等，每个类都封装了特定的数据和行为...
推荐优质Java课程 疯狂Java语言编程 Java入门到进阶教程 02.理解结构化程序设计_理解面向对象（共25页）.ppt
12-19
本系列课程《疯狂Java语言编程》涵盖了Java从入门到进阶的各个主题，包括数据类型、运算符、流程控制、数组、面向对象、异常处理、图形界面编程（AWT和Swing）、JDBC数据库访问、注解、输入输出、多线程、网络编程、...
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
JAVA类变量（静态变量）
weixin_34343000的博客
02-28 6772
2019独角兽企业重金招聘Python工程师标准>>> ...
Java static（一） - 静态变量
李平安
10-14 5338
1. JVM运行时数据区域 Java堆存放几乎所有的对象实例，被所有线程共享 方法区（永久代）与Java堆一样，是各个线程共享的内存区域，它用于存储已经被虚拟机加载类的类信息、常量、静态变量（static variable）等 2. static变量被static修饰的类的变量，也称为静态变量。非静态变量也称为实例变量 静态变量和实例变量的区别是： 静态变量被所有类实例对象所共享，在内存中只有一个
Java语言 static （静态变量、实例变量、局部变量、静态方法）
Hern（宋兆恒）
04-16 1万+
（一）静态变量：线程非安全   1、静态变量：使用static关键字定义的变量。static可以修饰变量和方法，也有static静态代码块。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对...
Java中类变量(静态变量)和类方法(静态方法)
y_xiao_qi的博客
02-19 751
类变量 类变量也叫静态变量或静态属性，是该类所有对象共享的变量任何一个该类的对象去访问它时，取得都是一样的值 语法： 访问修饰符 static 数据类型 变量名 static 访问修饰符数据类型 变量名 细节： 类变量随着类的加载而创建一次 什么时候需要类变量：当需要让某个类的所有对象都共享一个变量时，就可以考虑类变量。例如：定义学生类，定义类变量统一学生花了多少钱 类变量必须遵守访问权限 类变量与实例变量的区别：类变量时该类的所有对象实例共享的，实例变量时...
java静态变量什么意思_Java变量是指什么?java静态变量有什么作用?
weixin_39571219的博客
02-13 1265
一说到java中的变量，我只想表达的是，这应该是所有java初级入门的小伙伴们上的第一课吧，那么你还记得Java变量具体是指什么吗?其中的静态变量呢?首先我们先来了解一下，变量是什么?变量是用来存数的，代词，指代的就是它所存的那个数。其次它是由三个元素组成的：变量类型、变量名、变量值。下面我们再来看看声明和初始化变量：可以在声明变量的同时初始化;当然也可以先声明变量后初始化。注意，声明与初始化是必...
java static变量_什么是静态(static)?什么是静态方法，静态变量，静态块和静态类...
weixin_39968820的博客
11-16 329
static是Java中的一个关键字，我们不能声明普通外层类或者包为静态的。static用于下面四种情况。静态变量：我们可以将类级别的变量声明为static。静态变量是属于类的，而不是属于类创建的对象或实例。因为静态变量被类的所有实例共用，所以非线程安全的。通常静态变量还和关键字final一起用，作为所有对象共用的资源或常量。如果静态变量不是私有的，那么可以通过ClassName.variable...
Java中静态常量和静态变量的区别
热门推荐
luzhensmart的专栏
02-10 2万+
如下：测试java中静态常量和静态变量区别的样例，表明两者加载时的区别。 StaticClass类中定义了静态常量FIANL_VALUE和静态变量VALUE，静态代码块的打印语句表示类被加载 public class StaticClass {       static {           System.out.println("StaticClass loading...");   ...
"JAVA-SE入门学习——面向对象进阶解析与案例驱动模式
JAVA-SE入门学习的第六讲主题是面向对象进阶，探讨了案例驱动模式、分类思想和分包思想。案例驱动模式的概述包括通过实现一个案例来发现存在的问题，并通过新知识点来解决这些问题。案例驱动模式的好处包括减少重复...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值