JavaSE_day12：面向对象（中）

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

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

• ① 减少了代码的冗余，提高了代码的复用性
• ② 便于功能的扩展
• ③ 为之后多态性的使用，提供了前提
  

1.2 继承性的格式
A：子类、派生类、subclass
B：父类、超类、基类、superclass

class A extends B{}

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

• 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私的结构。只因为封装性的影响，使得子类不能直接调用父类的结构而已。
• 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。 子类和父类的关系，不同于子集和集合的关系。extends：延展、扩展

1.4 Java中继承性的说明

• 一个类可以被多个子类继承。
• Java中类的单继承性：一个类只能有一个父类
• 子父类是相对的概念。
• 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类
• 子类继承父类以后，就获取了直接父类以及所间接父类中声明的属性和方法
  

1.5 java.lang.Object类的理解

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

2. 方法的重写

2.1 什么是方法的重写（override 或 overwrite）？

• 子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

2.2 应用：

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

2.3 举例

class Circle{
	public double findArea(){}//求面积
}
class Cylinder extends Circle{
	public double findArea(){}//求表面积
}

2.4 重写的规则:

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

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
①子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
②子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
③特殊情况：子类不能重写父类中声明为private权限的方法
④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
⑤子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写)。
⑥返回值类型：

• 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
• 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类

2.5 面试题
区分方法的重写和重载？
① 二者的概念：

• 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写。
• 重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

② 重载和重写的具体规则
③ 重载：不表现为多态性。重写：表现为多态性。（多态一般是类与类之间发生的，但也有说重载也表现多态性）

https://www.runoob.com/java/java-override-overload.html

3. 关键字：super

3.1 super 关键字可以理解为：父类的
3.2 可以用来调用的结构：属性、方法、构造器
3.3 super调用属性、方法：

• 我们可以在子类的方法或构造器中。通过使用super.属性或super.方法的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略super.
• 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用super.属性的方式，表明调用的是父类中声明的属性。
• 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用super.方法的方式，表明调用的是父类中被重写的方法。

3.4 super调用构造器:

• 我们可以在子类的构造器中显式的使用super(形参列表)的方式，调用父类中声明的指定的构造器
• super(形参列表)的使用，必须声明在子类构造器的首行
• 我们在类的构造器中，针对于this(形参列表)或super(形参列表)只能二选一，不能同时出现
• 在构造器的首行，没显式的声明this(形参列表)或super(形参列表)，则默认调用的是父类中空参的构造器：super()
• 在类的多个构造器中，至少一个类的构造器中使用了super(形参列表)，调用父类中的构造器

Person.java

public class Person {
	String name;
	int age;
	int id = 1001;//身份证号
	
	public Person(){
		System.out.println("我无处不在！");
	}
	
	public Person(String name){
		this.name = name;
	}
	
	public Person(String name,int age){
		this(name);
		this.age = age;
	}
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	public void walk(){
		System.out.println("人：走路");
	}
}

Student 继承 Person

public class Student extends Person{
	
	String major;
	int id = 1002;//学号
	
	public Student(){
		super();
	}
	public Student(String major){
		super();
		this.major = major;
	}
	
	public Student(String name,int age,String major){
//		this.name = name;
//		this.age = age;
		super(name,age);
		this.major = major;
	}
	
	@Override
	public void eat() {
		System.out.println("学生：多吃有营养的食物");
	}
	
	public void study(){
		System.out.println("学生：学习知识");
		this.eat();
		super.eat();
		walk();
	}
	
	public void show(){
		System.out.println("name = " + name + ", age = " + age);
		System.out.println("id = " + this.id);
		System.out.println("id = " + super.id);
	}
}

SuperTest测试关键字super

public class SuperTest {
	public static void main(String[] args) {
		
		Student s = new Student();
		s.show();
		
		System.out.println();
		
		s.study();
		Student s1 = new Student("Tom", 21, "IT");
		s1.show();
		
		System.out.println("************");
		Student s2 = new Student();
		
	}
}

4. 子类对象实例化全过程

4.1 从结果上看：继承性

• 子类继承父类以后，就获取了父类中声明的属性或方法。
• 创建子类的对象，在堆空间中，就会加载所父类中声明的属性。

4.2 从过程上看：

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

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