5.面向对象编程(中)

Posted 2022-12-27

一、面向对象特征之二： 继承性(inheritance)

• 为什么要有继承？

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

• 此处的多个类称为子类(派生类)，单独的这个类称为父类(基类 或超类)。可以理解为:“子类 is a 父类”
• 类继承语法规则:
  ​​​class Subclass extends SuperClass ​​
• 作用：

• 继承的出现减少了代码冗余，提高了代码的复用性。
• 继承的出现，更有利于功能的扩展。
• 继承的出现让类与类之间产生了关系，提供了多态的前提。

• 注意：不要仅为了获取其他类中某个功能而去继承
• 子类继承了父类，就继承了父类的方法和属性。
• 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
• 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集， 而是对父类的“扩展”。

关于继承的规则：

• 子类不能直接访问父类中私有的(private)的成员变量和方法。可以通过get，set方法
• Java只支持单继承和多层继承，不允许多重继承

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

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

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

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
   子类不能重写父类中声明为private权限的方法
4. 子类方法抛出的异常不能大于父类被重写方法的异常

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

三、四种访问权限修饰符

Java权限修饰符public、protected、 (缺省)、 private置于类的成员定义 前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	Yes
(缺省)	Yes	Yes
protected	Yes	Yes	Yes
public	Yes	Yes	Yes	Yes

对于class的权限修饰只可以用 public 和 default(缺省)。

• public类可以在任意地方被访问。
• default类只可以被同一个包内部的类访问。

访问控制举例

public class Parent 
    private int f1 = 1;
    int f2 = 2;
    protected int f3 = 3;
    public int f4 =4;

    private void fm1() 
        System.out.println("in fm() f1 = " + f1);
    
    void fm2()
        System.out.println("in fm() f2 = " + f2);
    
    protected void fm3()
        System.out.println("in fm() f3 = " + f3);
    
    public void fm4()
        System.out.println("in fm() f4 = " + f4);
    

public class Child extends Parent
    private int c1 = 21;
    public int c2 = 22;

    private void cm1()
        System.out.println("in cm1() c1 = " + c1);
    
    public void cm2()
        System.out.println("in cm2() c2 = " + c2);
    

    public static void main(String[] args) 
        int i;
        Parent p = new Child();
        i = p.f2; // i = p.f3; i = p.f4;
        p.fm2(); // i = p.fm3; i = p.fm4;
        Child c = new Child();
        i = c.f2; // i = c.f3; i = c.f4;
        i = c.c1;// i = c.c2;
        c.cm1();// c.cm2(); c.fm2(); c.fm3(); c.fm4()
    

访问控制分析

父类Parent和子类Child在同一包中定义时：

四、关键字：super

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

• super可用于访问父类中定义的属性
• super可用于调用父类中定义的成员方法
• super可用于在子类构造器中调用父类的构造器

• 注意：

• 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
• super的追溯不仅限于直接父类
• super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

关键字super举例

//关键字super举例
public class StudentTest 
    public static void main(String[] args) 
        Student st = new Student();
        System.out.println(st.getinfo());
    


class Person 
    protected String name = "John";
    protected  int age ;
    public String getInfo()  return "Name: " + name + "\\nage: " + age; 


class Student extends Person 
    protected String name = "Mink";
    private String school = "New Oriental";
    public String getSchool()  return school;
    public String getinfo()  return super.getInfo() +  "\\nSchool: " + school;


/**输出
Name: John
age: 0
School: New Oriental
*/

调用父类的构造器

• 子类中所有的构造器默认都会访问父类中空参数的构造器
• 当父类中没有空参数的构造器时，子类的构造器必须通过==this(参数列表)或者super(参数列表)==语句指定调用本类或者父类中相应的 构造器。同时，只能”二选一” ，且必须放在构造器的首行
• 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又 没有无参的构造器，则编译出错

//调用父类构造器举例

public class Person 
    private String name;
    private int age;
    private Date birthDate;
    
    // 注释编译出错: no super(),系统将调用父类无参数的构造器。
