this关键字 、super关键字、多态性

this关键字 

1.目前可能出现的问题？解决？

声明一个属性对应的setXxx方法时，通过形参给i对应的属性赋值。形参如果和属性名同名 了，如何在方法区内区分这两个变量？

解决：使用this。使用this修饰的变量，表示的是属性；没有用this修饰的表示的是形参。

2.this可以调用的结构：

成员变量、方法、构造器

3.this的理解：

当前对象（在方法中调用时） 或 当前正自创建的对象（在构造器中调用时）

4.this调用属性和方法

一般情况:我们通过对象a调用方法，可以在方法内调用当前对象a的属性或其他方法。此时，我们可以在使用"this."，表示当前属性或方法所属的对象a。
但是，一般情况下，我们都选择省略此"this"结构。特殊情况:如果方法的形参与对象的属性同名了，我们必须使用"this"进行区分。
使用this修饰的变没有使用this.修饰的变量，即为局部变量。

【针对于构造器内的使用情况:】
一般情况:我们通过构造器创建对象时，可以在构造器内调用当前正在创建的对象的属性或方法。此时，我使用"this"，表示当前属性或方法所属的对象。
但是，一般情况下，我们都选择省略此"this"结构。
特殊情况:如果构造器的形参与正在创建的对象的属性同名了，我们必须使用"this"进行区分。使用th属性(或成员变量)，没有使用this修饰的变量，即为局部变量。

4.1this调用构造器

>格式："this(形参列表)"
>我们可以在类的构造器中，调用当前类中指定的 其他 构造器
>要求："this(形参列表)"必须声明在当前构造器的首行
>结论："this(形参列表)"在构造器中最多声明一个
>如果一个类中声明了n个构造器，则最多有n-1个构造器可以声明有"this(形参列表)"的结构

test1、test2测温hi四种权限修饰符的使用频率？

public、private频率最高

二、方法的重写override/overwrite

1。为什么需要方法重写？

子类在继承父类以后，就获取了弗雷声明的所有方法。但是父类肯不太适用于子类，换句话说你，子类需要对父类中继承过来的方法进行覆盖、覆写的操作。

2.何为方法重写？

子类对父类继承过来的方法进行覆盖、覆写的操作。

3.方法重写应遵循的规则？

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

具体规则：

1.父类被重写的方法必须和子类重写的方法的方法名和形参列表必须相同
2.子类重写的方法的权限修饰符必须不小于弗雷被重写的权限修饰符
>子类不能重写父类中声明为private修饰的方法
3.返回值类型：
>父类被重写的方法的返回值类型是void，子类重写的方法的返回值类型必须是void
>父类被重写的方法的返回值类型是基本数据类型，子类重写的方法的返回值类型必须与被重写的方法的返回值类型相同
>父类被重写的方法的返回值类型是引用数据类型（比如类），子类重写的方法的返回值类型可以与被重写的方法的返回值类型相同
或 是被重写的方法的返回值类型的子类
4.子类重写的方法抛出的异常可以与父类被重写的方法抛出的异常相同，或是父类被重写的方法抛出的异常类型的子类

4.重载和重写区别？

重载：“两同一不同”
重写：继承以后，子类覆盖父类中同名同参数的方法

 

super关键字

一、super关键字的使用

1.为什么需要super？

举例1：子类继承父类以后，对父类的方法进行重写，那么在子类中是否还可以对父类中被重写 的方法进行调用？
可以
举例2：子类继承父类以后，发现子类和父类中定义了同名的属性，是否可以在子类中区分两个同名的属性？
可以
如何调用？
使用super关键字

2.super的理解：父类的

3.super可以调用的结构：

属性、方法、构造器

具体:

3.1 super调用属性、方法

子类继承父类以后，我们就可以在子类的方法或构造器中，调用父类中声明的属性或方法。（满足封装性前提下）
|一般情况下，可以考虑省略“super.”结构。但是如果出现子类与父类有同名属性时，必须要用super声明，显式调用父类的属性

3.2 super调用构造器

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

二、 子类对象实例化的全过程

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

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

* 2. 从过程上来看：

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

* 明确：

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

多态性 

1.如何理解多态性？

>是运行时行为
>如果没有多态性，抽象类和接口的出现就没有意义

