Java面向对象核心知识（二）_x.equal(y),当x和y是同一个对象的引用时,返回true,否则返回false-优快云博客

本文链接：https://blog.youkuaiyun.com/Mysky984/article/details/92401181

本文深入探讨Java面向对象的核心概念，包括方法重写、super关键字、构造方法、Object类、toString与equals方法、对象转型、动态绑定、抽象类、final关键字、接口及多态性。解析如何利用这些特性提升程序的可扩展性和灵活性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java面向对象核心知识（二）

Java面向对象核心知识（一）

文章目录

Java面向对象核心知识（二）

一、方法的重写（overwrite/override）

在子类中可以根据需要从父类中继承来的方法进行重写
重写方法必须要和被重写方法具有相同的方法名称、参数列表和返回值类型。
重写方法不能使用比被重写方法更严格的访问权限。
当需要重写一个方法时，要去copy，以免出错！
重写和重载的区别。方法重新实现了动态多态性（也称为动态联编），方法重载则实现了静态多态性（编译时多态）。也正是重写和重载体现了Java的多态性。

二、super关键字

在Java类中使用super来引用父类的东西

当new一个对象出来的时候会有一个this引用，这个this指向这个对象自身。
如果这个对象是一个子类对象的话，那么，还会有另外的一个引用，叫super，super指向当前对象里面的父对象。
使用super.方法名调用父类中的方法
一个子类对象new出来的时候，在这个子类对象内部是有一个父类对象的。

三、继承中的构造方法

在子类的构造过程中必须调用其父类的构造方法，或者说必须在子类中重写构造方法，因为构造方法不能继承。
子类可以在自己的构造方法中使用super（参数列表）调用其父类的构造方法；使用this（参数列表）调用本类的另外的的构造方法，如果调用super，则必须写在子类构造方法的第一行。
如果子类的构造方法中没有显式调用父类的构造方法，则系统默认使用父类无参数构造方法。
如果子类构造方法中既没有显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错！

四、Object类

Object类是所有Java类的根基类
如果在类的声明中未使用extends关键字指明父类，则默认父类为Object类
例如：

public class Person{
      ....   
 }

等价于

public class Person extends Object{ 
       ....  
}

五、toString方法（Object中其中的一个方法）

Object类中定义有public String toString（）方法，其返回值是String类型，此方法用于描述当前对象的有关信息，默认描述格式：类名加其所在的内存地址（类@地址）
在进行String与其他类型数据的连接操作时，将自动调用该对象的toString（）方法，例如：System.out.println("info" + person);
可以根据需要在用户自定义类型中重写toString（）方法。
补充：“==”比较的是两个对象的内存地址，而equals则比较的是二者是否指向同一个对象。

六、equals方法（也是Object类中的一个方法）

Object类中定义有：public boolean equals(Object obj)方法，提供定义对象是否“相等”
的逻辑。
Object的equals方法定义为：x.equals(y)，当x和y是同一个对象的引用时返回true，否则返回false。
JDK提供的一些类，如String，Date，Integer等，重写了Object的equals方法，调用这些类的equals方法，x.equals(y)，当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回true，否则返回false。
可以根据需要在用户自定义类型中重写equals方法。

七、对象转型（casting）—— 程序的可扩展性得到了很大的提高

一个父类的引用类型变量可以“指向”其子类的对象。（如：Father father = new Son()；）
一个父类的引用不可以访问其子类对象新增加的成员变量和方法。
可以使用引用变量instanceof类名来判断该引用类型变量所“指向”的对象是否属于该类或者该类的子类。
子类的对象可以当作父类的对象来使用，称作向上转型（upcasting），反之称为向下转型（downcasting）。
父类引用指向子类对象时，它看到的只是作为父类的那部分所拥有的属性和方法，至于子类那部分是“看”不到的，但是它仍属于子类类型。例如： animal instanceof Dog; //true
在发生向下转型之前，一定要首先发生对象的向上转型，建立关系后才可以进行。例如：

Animal animal = new Dog("bigyellow","yellow"); //通过向上转型建立关系
Dog dog1 = (Dog) animal; //向下转型
System.out.println(dog1.furColor);

父类引用可以指向子类对象，从而程序可扩展性得到了很大的提高，我们可以在一个方法参数里面定义父类的引用，然后实际传的时候是子类对象，这个时候在实现方法时，判断到底属于哪个子类，然后再执行里面的方法或者调用里面的成员变量。

八、动态绑定（多态）—— 程序的可扩展性达到极致

