Java自学基础 面向对象（中）

---

前言

面向对象（上）
面向对象（中）
面向对象（下）

---

一、OOP特征二：继承性

1.为什么要有类的继承性？(继承性的好处）

• 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
  那么多个类无需再定义这些属性和行为，只要继承那个类即可。
• 减少了代码的冗余，提高了代码的复用性
• 便于功能的扩展
• 为之后多态性的使用，提供了前提

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

2.继承性的格式：

class A extends B{}

• A:子类、派生类、subclass
• B:父类、超类、基类、superclass

3.子类继承父类以后有哪些不同？

• 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
  • 特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。(不可见，可以使用get set 方法获取)

即：子类不能直接访问父类中私有的(private)的成员变量和方法。

• 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
  • 子类和父类的关系，不同于子集和集合的关系。
  • 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，
    而是对父类的“扩展”。
  • extends：延展、扩展

4.Java中继承性的说明

1. 一个类可以被多个子类继承。

2. Java中类的单继承性：一个类只能有一个父类
   即：Java只支持单继承和多层继承，不允许多重继承
   

3. 子父类是相对的概念。(各个类都是往上继承，且所有类的最终父类都是 java.lang.Object )

4. 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类

5. 子类继承父类以后，就获取了直接父类以及间接父类中声明的属性和方法

5.java.lang.Object类的理解

1. 如果我们没显式的声明一个类的父类的话，则此类继承于java.lang.Object类
2. 所的java类（除java.lang.Object类之外都直接或间接的继承于java.lang.Object类
3. 意味着，所的java类具有java.lang.Object类声明的功能。

二、方法的重写(override)

定义

子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。
在程序执行时，子类的方法将覆盖父类的方法。

要求

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

2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
   （可以是父类返回值类型的子类，但不能是父类返回值类型的父类）

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

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

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

重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。

---

重写的规则：

方法的声明：

权限修饰符  返回值类型  方法名(形参列表) throws 异常的类型{
					//方法体
}

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

1. 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同（方法名和形参列表必须相同才构成重写）

2. 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

   特殊情况：子类不能重写父类中声明为private权限的方法

3. 返回值类型：

   • 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
   • 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
   • 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)

4. 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）

如何区分方法的重写和重载？

① 二者的概念
② 重载和重写的具体规则
③ 重载：不表现为多态性。
重写：表现为多态性。

三、四种访问权限修饰符

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

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

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

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

举例： 定义一个Order类

 类内部可以调用所有权限

package com.zhu.java3;

public class Order {
    public int orderPublic = 1;
    int orderDefault = 1;
    protected int orderProtected = 1;
    private int orderPrivate = 1;

    public void methodPublic() {
        orderPublic = 1;
        orderDefault = 1 ;
        orderProtected = 1;
        orderPrivate = 1;
    }

    void methodDefault() {}

    protected void methodProtected() {}

    private void methodPrivate() {}

}

同一个包内可以调用除private权限外

package com.zhu.java3;

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();

        order.orderPublic = 1;
        order.orderProtected = 1;
        order.orderDefault = 1;
//        order.orderPrivate = 1;
        
        order.methodPublic();
        order.methodProtected();
        order.methodDefault();
//        order.methodPrivate();
        
    }
}

非同一包内非子类，只能调用public，若要调用protected，则需要当前包内的Order的子类来调用

package com.zhu.java2;
import com.zhu.java3.Order;

public class OrderTest {
    public static void main(String[] args) {
        Order order = new Order();

        order.orderPublic = 1;
//        order.orderProtected = 1;
//        order.orderDefault = 1;
//        order.orderPrivate = 1;

        order.methodPublic();
//        order.methodProtected();
//        order.methodDefault();
//        order.methodPrivate();

    }
}

四、关键字：super

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

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

注意：

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

super关键字的使用

1. super理解为：父类的

2. super可以用来调用：属性、方法、构造器

3. super的使用：调用属性和方法

   我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."

   特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

   特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

4. super调用构造器

   • 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器

   • "super(形参列表)"的使用，必须声明在子类构造器的首行！

   • 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现

   • 在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器：super()

   • 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器

调用父类的构造器

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

this和super的区别

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

五、子类对象实例化过程

1. 从结果上来看：（继承性）
   子类继承父类以后，就获取了父类中声明的属性或方法。
   创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。
2. 从过程上来看：
   当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…
   直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有
   父类中的结构，子类对象才可以考虑进行调用。

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

六、OOP特征三：多态性

• 多态性，是面向对象中最重要的概念，在Java中的体现：

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

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

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

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

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

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

简单举例

定义一个父类Animal 两个子类Cat和Dog，都重写父类的两个方法

package com.zhu.java5;

public class Animal {

    public void eat(){
        System.out.println("动物吃粮食");
    }
    public void shout(){
        System.out.println("动物会叫");
    }

}

class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }

    @Override
    public void shout() {
        System.out.println("汪汪汪?");
    }
}

