Day07-继承、多态

一、面向对象特征之二： 继承

• 为描述和处理个人信息，定义类Person:

  class Person { 
      public String name; 
      public int age; 
      public Date birthDate; 
      public String getInfo() { //... } 
  }
  

• 为描述和处理学生信息，定义类Student:

  class Student { 
      public String name; 
      public int age; 
      public Date birthDate; 
      public String school; 
      public String getInfo() { // ... } 
  }
  

• 通过继承，简化Student类的定义:

  class Person { 
      public String name; 
      public int age; 
      public Date birthDate; 
      public String getInfo() { // ... } 
  } 
  class Student extends Person { 
      public String school; 
  }
  

  Student类继承了父类Person的所有属性和方法，并增加了一 个属性school。Person中的属性和方法,Student都可以使用。

为什么要有继承？

• 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那个类即可。

• 此处的多个类称为子类(派生类)，单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”

• 类继承语法规则: class Subclass extends SuperClass{ }

作用

• 继承的出现减少了代码冗余，提高了代码的复用性。 继承的出现，更有利于功能的扩展。

• 继承的出现让类与类之间产生了关系，提供了多态的前提。

  注意：不要仅为了获取其他类中某个功能而去继承

特性

• 子类继承了父类，就继承了父类的方法和属性。

• 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和 方法。

• 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集， 而是对父类的“扩展”。

  关于继承的规则：子类不能直接访问父类中私有的(private)的成员变量和方法。

• Java只支持单继承和多层继承，不允许多重继承

• • 一个子类只能有一个父类
  • 一个父类可以派生出多个子类

class SubDemo extends Demo{ } //ok 
class SubDemo extends Demo1,Demo2...//error

二、方法的重写(override/overwrite)

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

要求：

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表

2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型

3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限

   子类不能重写父类中声明为private权限的方法

4. 子类方法抛出的异常不能大于父类被重写方法的异常

注意： 子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为 static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

问题1：

如果现在父类的一个方法定义成private访问权限，在子类中将此方法声明为default访问权限，那么这样还叫重写吗？

不是重写，虽然default权限范围比private权限范围大，但是重写的前提是子类对从父类继承过来的方法进行改造，private修饰的方法是无法被继承的。

问题2：

继承中可以存在方法的重载吗？

可以存在重载，因为子类将父类中的方法继承后已经将其作为自己的方法。

所以重载不仅可以发生在同一个类中，也可以发生在继承类中。

但是与上题的问题一样，private修饰的方法子类无法继承，也就没有重写一说。

三、关键字：super

• 在Java类中使用super来调用父类中的指定操作：

• • super可用于访问父类中定义的属性

  • super可用于调用父类中定义的成员方法

  • super可用于在子类构造器中调用父类的构造器

  • 注意：

  • • 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员

    • super的追溯不仅限于直接父类

    • super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

      参考Java核心卷；有些人认为 super 与 this 引用是类似的概念， 实际上，这样比较并不太恰当。这是因为 super 不是一个对象的引用， 不能将 super 赋给另一个对象变量， 它只是一个指示编译器调用超类方法的特殊关键字

class protected Person { 
    String name = "张三"; 
    protected int age; 
    public String getInfo() { 
        return "Name: " + name + "\nage: " + age; 
    } 
} 
class Student extends Person { 
    protected String name = "李四"; 
    private String school = "New Oriental"; 
    public String getSchool() { 
        return school; 
    } 
    public String getInfo() { 
        return super.getInfo() + "\nschool: " + school; 
    }
} 
public class StudentTest { 
    public static void main(String[] args) { 
        Student st = new Student(); 
        System.out.println(st.getInfo()); 
    }
}

//调用父类构造器
public class Person { 
    private String name; 
    private int age; 
    private Date birthDate; 
    public Person(String name, int age, Date d) { 
        this.name = name; 
        this.age = age; 
        this.birthDate = d; 
    } 
    public Person(String name, int age) { 
        this(name, age, null); 
    } 
    public Person(String name, Date d) { 
        this(name, 30, d); 
    } 
    public Person(String name) { 
        this(name, 30); 
    } 
}


public class Student extends Person { 
    private String school; 
    public Student(String name, int age, String s) { 
        super(name, age); 
        school = s; 
    } 
    public Student(String name, String s) { 
        super(name); school = s; 
    } 
    // 编译出错: no super(),系统将调用父类无参数的构造器。
    public Student(String s) { 
        school = s; 
    } 
}

四、面向对象特征之三： 多态

• 多态性，是面向对象的核心特征之一,类的多态性提供类中成员设计的灵活性和方法执行的多样性.在Java中的体现：

  对象的多态性：父类的引用指向子类的对象

  可以直接应用在抽象类和接口上

• Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明 该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。

• 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)

• 多态情况下， “看左边” ：看的是父类的引用（父类中不具备子类特有的方法）

                          **”看右边”** ：看的是子类的对象（实际运行的是子类重写父类的方法）
  

• 对象的多态 —在Java中,子类的对象可以替代父类的对象使用

• • 一个变量只能有一种确定的数据类型
  • 一个引用类型变量可能指向(引用)多种不同类型的对象

Person p = new Student(); 
Object o = new Person();//Object类型的变量o，指向Person类型的对象 
o = new Student(); //Object类型的变量o，指向Student类型的对象

子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向 上转型(upcasting)。

• 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的特有的属性和方法

Student m = new Student(); 
m.school = “pku”; //合法,Student类有school成员变量 
Person e = new Student(); 
e.school = “pku”; //非法,Person类没有school成员变量

属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编译错误。

• 多态的应用

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

Person e = new Student(); 
e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型

编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类 的getInfo()方法。——动态绑定

五、instanceof 操作符

x instanceof A：检验x是否为类A的对象，返回值为boolean型。

• • 要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
  • 如果x属于类A的子类B，x instanceof A值也为true。

public void method1(Person e) { 
    if (e instanceof Person) 
        // 处理Person类及其子类对象 
    if (e instanceof Student) 
        //处理Student类及其子类对象 
    if (e instanceof Graduate) 
        //处理Graduate类及其子类对象 
}

六、对象类型转换 (Casting )

• 基本数据类型的Casting：

• • 自动类型转换：小的数据类型可以自动转换成大的数据类型

     如long g=20; double d=12.0f
    

  • 强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型

    如 float f=(float)12.0; int a=(int)1200L
    

• 对Java对象的强制类型转换称为造型

• • 从子类到父类的类型转换可以自动进行
  • 从父类到子类的类型转换必须通过造型(强制类型转换)实现
  • 无继承关系的引用类型间的转换是非法的
  • 在造型前可以使用instanceof操作符测试一个对象的类型

七、多态总结

一、多态存在的三个必要条件

1. 要有继承；
2. 要有重写；
3. 父类引用指向子类对象

二、多态性有两种:

1）编译时多态性 对于多个同名方法,如果在编译时能够确定执行同名方法中的哪一个,则称为编译时多态性.

2）运行时多态性 在编译时不能确定,只能在运行时才能确定执行多个同名方法中的哪一个,则称为运行时多态性

三、类多态性表现

(1)方法重载

重载表现为同一个类中方法的多态性.一个类生命多个重载方法就是为一种功能提供多种实现.编译时,根据方法实际参数的数据类型\个数和次序,决定究竟应该执行重载方法中的哪一个.

(2)子类重定义从父类继承来的成员

• 1. 当子类从父类继承来的成员不适合子类时,子类不能删除它们,但可以重定义它们,使父类成员适应子类的新需求.子类重定义父类成员,同名成员在父类与子类之间表现出多态性,父类对象引用父类成员,子类对象引用子类成员,不会产生冲突和混乱。
  2. 子类可重定义父类的同名成员变量,称子类隐藏父类成员变量.子类也可以重定义父类的同名成员方法，当子类方法的参数列表与父类方法参数列表完全相同时，称为子类方法覆盖（override）父类方法。覆盖父类方法时，子类方法的访问权限不能小于父类方法的权限。
  3. 由于Object类的equals()方法比较两个对象的引用是否相等而不是值是否相等,因此一个类要覆盖Object类的equals()方法,提供本类两个对象比较相等方法.
  4. 覆盖表现为父类与子类之间方法的多态性.java 寻找执行方法的原则是:从对象所属的类开始,寻找匹配的方法执行,如果当前类中没有匹配的方法,则逐层向上依次在父类或祖先类中寻找匹配方法,直到Object类.

八、Object类的使用

Object类是所有Java类的根父类

==操作符与equals方法

• = =： 基本类型比较值:只要两个变量的值相等，即为true。

int a=5; 
if(a==6){…} 

• 引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才 返回true。

Person p1=new Person(); 
Person p2=new Person(); 
if (p1==p2){…} 

用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本 数据类型除外)，否则编译出错

• equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。 只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。

格式:obj1.equals(obj2)

特例：当用equals()方法进行比较时，对类File、String、Date及包装类 （Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对 象；

原因：在这些类中重写了Object类的equals()方法。

• 当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都 相等

重写equals()方法的原则

• 对称性：如果x.equals(y)返回是“true” ，那么y.equals(x)也应该返回是 “true”。
• 自反性：x.equals(x)必须返回是“true”。
• 传递性：如果x.equals(y)返回是“true” ，而且y.equals(z)返回是“true” ， 那么z.equals(x)也应该返回是“true”。
• 一致性：如果x.equals(y)返回是“true” ，只要x和y内容一直不变，不管你 重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false” ； x.equals(和x不同类型的对象)永远返回是“false”。

面试题：==和equals的区别

1 == 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型 就是比较内存地址

2 equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也 是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中 用的比较多，久而久之，形成了equals是比较值的错误观点。

3 具体要看自定义类里有没有重写Object的equals方法来判断。

4 通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

toString() 方法

• toString()方法在Object类中定义，其返回值是String类型，返回类名和它 的引用地址。
• 在进行String与其它类型数据的连接操作时，自动调用toString()方法

九、包装类的使用

• 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
• 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

• 基本数据类型包装成包装类的实例 —装箱

通过包装类的构造器实现： int i = 500; Integer t = new Integer(i);

还可以通过字符串参数构造包装类对象：

Float f = new Float(“4.56”); Long l = new Long(“asdf”); //NumberFormatException

• 获得包装类对象中包装的基本类型变量 —拆箱

调用包装类的.xxxValue()方法： boolean b = bObj.booleanValue();

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

• 字符串转换成基本数据类型

• • 通过包装类的构造器实现： int i = new Integer(“12”);
  • 通过包装类的parseXxx(String s)静态方法： Float f = Float.parseFloat(“12.1”);

• 基本数据类型转换成字符串

• • 调用字符串重载的valueOf()方法： String fstr = String.valueOf(2.34f);
  • 更直接的方式： String intStr = 5 + “”