//    public Person() 
//    

    public Person(String name, int age, Date birthDate) 
        this.name = name;
        this.age = age;
        this.birthDate = birthDate;
    

    public Person(String name, int age) 
        this(name, age, null);
    

    public Person(String name, Date birthDate) 
        this(name, 30, birthDate);
    

    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;
    

this和super的区别

No.	区别点	this	super
1	访问属性	访问本类中的属性，如果本类中没有此属性则从父类中继续查找	直接访问父类中的属性
2	调用方法	访问本类中的方法，如果本类没有此方法则从父类中继续查找	直接访问父类中的方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行

五、子类对象实例化过程

1.从结果上看：（继承性）

子类继承父类之后，就获取了父类中声明的属性或方法。

创建子类对象，在堆空间中，就会加载所有父类中声明的属性。

2.从过程上看：

当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，知道到调用了 java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类的结构，子类对象才可以考虑进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建了一个对象，即为new的子类对象。

思考：

1. 为什么super(…)和this(…)调用语句不能同时在一个构造器中出现？
   答：
2. 为什么super(…)或this(…)调用语句只能作为构造器中的第一句出现？

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

• 多态性，是面向对象中最重要的概念，在Java中的体现：
  对象的多态性：父类的引用指向子类的对象

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

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

• 若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
• 多态情况下，
  “看左边”：看的是父类的引用（父类中不具备子类特有的方法）
  “看右边” ：看的是子类的对象（实际运行的是子类重写父类的方法）

1.编译时类型和运行时类型：

Java的引用变量有两个类型，一个是编译时类型，一个是运行时类型，编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，会出现所谓的多态。因为子类其实是一种特殊的父类，因此java允许把一个子类对象直接赋值给一个父类引用变量，无须任何类型转换，或者被称为向上转型，由系统自动完成。

引用变量在编译阶段只能调用其编译时类型所具有的方法，但运行时则执行它运行时类型所具有的方法（意思是说：编写代码时，只能调用父类中具有的方法，如果子类重写了该方法，运行时实际调用的是运行时类型的该方法。程序在编译时，会在编译类型中检查是否具有所调用的方法，如果编写代码时，使用引用变量调用子类中的特有方法，或者调用重载了父类中的方法，而父类中找不到该方法，则会报编译错误），因此，编写Java代码时，引用变量只能调用声明该变量所用类里包含的方法。与方法不同的是，对象的属性则不具备多态性。通过引用变量来访问其包含的实例属性时，系统总是试图访问它编译时类所定义的属性，而不是它运行时所定义的属性。转换。
——要访问子类中特有的方法和属性，在编写代码时，则必须进行类型转换。

—— 以上摘自《疯狂Java讲义》

• 对象的多态 —在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成员变量，因而编译错误。

2.虚拟方法调用(Virtual Method Invocation)

• 正常的方法调用

Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

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

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

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

• 前提：Person类中定义了welcome()方法，各个 子类重写了welcome()。
• 执行：多态的情况下，调用对象的welcome()方法， 实际执行的是子类重写的方法。

3.小结：方法的重载与重写

1. 二者的定义细节：略
2. 从编译和运行的角度看：
   重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不 同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了 不同的方法。==它们的调用地址在编译期就绑定了。==Java的重载是可以包括父类 和子类的，即子类可以重载父类的同名不同参数的方法。
   所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法， 这称为“早绑定”或“静态绑定”；
   而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体 方法，这称为“晚绑定”或“动态绑定”。

引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

4.多态小结

• 多态作用：

• 提高了代码的通用性，常称作接口重用

• 前提：

• 需要存在继承或者实现关系
• 有方法的重写

• 成员方法：

• 编译时：要查看引用变量所声明的类中是否有所调用的方法。
• 运行时：调用实际new的对象所属的类中的重写方法。

• 成员变量：

• 不具备多态性，只看引用变量所声明的类。

instanceof 操作符

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

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。

如果x属于类A的子类B，x instanceof A值也为true。

对象类型转换 (Casting )

• 基本数据类型的Casting：