动态绑定是指“在执行期间(非编译期间)”判断所引用对象的实际类型，根据实际的类型调用其相应的方法。new出来的是谁，就找谁的方法。
下面的例子中，根据Lady对象的成员变量pet所引用的不同的实际类型而调用相应的enjoy方法。

package com.lfq.faceobject.testcast;

/**
 * 多态（动态绑定）
 * 程序的可扩展性发展到极致
 */
public class TestDuoTai {

    public static void main(String[] args) {
        Cat2 cat2 = new Cat2("cat2Name", "blue");
        Dog2 dog2 = new Dog2("dog2Name", "black");
        Lady lady1 = new Lady("laydy1", cat2);
        Lady lady2 = new Lady("lady2", dog2);
        lady1.mypetEnjoy();
        lady2.mypetEnjoy();
    }

}

class Animal2 {
    private String name;

    Animal2(String name) {
        this.name = name;
    }

    public void enjoy() {
        System.out.println("叫声......");
    }
}

class Cat2 extends Animal2 {
    private String eyesColor;

    Cat2(String name, String eyesColor) {
        super(name);
        this.eyesColor = eyesColor;
    }

    public void enjoy() {
        System.out.println("猫叫声......");
    }
}

class Dog2 extends Animal2 {
    private String furColor;

    Dog2(String name, String furColor) {
        super(name);
        this.furColor = furColor;
    }

    public void enjoy() {
        System.out.println("狗叫声......");
    }
}

class Lady {
    private String name;
    private Animal2 pet;

    Lady(String name, Animal2 pet) {
        this.name = name;
        this.pet = pet;
    }

    public void mypetEnjoy() {
        pet.enjoy();
    }
}

程序运行结果如下：
核心机制：调用方法时，只要这个方法重写了，实际调用哪个方法，要看你实际当中new的是什么对象，这个机制就叫多态机制或者动态绑定，也称为延迟绑定，这个机制是面向对象的核心机制。

多态的总结
多态的存在必须的三个条件：
- 要有继承或者类实现接口
- 要有重写或者对接口方法的实现
- 父类引用指向子类对象或者接口对象指向它的实现类
  这三个条件一旦满足，当你调用父类里面被重写的方法或者调用你实现接口的方法的时候，实际当中new的是哪个子类对象就调用子类对象的那个方法。

九、抽象类

继承抽象类的类一般应该实现抽象类中的所有抽象方法，如果没有，那么该子类也应该声明为抽象类。
用abstract关键字来修饰一个类时，这个类叫做抽象类，用abstract来修饰一个方法时，该方法叫做抽象方法。
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。
抽象类不能被实例化，即不能new对象
抽象方法只需声明，而不需要实现。
抽象方法就是被用来重写的，所以在子类里面应该重写这方法。
抽象方法的一个主要目的就是为所有子类定义一个统一的接口。
抽象类不一定要包含抽象方法。若类中包含了抽象方法，则该类必须被定义为抽象类。
抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

十、final关键字

final的变量的值不能够被改变，包括final的成员变量，final的局部变量。例如：形式参数
final的类不能够被继承，即不能有子类。
final的方法不能够被重写。
final常量：常量必须赋初值，即初始化可在定义处或构造方法中，而且不能再发生变化。

十一、接口（interface）

接口是抽象方法和常量值的定义的集合。。
从本质来讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
接口定义，例如：

public interface Runner{
		public static final int id = 1;
		public abstract void start();//public和abstract写不写都行，默认就是public和abstract的
		public void run();
		public void stop();
}

多个无关的类可以实现同一个接口。
一个类可以实现多个无关的接口。
与继承关系类似，接口与实现类之间存在多态性
定义Java类的语法格式：

<modifier> class <name> [extends <superclass>] [implements <interface>] [,<interface>...]{
	<declarations>*
}

接口特性：

接口可以多重实现，也就是一个类可以实现多个接口。
接口中声明的属性默认为public static final的，也只能是public static final的。
接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的。
接口可以继承其他的接口，并添加新的属性和抽象方法。
接口之间可以相互继承，一个类只能实现接口，类和类之间可以继承，接口和接口之间也可以相互继承，但是类和接口之间，只能是类实现接口。

十二、总结

Java程序运行的内存分析至关重要
对象和类的概念
类和类之间的关系，类和对象之间的关系
面向对象设计思想
class
new和引用的概念；构造方法的概念
方法重载；构造方法重载
this
static
package和import
private/default/protected/public
extends
overwrite/override
final
Object toString/equals
upcasting/downcasting
多态