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

2024-06-10 1856阅读

前言

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

文章目录

一、static
- 1.1 静态变量
- 1.2 静态方法
- 1.3 静态变量和静态方法在内存中
- 二、继承
- - 2.1 概念
  - 2.2 继承的特点和能继承什么
  - 2.3 继承中的重写
  - 2.4 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）是子类覆盖父类中具有相同名称和参数的方法。
        
        重写的规则
        
        必须是被子类继承的父类成员方法，才能是重写
        
        方法签名：子类重写父类方法时，方法名、参数列表必须与父类方法完全相同。
        
        访问修饰符：子类重写父类方法时，访问修饰符不能更严格。例如，如果父类方法是 protected，子类重写时可以使用 protected 或者 public，但不能使用 private 或者默认的（package-private）修饰符。
        
        返回类型：重写方法的返回类型必须与被重写方法的返回类型相同，或者是其子类。
        
        @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 关键字
        
        访问当前对象的属性和方法：
        
        可以通过 this 关键字访问当前对象的属性和方法，避免命名冲突或者明确指出正在使用的对象是当前对象。
        class MyClass { private int number; public void setNumber(int number) { this.number = number; // 使用this访问当前对象的number属性 } public int getNumber() { return this.number; // 使用this访问当前对象的number属性 } }
        
        在构造方法中调用其他构造方法：
        
        可以使用 this() 调用本类的其他构造方法（必须位于构造方法的第一行）。
        class MyClass { private int number; // 构造方法1 public MyClass() { this(0); // 调用另一个构造方法 } // 构造方法2 public MyClass(int number) { this.number = number; } }
        
        super 关键字
        
        访问父类的属性和方法：
        
        可以使用 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"); } }
        
        调用父类的构造方法：
        
        可以使用 super() 调用父类的构造方法，必须位于子类构造方法的第一行。
        class Parent { private int number; public Parent(int number) { this.number = number; } } class Child extends Parent { public Child(int number) { super(number); // 调用父类的构造方法 } }
        
        避免子类和父类同名字段的歧义：
        
        在子类和父类中有同名字段时，可以使用 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 关键字用于引用父类对象，可以访问父类的属性、方法和构造方法。
        如果你喜欢这篇文章，点赞👍+评论+关注⭐️哦！
        欢迎大家提出疑问，以及不同的见解。

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

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

文章目录

一、static

1.1 静态变量

1.2 静态方法

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

二、继承

2.1 概念

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

2.3 继承中的重写

2.4 this和super关键字

相关阅读

怎么把织梦的模板替换?

dedecms怎么调用特定的栏目文档?

怎么抓包一个网页?

wap怎么封装app?

目录[+]