• 自动类型转换：
• 强制类型转换：

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

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

• 子类继承父类

• 若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的 同名方法，系统将不可能把父类里的方法转移到子类中。
• 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的 实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

面试题：多态是编译时行为还是运行时行为？

package com.codediao.java5;

import java.util.Random;

//面试题：多态是编译时行为还是运行时行为？ 答:运行时行为

//证明如下：
class Animal 

  protected void eat() 
    System.out.println("animal eat food");
  


class Cat extends Animal 

  protected void eat() 
    System.out.println("cat eat fish");
  


class Dog extends Animal 

  public void eat() 
    System.out.println("Dog eat bone");

  



class Sheep extends Animal 

  public void eat() 
    System.out.println("Sheep eat grass");

  



public class InterviewTest 

  public static Animal getInstance(int key) 
    switch (key) 
    case 0:
      return new Cat();
    case 1:
      return new Dog();
    default:
      return new Sheep();
    

  

  public static void main(String[] args) 
    int key = new Random().nextInt(3); // 随机数

    System.out.println(key);

    Animal animal = getInstance(key);// 看不出来结果，是运行时行为，只有运行的时候才知道new的是谁

    animal.eat();

  

七、Object类的使用

• Object类是所有Java类的根父类
• 如果在类的声明中未使用extends关键字指明其父类，则默认父类 为java.lang.Object类

1.Object类中的主要结构

No.	方法名称	类型	描述
1	public Object()	构造	构造器
2	public boolean equals(Object obj)	普通	对象比较
3	public int hashCode()	普通	取得Hash码
4	public String toString()	普通	对象打印时调用

2.==操作符与equals方法

• == ：

• 基本类型比较值:只要两个变量的值相等，即为true。
• 引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。

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

• 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方法，会比较类中的相应属性是否都相等。

public boolean equals(Object anObject) 
        if (this == anObject) 
            return true;
        
        if (anObject instanceof String) 
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) 
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) 
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                
                return true;
            
        
        return false;
    

3. toString() 方法

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

Date now=new Date();
System.out.println(“now=”+now); 相当于
System.out.println(“now=”+now.toString());

• 可以根据需要在用户自定义类型中重写toString()方法 如String 类重写了toString()方法，返回字符串的值。

s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString());

• 基本类型数据转换为String类型时，调用了对应包装类的toString()方法

int a=10; System.out.println(“a=”+a);

八、包装类(Wrapper)的使用

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

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

Byte Short Integer Long Float Double Boolean Character 的父类是Number

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

• 通过包装类的构造器实现：
  ​​​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();​​

• JDK 1.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 + ""

装箱：包装类使得一个基本数据类型的数据变成了类。

有了类的特点，可以调用类中的方法。

int i = 500;
Intefer t = new Integer(i);
String s = t.toString;
String s1 = integer.toString(314);
String s2 = "4.56";
double ds = Double.parseDouble(s2); //将字符串转换成数字

1.包装类的用法举例

• 拆箱：将数字包装类中内容变为基本数据类型。

• int j = t.intValue(); // j = 500，intValue取出包装类中的数据

• 包装类在实际开发中用的最多的在于字符串变为基本数据类型。
  String str1 = "30" ;
  String str2 = "30.3" ;
  int x = Integer.parseInt(str1) ; // 将字符串变为int型
  float f = Float.parseFloat(str2) ; // 将字符串变为int型

public static void method1() 
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i == j); //false
        Integer m = 1;
        Integer n = 1;
        System.out.println(m == n);//true
        Integer x = 128;
        Integer y = 128;
        System.out.println(x == y);//false
    

拓展：垃圾回收机制的说明

垃圾回收机制关键点

垃圾回收机制只回收JVM堆内存里的对象空间。

对其他物理连接，比如数据库连接、输入流输出流、Socket连接无能为力

现在的JVM有多种垃圾回收实现算法，表现各异。

垃圾回收发生具有不可预知性，程序无法精确控制垃圾回收机制执行。

可以将对象的引用变量设置为null，暗示垃圾回收机制可以回收该对象。

