java笔记第八章：面向对象-继承

继承的概念

使用继承可以为一系列相关对象定义共同特征的一般类，然后其他类(更特殊的类)可以继承这个一般类，每个进行继承的类都可以添加其特有的内容。

被继承的类称为超类（super class）/父类，继承的类称为派生类/子类（subclass）。

一旦创建了一个定义一系列对象共同特征的超类，就可以使用该超类创建任意数量的更特殊的子类。

可以考虑将此概念转化成地图的思想 父类世界地图、子类部分地图。

继承的语法

public class A extends SuperA{
​
}

子类可以从父类继承属性和部分方法，自己再增加新的属性和方法。通过继承可以重用父类的方法和属性，减少代码重复编写，便于维护、代码扩展。

对继承的说明

（1）子类不能从父类继承的资源：私有方法、构造方法、如果子类与父类在不同包中，子类不能继承父类中那些具有默认访问权限的方法。即不能继承那些不能访问的方法。在子类中不能访问到的那些方法，无法继承的。

理论上子类会继承父类的全部成员变量，但是子类不能访问父类的私有成员变量，如果子类与父类在不同包中，子类也不能访问父类中具有默认访问权限的成员变量。

（2）java类继承只允许单继承（只能有一个超类）java中接口允许多继承。

（3）子类中可以定义与父类中同名的成员变量，这时子类的成员变量会隐藏/覆盖父类中的同名成员变量。

（4）子类中也可以定义与父类中同名的成员方法，这时子类中的方法重写了父类中的同名方法。

子类的构造方法

1.构造方法的调用顺序：在类继承层次中按照继承的顺序从父类到子类调用构造函数。

2.在子类的构造方法中，一定会先调用父类的构造方法。

3.子类的每个构造方法都会隐式的调用父类的无参数构造方法，如果想调用父类的其他构造方法，必须使用super(参数列表)来显式调用。说明：编写类时，通常需要提供无参数构造方法。

4.如果父类没有无参的构造方法，或者想调用父类的有参构造方法，则在子类的构造方法中必须显式使用super(xxx)调用父类有参构造方法。这时super(xxx)必须是子类中的第一条语句。

5.通常的做法：在父类中定义有参数的构造方法，负责初始化父类的成员变量。在子类的构造方法中，先调用父类的构造方法完成从父类继承来的那些成员变量，然后初始化子类中特有的成员变量。

注意：如果父类中定义了一个有参数的构造方法，系统就不会再为父类提供默认的构造方法。这时，在子类的构造方法中，必须使用super(xxx)显示调用父类的有参构造方法。

创建多级继承层次

            public  GrandFather( ){
​
            }
​
            public  Father( ) extends GrandFather{
​
            }
​
            public  Son( )  extends Father{
​
            }

超类引用变量可以引用子类对象

SuperA  sa;   //声明超类的变量
​
A  a = new A();  //创建子类对象
​
sa = a;      //将子类对象赋给引用对象
​
sa = new A();   //创建一个新的子类对象，赋给超类引用变量

可以将子类的对象赋给父类的引用变量，但是这时使用父类的引用变量只能访问父类中定义的那些成员变量。换句话说，可以访问哪些成员是由引用变量的类型决定的，而不是由所引用的对象类型决定的。

在面向对象编程中，子类（或称为派生类）是另一个类（称为父类或基类）的扩展或特殊化。子类继承了父类的所有属性和方法（除非某些方法或属性在子类中被明确覆盖或隐藏）。

现在，当我们说“可以将子类的对象赋给父类的引用变量”时，这意味着我们创建了一个子类的对象，但使用一个父类类型的变量来引用它。这是多态性的一个关键方面。

简单的例子来说明：

假设我们有一个父类Animal，它有一个方法eat()和一个成员变量name。然后我们有一个子类Dog，它继承了Animal类，并添加了一个额外的成员变量breed（品种）。

class Animal {  
    String name;  
    void eat() {  
        System.out.println("The animal eats.");  
    }  
}  
  
class Dog extends Animal {  
    String breed;  
    void bark() {  
        System.out.println("The dog barks.");  
    }  
}

现在，如果我们创建一个Dog对象并尝试用一个Animal类型的变量来引用它：

Animal myPet;  
Dog myDog = new Dog();  
myPet = myDog; // 这是合法的，因为Dog是Animal的子类

在上面的代码中，myPet是一个Animal类型的引用变量，但它实际上引用了一个Dog对象。但是，当我们尝试通过myPet来访问Dog特有的breed成员变量或bark()方法时，我们会遇到问题：

// 以下两行代码都是错误的，因为myPet是Animal类型，没有breed成员变量和bark方法  
System.out.println(myPet.breed); // 错误：无法找到符号  
myPet.bark(); // 错误：无法找到符号

但是，由于Dog继承了Animal，所以我们可以通过myPet来访问Animal中定义的name成员变量和eat()方法：

System.out.println(myPet.name); // 这是合法的，因为name是Animal的成员变量  
myPet.eat(); // 这是合法的，因为eat是Animal的方法

总结：虽然myPet实际上引用了一个Dog对象，但由于它的类型是Animal，所以我们只能访问Animal类中定义的成员。这就是“可以访问哪些成员是由引用变量的类型决定的，而不是由所引用的对象类型决定的”这句话的含义。

对象的转型

Animal a = new Dog();  //小转大  可以自动进行
​
a.layal;  //语法错误，这时通过a只能使用父类中定义的成员变量。编译时就确定
​
a.eat();  //
​
 
