IDE的使用

Debug调试

面向对象-中

方法的重写

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

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

2.应用

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

3.举例

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

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

class Account{
    public boolean withdraw(double amount){}
}

class CheckAccount{
    public boolean withdraw(double amount){}
}

4.重写的规则

* 方法的声明：权限修饰符 返回值类型 方法名（形参列表）throws 异常的类型{
* //方法体
* }
* 约定俗成，子类中的叫重写的方法，父类中的叫被重写的方法
* ① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
* ② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
* >特殊情况：子类不能重写父类中声明为private权限的方法
* ③ 返回值类型：
* >父类被重写的方法的返回值类型是void,则子类重写的方法的返回值类型也是void
* >父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或者A类的子类
* >父类被重写的方法的返回值类型是基本数据类型（比如double），则子类重写的方法的返回值类型必须是相同的基本数据类型（必须也是double）
* ④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
************************************************
* 子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）

5.面试题

区分方法的重载与重写

答：

① 二者的概念：

② 重载和重写的具体规则

③ 重载：表现为多态性

    重写：不表现为多态性

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

关键字：super

1.super关键字可以理解为：父类的

2.可以用来调用的结构：

属性、方法、构造器

3.super调用属性、方法：

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

4.super调用构造器

* 4.1 我们可以在子类的构造器中显式的使用“super（形参列表）”的方式，调用父类中声明的指定的构造器
* 4.2 “super(形参列表)”的使用，必须声明在子类构造器的首行！
* 4.3 我们在类的构造器中，针对于“this(形参列表)”或“super(形参列表)”只能二选一，不能同时出现。
* 4.4 在构造器的首行，没有显式的声明“this(形参列表)”或“super(形参列表)”，则默认调用的是父类中空参构造器。
* 即 super()
* 4.5 在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”，调用父类的构造器。

子类对象实例化全过程

理解即可。

1.从结果上来看：继承性

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

2.从过程上来看

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

图示：

3.强调说明

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

面向对象的特征三：多态性

1.多态性的理解：可以理解为一个食物的多种形态。

2.何为多态性：

* 对象的多态性：父类的引用指向子类的对象（或子类的对象付给父类的引用）

举例：

Person p = new Man();

Object obj = new Date();

3.多态性的使用：虚拟方法调用

* 有了对象的多态性以后，我们在编译期，只能调用父类中声明的结构，但在运行期，我们实际执行的是子类重写父类的方法
* 总结：编译看左，运行看右

4.多态性的使用前提

① 类的继承关系 ② 方法的重写

5.多态性的应用举例

举例一：

1     public void func(Animal animal) {
2         animal.eat();
3         animal.shout();
4     }

举例二:

1 class Order{
2     public void method(Object obj) {
3         
4     }
5 }

举例三：

1 class Driver{
2     public void getData(Connection conn) {///conn = new MySQLConnection
3         //规范的步骤去操作数据
4 //        conn.method1();
5 //        conn.method2();
6 //        conn.method3();
7         
8     }
9 }

6.多态性使用的注意点：

对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）。

Java基础教程----面向对象（中）

原文：https://www.cnblogs.com/saltedfishxiaowang/p/13525348.html