程序员可以通过==System.gc()或者Runtime.getRuntime().gc()==来通知系统进行垃圾回收，会有
一些效果，但是系统是否进行垃圾回收依然不确定。

垃圾回收机制回收任何对象之前，总会先调用它的finalize方法（如果覆盖该方法，让一
个新的引用变量重新引用该对象，则会重新激活对象）。

永远不要主动调用某个对象的finalize方法，应该交给垃圾回收机制调用。

拓展：native关键字的理解

使用 native 关键字说明这个方法是原生函数，也就是这个方法是用 C/C++等非 Java 语言实现的，并且被编译成了 DLL，由 java 去调用。

1. 为什么要用 native 方法
   java 使用起来非常方便，然而有些层次的任务用 java 实现起来不容易，或者我们 对程序的效率很在意时，问题就来了。例如：有时 java 应用需要与 java 外面的 环境交互。这是本地方法存在的主要原因，你可以想想 java 需要与一些底层系 统如操作系统或某些硬件交换信息时的情况。本地方法正是这样一种交流机制： 它为我们提供了一个非常简洁的接口，而且我们无需去了解 java 应用之外的繁 琐的细节。
2. native 声明的方法，对于调用者，可以当做和其他 Java 方法一样使用
   一个 native method 方法可以返回任何 java 类型，包括非基本类型，而且同样可 以进行异常控制。 native method 的存在并不会对其他类调用这些本地方法产生任何影响，实际上 调用这些方法的其他类甚至不知道它所调用的是一个本地方法。JVM 将控制调用 本地方法的所有细节。 如果一个含有本地方法的类被继承，子类会继承这个本地方法并且可以用 java 语言重写这个方法（如果需要的话）

拓展：类与类之间的关系说明

对象的关联 — 简单地说，是指一个对象中使用了另一个对象。

依赖关系（Dependency）

对象之间最弱的一种关联方式，是临时性的关联。代码中一般指由局部变量、函数参数、返 回值建立的对于其他对象的调用关系。

class A
  public B method(C c,D d)
    E e = new E();
    ...
    B b = new B();
    ...
    return b;
  

这个代码结构中，表示 A 类依赖了 B,C,D,E 类

关联关系（Association）

对象之间一种引用关系，比如客户类与订单类之间的关系。这种关系通常使用类的属性表达。 关联可以有方向，即导航。一般不作说明的时候，导航是双向的，不需要在线上标出箭头。

大部分情况下导航是单向的，可以加一个箭头表示。

class Employee
  private int eid;//员工编号
  private String name;//员工姓名
  private Computer coumputer;//员工所使用的电脑
  //....

class Computer

class Husband
private Wife wife;

class Wife
private Husband husband;

关联表示类之间的“持久”关系，这种关系一般表示一种重要的业务之间的关系，需要保存 的，或者说需要“持久化”的，或者说需要保存到数据库中的。另外，依赖表示类之间的是 一种“临时、短暂”关系，这种关系是不需要保存的.

聚合（Aggregation）

聚合（关联关系的一种）：表示 has-a 的关系。与关联关系一样，聚合关系也是通过实例变 量来实现这样关系的。关联关系和聚合关系来语法上是没办法区分的，从语义上才能更好的 区分两者的区别。 如汽车类与引挚类，轮胎类之间的关系就是整体与个体的关系。 与关联关系一样，聚合关系也是通过实例变量来实现的。空心菱形

class Car
  private Engine engine;//引擎
  private Tyre[] tyres;//轮胎

关联和聚集（聚合）的区别： 关联关系所涉及的两个对象是处在同一个层次上的。比如人和自行车就是一种关联关系，而 不是聚合关系，因为人不是由自行车组成的。 聚合关系涉及的两个对象处于不平等的层次上，一个代表整体，一个代表部分。比如电脑和 它的显示器、键盘、主板以及内存就是聚集关系，因为主板是电脑的组成部分。

组合（Composite）

继承（Generalization，又称为泛化，is-a 的关系）