JavaSE-继承(包含Object类)

继承(包含Object类)

何为继承

在面向对象编程(OOP)中,继承是一种机制,它允许一个类(称为子类或派生类)继承另一个类(称为父类或基类)的属性和方法。继承提供了一种代码复用的方式,使得子类可以继承父类的公共属性和方法,而不需要重新编写相同的代码。

优点

代码复用

通过继承,可以在现有的类基础上创建新类,新类自动拥有父类的所有属性和方法,这样可以减少代码的重复编写。

易于维护和扩展

继承提供了一种层次结构,使得代码更加模块化,易于维护和扩展。如果需要修改某个功能,只需要在父类中修改,所有继承自该父类的子类都会受到影响。

缺点

紧密耦合

继承创建了类之间的强依赖关系,如果父类发生改变,可能会影响所有继承自该父类的子类。

缺乏灵活性

继承是静态的,一旦定义了继承关系,就很难改变。这限制了代码的灵活性。

常用的方法

在Java中,继承可以通过关键字extends来实现。下面是一个简单的示例:

复制代码
// 父类
class Animal {
void eat() {
System.out.println("动物吃东西");
}
}
// 子类
class Dog extends Animal {
void bark() {
System.out.println("狗叫");
}
}
public class TestInheritance {
public static void main(String[] args) {
Dog myDog = new Dog();
myDog.eat(); // 继承自Animal类的方法
myDog.bark(); // Dog类特有的方法
}
}

Object类

在Java中,所有的类都隐式地继承自java.lang.Object类,这是Java类层次结构的根类。即使在定义类时没有显式地指定父类,它也会默认继承自Object类。

复制代码
class MyClass {
// ...
}
public class TestObject {
public static void main(String[] args) {
MyClass myObject = new MyClass();
// 可以使用Object类的方法
myObject.toString();
}
}

Object类中的常用方法:

在Java中,Object类是所有类的根类,它提供了一些常用的方法,这些方法在很多情况下都非常有用。以下是Object类的一些常用方法及其简要说明:

  1. equals(Object obj):检查传递给此方法的对象是否与该对象相等。默认行为是比较对象的引用,但通常需要根据类的属性重写这个方法。

  2. hashCode():返回该对象的哈希码值。支持equals方法的类通常也应该重写hashCode方法,以维护equalshashCode的一致性。

  3. toString():返回该对象的字符串表示。通常需要重写这个方法以提供更有用的信息。

  4. getClass():返回运行时类对象,这个类对象表示该对象的实际类。

  5. notify()notifyAll():唤醒在此对象监视器上等待的单个或所有线程。

  6. wait():导致当前线程等待,直到另一个线程调用此对象的notify()notifyAll()方法。

  7. wait(long timeout)wait(long timeout, int nanos):导致当前线程等待,直到另一个线程调用此对象的notify()notifyAll()方法,或者超过指定的时间。

下面是一个示例,展示了如何使用这些方法:

复制代码
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
Person person = (Person) obj;
return age == person.age &&
(name != null ? name.equals(person.name) : person.name == null);
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public static void main(String[] args) throws InterruptedException {
Person person1 = new Person("Kimi", 30);
Person person2 = new Person("Kimi", 30);
System.out.println("person1 = " + person1);
System.out.println("person2 = " + person2);
System.out.println("Are person1 and person2 equal? " + person1.equals(person2));
System.out.println("Hash code of person1: " + person1.hashCode());
System.out.println("Hash code of person2: " + person2.hashCode());
// 获取类对象
System.out.println("Class of person1: " + person1.getClass().getName());
System.out.println("Class of person2: " + person2.getClass().getName());
}
}

在这个例子中,我们重写了equalshashCodetoString方法,以便提供更有意义的行为。我们也展示了如何获取对象的类对象,并打印出它的名称。这个例子没有展示waitnotifynotifyAll方法的使用,因为它们通常与多线程编程一起使用,涉及到更复杂的同步机制。

方法重写规则

方法重写(Override)是指子类中定义一个与父类中具有相同名称、参数列表的方法。这是实现多态的一种方式。

方法重写规则

  1. 方法名、参数列表和返回类型必须与父类中被重写的方法相同。
  2. 访问权限不能比父类中被重写的方法更严格。
  3. 不能重写父类中声明为final的方法。
  4. 如果父类中的方法被声明为static,则子类中的方法也必须是static

方法重写与方法重载的区别

  • 方法重写:发生在子类和父类之间,要求方法名、参数列表相同,返回类型相同或兼容,访问权限相同或更宽松。
  • 方法重载:发生在同一个类中,要求方法名相同,参数列表不同。

示例代码

复制代码
class Parent {
void show() {
System.out.println("Parent show()");
}
}
class Child extends Parent {
// 方法重写
void show() {
System.out.println("Child show()");
}
// 方法重载
void show(int num) {
System.out.println("Child show(int num)");
}
}
public class TestOverride {
public static void main(String[] args) {
Child obj = new Child();
obj.show(); // 调用重写的方法
obj.show(10); // 调用重载的方法
}
}

super关键字的用法

super关键字用于引用父类中的属性、方法和构造器。

示例代码

复制代码
class Parent {
String name = "Parent";
void show() {
System.out.println("Parent show()");
}
}
class Child extends Parent {
String name = "Child";
void show() {
super.show(); // 调用父类的show方法
System.out.println("Child show(), name = " + name);
}
}
public class TestSuper {
public static void main(String[] args) {
Child obj = new Child();
obj.show();
}
}

final关键字的用法

final关键字可以用于修饰类、方法和变量。

  • final类:不能被继承。
  • final方法:不能被重写。
  • final变量:一旦赋值后,其值不能被改变。

示例代码

复制代码
final class FinalClass {
// ...
}
class MyClass {
final void show() {
// ...
}
}
public class TestFinal {
public static void main(String[] args) {
final int num = 10; // final变量
// num = 20; // 编译错误:不能为final变量赋值
}
}

通过上述内容,你应该对继承有了基本的了解,包括它的概念、优点、缺点、方法重写规则以及superfinal关键字的用法。希望这些示例代码能帮助你更好地理解这些概念。

posted @   柒寒(平安)  阅读(48)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· 【.NET】调用本地 Deepseek 模型
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· 上周热点回顾(2.17-2.23)
· 如何使用 Uni-app 实现视频聊天(源码,支持安卓、iOS)
点击右上角即可分享
微信分享提示