class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("小猫吃鱼");
    }

    @Override
    public void shout() {
        System.out.println("喵喵喵?");
    }
}

测试类测试方法形参为父类，分别传入子类，则输出结果为子类重写父类的方法！

package com.zhu.java5;

public class AnimalTest {
    public static void main(String[] args) {
        fuc(new Cat());
        fuc(new Dog());
    }

    private static void fuc(Animal animal){ 等同于 ( Animal animal = new new Dog(); )
        animal.eat();
        animal.shout();

        if (animal instanceof Cat){
            System.out.println("Cat子类!");
        }

    }
}
输出结果:

小猫吃鱼
喵喵喵?
Cat子类!
小狗吃骨头
汪汪汪?

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

虚拟方法调用(Virtual Method Invocation)

• 正常的方法调用

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

• 虚拟方法调用(多态情况下)
  子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父
  类根据赋给它的不同子类对象，动态调用属于子类的该方法(该方法重写了父类的方法)。这样的方法调用在编译期是无法
  确定的。
• 编译时类型和运行时类型
  编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类 的getInfo()方法。——动态绑定

方法的重载与重写

1. 二者的定义细节：

   1. 重载发生类本身，类内部同名不同形参的方法，无关返回值类型
   2. 重写发生在子父类之间，子类方法名，形参与父方法名形参相同，子类异常与返回值类型不能大于父类

2. 从编译和运行的角度看：

   重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不
   同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了
   不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类
   和子类的，即子类可以重载父类的同名不同参数的方法。
   所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，
   这称为“早绑定”或“静态绑定”； 而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体
   方法，这称为“晚绑定”或“动态绑定”。
   引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”

多态小结

• 多态作用：
  提高了代码的通用性，常称作接口重用
• 前提：
  需要存在继承或者实现关系
  有方法的重写
• 成员方法：
  编译时：要查看引用变量所声明的类中是否有所调用的方法。
  运行时：调用实际new的对象所属的类中的重写方法。
• 成员变量：
  不具备多态性，只看引用变量所声明的类。（左边）

instanceof 操作符

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

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

总之必须有子父类关系

对象类型转换 (Casting )

• 基本数据类型的Casting：
  • 自动类型转换：小的数据类型可以自动转换成大的数据类型
    如long g=20; double d=12.0f
  • 强制类型转换：可以把大的数据类型强制转换(casting)成小的数据类型
    如 float f=(float)12.0; int a=(int)1200L
• 对Java对象的强制类型转换称为造型
  • 从子类到父类的类型转换可以自动进行
  • 从父类到子类的类型转换必须通过造型(强制类型转换)实现
  • 无继承关系的引用类型间的转换是非法的
  • 在造型前可以使用instanceof操作符测试一个对象的类型(判断)

子类继承父类

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

关于向上转型与向下转型：

• 向上转型：多态
• 向下转型：

  • 为什么使用向下转型：
    有了对象的多态性以后，内存中实际上是加载了子类(左边)特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类(右边)中声明的属性和方法。子类特有的属性和方法不能调用。如何才能调用子类特的属性和方法？使用向下转型。

  • 如何实现向下转型：
    使用强制类型转换符：()

  • 使用时的注意点：
    使用强转时，可能出现ClassCastException的异常。
    为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

  • instanceof的使用：
    a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false。
    要求a所属的类与类A必须是子类和父类的关系，否则编译错误。

七、Object类的使用

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

Object类中的主要结构

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

==操作符与equals方法

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

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

• equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写。
  • 只能比较引用类型（类），其作用与“==”相同,比较是否指向同一个对象。
  • 格式:obj1.equals(obj2)
• 特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；

原因：在这些类中重写了Object类的equals()方法。所以通常在自定义的类中重写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”。

toString() 方法

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

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

• 可以根据需要在用户自定义类型中重写toString()方法
• 基本类型数据转换为String类型时，调用了对应包装类的toString()方法

char[] arr = new char[] { 'a', 'b', 'c' };
System.out.println(arr);//输出结果  abc
int[] arr1 = new int[] { 1, 2, 3 };
System.out.println(arr1);//输出结果  [I@704921a5
double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
System.out.println(arr2);//输出结果  [D@df27fae

八、包装类的使用

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

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

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

• 通过包装类的构造器实现:

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 + "";

包装类用法举例

int i = 500;
Integer t = new Integer(i);

装箱：包装类使得一个基本数据类型的数据变成了类。
有了类的特点，可以调用类中的方法。

String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。
String s2="4.56";
double ds=Double.parseDouble(s2); //将字符串转换成数字

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

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型

自动拆装箱

Integer in1 = 10;//自动装箱
int in2 = in1;	 //自动拆箱

---

总结

本章主要讲述子父类之间继承所带来的面向对象的特性，主要包含方法的重写，重写后发生的多态，还有对象的上下转型，其中各个关键词的使用如this、super。 将基础数据类型引入Java面向对象的各个包装类