理解：一个事务的多种形态。

举例：
>我想养一个宠物。
>我想要一个玩具。
>我需要一个同事和我一起出差。

2.Java中多态性的体现:

子类对象的多态性[狭义的理解]：父类的引用指向子类的对象。（或者 子类的对象赋给父类的引用）
比如：Person p2 = new Man();

3.多态性的应用【虚拟方法调用】

多态场景下，调用方法时：
编译时，认为方法是左边声明的父类类型的方法
执行时，实际执行的是子类重写父类的方法（即：被重写的方法）
编译看左边，运行看右边

4.多态性使用前提

要有类的继承关系
要有方法的重写

5.适用性

只适用于方法，不适应与属性

6.多态的好处与弊端

好处：极大地减少了代码的冗余，不需要重新定义多个重载的方法
eg：
class Account(){}
class CheckAcount extends Account(){
//存在方法的重写
}
class SavingAcount extends Account(){
//存在方法的重写
}
class Customer{
Account account;
public void setAccount(Account account)
this.account = account;
}
class CustomerTest(){
main(){
Customer cust = new Customer();
cust.setAccount(new CheckAccount());
cust.getAccount().witdraw();
}}
弊端：在多态场景下，我们创建类子类的对象，也加载了子类特有的属性和方法。但由于声明为父类的引用，导致我们没有部分直接调用子类特有的属性和方法。

7.instanceof的使用

*建议在向下转型之前用instanceof进行判断，避免出现类型转换异常
* 格式： a instanceOf A ：判断对象a是否是类A的实例
* 如果a instanceOf A 返回 true，则：
* a instanceOf superA 返回也是true。A是superA的子类

java.lang.Object类

-Object类是所有Java类的根父类
-如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
-Object类中的功能(属性、方法)就具有通用性。
>Object类中没有声明属性
>Object类提供空参构造器

重点方法：equals() / toString()
了解方法：clone() / finalize()
目前不关注：getClass() \ hashCode() \ notify() \ notifyAll() \ wait() \ wait(xx) \ wait(xx,yy)

* 面试题：

final、finally、finalize的区别？

3.equals的使用

3.1适用性：任何数据类型都可以使用。

3.2 java.lang.Object类中equals()的定义：

public boolean equals(Object obj) {
return (this == obj);
}

3.3子类使用说明：

>自定义的类在没有重写Object中的equals()方法的情况下，调用的就是Object类中声明的equals()，比较两个对象的引用地址是否相同。（或比较两个对象是否指向了堆空间中的同一个对象实体）
>对于像String、File、Date和包装类等，他们都重写了Object类中的equals()方法，用于比较两个对象的实体内容是否相等。

3.4开发中使用说明

>实际开发中，针对自定义的类，常常会判断两个对象是否equals();而此时主要是判断两个对象的属性值是否相等。
使用我们要重写Object类的equals()方法。
>如何重写：
手动实现
调用idea自动实现（推荐）

3.5高频面试题：

区分 == 和 equals()
==：运算符
①适用范围：基本数据类型、引用数据类型
②
基本数据类型：判断数据值是否相等？

int i1 = 10;
int i2 = 10;
sout(i1 == i2);//true

char c1 = 'A';
int i3 = 65;
sout(c1 == i3);//true

float f1 = 12.0F;
int i4 = 12;
sout(f1 == i4);//true;
引用数据类型：比较两个引用变量的地址值是否相等。（或比较两个引用是否指向了堆空间中的同一个对象实体）
equals()：方法
>使用范围： 引用数据类型
>具体使用：对于类来说，重写equals()和不重写equals()的区别。

4.toString的使用

4.1 Object类中toString()定义

public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

4.2开发中的使用场景

>平时调用System.out.println()打印对象引用变量时，其实就调用了对象的toString()

4.3子类的使用说明

>自定义的类，在没有重写Object类的toString()的情况下，默认返回当前对象的地址值。
>像String、File、Date或包装类等Object的子类，他们都重写了Object类的toString()，在调用toString()时，返回当前对象的实体内容。

4.4开发中说明

>习惯上，开发中对于自定义的类在调用toString()时，也希望显示其对象的实体内容，而非地址值。这时候就需要重写Object类中的toString()方法。