面向对象编程(中)

1.面向对象特征之二：继承性

1.1 概述

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

继承那一个类即可。如图所示：

2022-09-08_163059

其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，例如图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接

访问父类中的非私有的属性和行为。

好处:

提高代码的复用性。
类与类之间产生了关系，是多态的前提。

1.2 继承的格式

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 { ... }
class 子类 extends 父类 { ... }

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

一个子类只能有一个父类
一个父类可以派生出多个子类
- class SubDemo extends Demo{ } //ok
- class SubDemo extends Demo1,Demo2...//error

2022-09-08_164810

1.3 方法的重写

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

要求：

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

注意：

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

举例：

public class Person {
	public String name;
	public int age;
	public String getInfo() {
	return "Name: "+ name + "\n" +"age: "+ age;
	} 
}
public class Student extends Person {
	public String school;
	public String getInfo() { //重写方法
	return "Name: "+ name + "\nage: "+ age + "\nschool: "+ school;
}
public static void main(String args[]){
	Student s1=new Student();
	s1.name="Bob";
	s1.age=20;
	s1.school="school2";
	System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
	} 
}

2022-09-08_165241

1.4 四种访问权限修饰符

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

2022-09-08_165410

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

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

1.5 关键字：super

1.5.1 功能

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

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

注意：

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

class Person {
	protected 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());
	}
}

1.5.2 调用父类的构造器

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

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; 
    } 
}

1.5.3 this和super的区别

2022-09-08_170455

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。理解图解如下：

2022-09-08_171145

1.5.4 子类对象实例化过程

2022-09-08_170619

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

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

2.面向对象特征之三：多态性

2.1 概述

多态性，是面向对象中最重要的概念，在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成员变量，因而编译错误。

小结：

多态作用：

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

前提：

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

成员方法：

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

成员变量：

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

2.2 instanceof 操作符

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

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

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

2.3 对象类型转换

基本数据类型的Casting：
1. 自动类型转换：小的数据类型可以自动转换成大的数据类型如long g=20; double d=12.0f
2. **强制类型转换：**可以把大的数据类型强制转换(casting)成小的数据类型如 float f=(float)12.0; int a=(int)1200L

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

从子类到父类的类型转换可以自动进行
从父类到子类的类型转换必须通过造型(强制类型转换)实现

无继承关系的引用类型间的转换是非法的

public class ConversionTest {
public static void main(String[] args) {
	double d = 13.4;
	long l = (long) d;
	System.out.println(l);
	int in = 5;
	// boolean b = (boolean)in;
	Object obj = "Hello";
	String objStr = (String) obj;
	System.out.println(objStr);
	Object objPri = new Integer(5);
	// 所以下面代码运行时引发ClassCastException异常
	String str = (String) objPri; 
	} 
}

在造型前可以使用instanceof操作符测试一个对象的类型

public class Test {
	public void method(Person e) { // 设Person类中没有getschool() 方法
		// System.out.pritnln(e.getschool()); //非法,编译时错误
		if (e instanceof Student) {
		Student me = (Student) e; // 将e强制转换为Student类型
		System.out.pritnln(me.getschool());
		} 
    }
public static void main(String[] args){
	Test t = new Test();
	Student m = new Student();
	t.method(m);
	} 
}

2022-09-08_174803

2.4 继承成员变量和继承方法的区别

子类继承父类

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

3.Object类的使用

3.1 概述

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

public class Person {
...
}
等价于：
public class Person extends Object {
...
}

3.2 Object类的注意结构

2022-09-08_175117

3.3 ==操作符与equals方法

==操作符
- 基本类型比较值:只要两个变量的值相等，即为true。
- 引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回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方法区别：

== 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值，对于引用类型就是比较内存地址
equals的话，它是属于java.lang.Object类里面的方法，如果该方法没有被重写过默认也是==;我们可以看到String等类的equals方法是被重写过的，而且String类在日常开发中用的比较多，久而久之，形成equals是比较值的错误观点。
具体要看自定义类里有没有重写Object的equals方法来判断。
通常情况下，重写equals方法，会比较类中的相应属性是否都相等。

3.4 重写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”。

3.5 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()方法

4.包装类的使用

4.1 概述

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

2022-09-08_190517

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

通过包装类的构造器实现：

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

4.2 基本类型、包装类与String类间的转换

2022-09-08_191830

# 面向对象编程(中)

# 1.面向对象特征之二：继承性

# 1.1 概述

# 1.2 继承的格式

# 1.3 方法的重写

# 1.4 四种访问权限修饰符

# 1.5 关键字：super

# 1.5.1 功能

# 1.5.2 调用父类的构造器

# 1.5.3 this和super的区别

# 1.5.4 子类对象实例化过程

# 2.面向对象特征之三：多态性

# 2.1 概述

# 2.2 instanceof 操作符

# 2.3 对象类型转换

# 2.4 继承成员变量和继承方法的区别

# 3.Object类的使用

# 3.1 概述

# 3.2 Object类的注意结构

# 3.3 ==操作符与equals方法

# 3.4 重写equals()方法的原则

# 3.5 toString()方法

# 4.包装类的使用

# 4.1 概述

# 4.2 基本类型、包装类与String类间的转换