​
Animal a = new Dog()；
​
d = (Dog)a;  //正确  大转小， 需要强制转换
​
 
​
Dog d = new Animal();  //错误
​
Dog d = (Dog)new Animal();  //语法没错，可以编译，但运行时会抛出异常
​
 
​
Cat c = new Cat();
​
d = (Dog)c; //不正确

子类对象 赋给 父类引用 可以，自动转换

父类引用 赋给 子类引用 需要强转 ，前提：父类引用确实指向了正确的子类对象

super关键字

关键字super用于调用/访问从父类中继承来的实例变量和方法。

super有两种一般用法。第一种用于调用超类的构造方法。第二种用于访问超类中被子类的某个成员隐藏的成员。

使用super()调用父类的构造方法

在子类中使用super()调用父类的构造方法，必须是第一条语句

在本类中可以使用this()调用重载的构造方法，也必须是第一条语句

在子类的构造方法中this()和super()不能同时使用

使用super访问父类中被子类隐藏的成员变量

父类的属性被子类继承，如果子类又添加了名称相同的属性，则子类有两个相同名称的属性，如果父类型对象调用属性，就是父类的，如果是子类型对象调用就是子类的属性。

一个子类需要引用它的直接超类，都可以使用关键字super。

第一种用法：调用超类（父类）的构造方法

在子类的构造方法中，我们可以使用 super 关键字来调用父类的构造方法。这通常用于在创建子类对象时初始化从父类继承的字段。

示例：

class Parent {
    String name;
​
    Parent(String name) {
        this.name = name;
    }
}
​
class Child extends Parent {
    int age;
​
    Child(String name, int age) {
        super(name); // 调用父类的构造方法
        this.age = age;
    }
}

在这个例子中，Child 类继承了 Parent 类。在 Child 类的构造方法中，我们使用 super(name) 来调用 Parent 类的构造方法，以初始化 name 字段。

第二种用法：访问超类（父类）中被子类隐藏的成员

如果子类中的某个成员（如字段、方法或构造函数）与父类中的成员具有相同的名称，那么我们说子类成员“隐藏”了父类成员。在这种情况下，我们可以使用 super 关键字来访问父类中被隐藏的成员。

示例：

class Parent {
    void showMessage() {
        System.out.println("Parent's message");
    }
}
​
class Child extends Parent {
    void showMessage() {
        super.showMessage(); // 调用父类的showMessage方法
        System.out.println("Child's message");
    }
}

在这个例子中，Child 类继承了 Parent 类，并且两者都有一个名为 showMessage 的方法。在 Child 类的 showMessage 方法中，我们使用 super.showMessage() 来调用父类的 showMessage 方法。这样，我们可以先执行父类的行为，然后再执行子类特定的行为。

Object

所有其他类都是Object的子类。也就是说，Object是所有其他类的超类。这意味着Object类型的引用变量可以引用任何其他类的对象。此外，因为数组也是作为类实现的，所以Object类型的变量也可以引用任何数组。

Object类定义了下面列出的方法，这意味着所有对象都可以使用这些方法。

方 法	用 途
Object clone()	创建一个和将要复制的对象完全相同的新对象。
boolean equals(Object object)	确定一个对象是否和另外一个对象相等
void finalize()	在回收不再使用的对象前调用
Class<?> getClass()	在运行时获取对象的类
int hashCode()	返回与调用对象相关联的散列值
void notify()	恢复执行在调用对象上等待的某个线程
void notifyAll()	恢复执行在调用对象上等待的所有线程
String toString()	返回一个描述对象的字符串
void wait()void wait(long milliseconds)void wait (ling milliseconds,int nanoseconds)	等待另一个线程的执行

对象相等性比较

Object类中的equals()方法实现等价于“==”运算符，比较相等，如果实现对象的内容相等比较，自己的类必须重写equals方法。

例如：String类对equals()方法进行了重写，重写后的equals方法比较两个两个字符串的内容是否相同。

Object类的常用方法

l equals(Object obj)方法

比较对象相等 Object类的实现是 等价于 ==

相等的含义：两个引用是否指向同一个对象。

自己的类要比较对象相等，重写equals()方法

案例：重写Box类的equals()方法

l toString()方法

直接打印对象时，默认调用对象的toString()方法

Object类的toString方法输出格式：

getClass().getName() + '@' + Integer.toHexString(hashCode())

自己的类要重写toString()

案例：重写Box类的toString()方法。

l protected Object clone()

克隆对象的方法 被克隆的对象的类必须实现Cloneable接口

l finalize()方法 //终结方法

当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

l HashCode()方法

返回该对象的哈希码值

当我们重写equals()方法，判断两个对象相等时，最好也同时重写hascode()方法，让相同对象的哈希码值也相同

final

final修饰变量、方法、类

l 如果final修饰变量，变量就是常量，常量不可修改，定义时必须初始化

l 如果final修饰方法，方法就不能被子类重写

l 如果final修饰类，类就不能再被扩展，不能再有子类。Java类库中的String、Math就是final类。

引用类型的常量

如果常量是基本数据类型，不可以再修改。

如果常量是引用类型，不能再将其他对象赋给该引用，但可以使用该引用改变对象内部的属性。

例如

final Student s = new Student(“zhangsan”,20);
​
s = new Student(“李四”,20); //错误
​
s.setName(“李四”);     //可以  正确

*多态的概念*

同一个方法名称，执行不同的操作。方法重载就是一种多态的一种形式。