274 super调用属性和方法
super关键字的使用
1.super理解为：父类的
2.super可以用来调用：属性，方法，构造器
3.super的使用：调用属性和方法
3.1 我们可以在子类的方法或构造器中，通过使用“super.属性”或“super.方法”的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略“super.”
3.2 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用super.属性的方式，表明调用的的是父类中声明的属性
3.3 特殊情况：当子类重写了父类中的方法时，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用super.方法的方式，表明调用的的是父类中声明的属性
275 super调用构造器
4.super调用构造器
4.1我们可以在子类的构造器中显式的使用super（形参列表）的方式，调用父类中声明的构造器
4.2super（形参列表）的使用，必须声明在子类构造器的首行
4.3我们在类的构造器中，针对于this（形参列表）或super（形参列表）只能二选一，不能同时出现
4.4在构造器的首行，没有显式的声明this（形参列表）或super（形参列表），则默认调用的是父类中空参的构造器：super（）
4.5 在类的多个构造器中，至少有一个类的构造器中使用了super（形参列表），调用了父类的构造器
276 子类对象实例化的全过程
1.从结果上来看：（继承性）
子类继承父类以后，就获取了父类中声明的属性或方法
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性
2.从过程上来讲
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用
明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象
277 继承和super课后练习
写一个名为Account的类模拟账户。该类的属性和方法如下图所示。
* 该类包括的属性：账号id，余额balance，年利率annualInterestRate；
* 包含的方法：访问器方法（getter和setter方法），
* 返回月利率的方法getMonthlyInterest()，
* 取款方法withdraw()，存款方法deposit()。
写一个用户程序测试Account类。在用户程序中，
* 创建一个账号为1122、余额为20000、年利率4.5%的Account对象。
* 使用withdraw方法提款30000元，并打印余额。再使用withdraw方法提款2500元，
* 使用deposit方法存款3000元，然后打印余额和月利率。
* 创建Account类的一个子类CheckAccount代表可透支的账户，该账户中定义一个属性overdraft代表可透支限额。
* 在CheckAccount类中重写withdraw方法，其算法如下：
* 如果（取款金额<账户余额），
* 可直接取款
* 如果（取款金额>账户余额），
* 计算需要透支的额度
* 判断可透支额overdraft是否足够支付本次透支需要，如果可以
* 将账户余额修改为0，冲减可透支金额
* 如果不可以
* 提示用户超过可透支额的限额
写一个用户程序测试CheckAccount类。在用户程序中，
* 创建一个账号为1122、余额为20000、年利率4.5%，
* 可透支限额为5000元的CheckAccount对象。
* 使用withdraw方法提款5000元，并打印账户余额和可透支额。
* 再使用withdraw方法提款18000元，并打印账户余额和可透支额。
* 再使用withdraw方法提款3000元，并打印账户余额和可透支额。
278 多态性的使用
1.理解多态性，可以理解为一个事物的多种形态
2.何为多态性
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
3.多态的使用：虚拟方法调用
有了对象的多态性之后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法
总结：编译，看左边；运行，看右边
4.多态性使用前提：
4.1 要有类的继承关系
4.2方法的重写
279 多态性使用举例
280 多态性不适用于属性
5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
281 虚拟方法调用的再理解
2.从编译和运行的角度看：
* 重载，是指允许存在多个同名方法，而这些方法的参数不同。
* 编译器根据方法不同的参数表，对同名方法的名称做修饰。
* 对于编译器而言，这些同名方法就成了不同的方法。
* 它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，
* 即子类可以重载父类的同名不同参数的方法。所以：对于重载而言，在方法调用之前，
* 编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
* 而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，
* 这称为“晚绑定”或“动态绑定”。
*
* 引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
*/
//面试题：多态是编译时行为还是运行时行为？
//证明如下：
class Animal {
protected void eat() {
System.out.println("animal eat food");
}
}
class Cat extends java核心基础279讲解 Animal {
protected void eat() {
System.out.println("cat eat fish");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("Dog eat bone");
}
}
class Sheep extends Animal {
public void eat() {
System.out.println("Sheep eat grass");
}
}
public class InterviewTest {
public static Animal getInstance(int key) {
switch (key) {
case 0:
return new Cat ();
case 1:
return new Dog ();
default:
return new Sheep ();
}
}
System.out.println(key);
Animal animal = getInstance(key);
animal.eat();
}
}
285 向下转型的过程
286 instanceof关键字的使用
a instanceof A:判断对象a是否是类A的实例。如果是，返回true；如果不是，返回false
实用情景：为了避免在向下转型时出现ClassCastExpection的异常，我们在向下转型之前，先进行intstanceof的判断，一旦返回true，就进行向下转型，如果返回false，不进行向下转型
如果a instanceof A返回true，则a instanceof B也返回true
其中，类B是类A的父类
287 向下转型的几个问题
练习
问题一：编译时通过，运行时不通过
//举例一
//Person p3=new Woman()；
//Man m3=(Man) p3;
//举例二
Person p4=new Person();
Man m4=(Man)p4;
问题二：编译通过，运行时也通过
Object obj=new Woman();
Person p=(Person)obj;
//问题三：编译不通过 不相关的两个类不能运行
Man m5=new Woman();
String str=new Date();
Object o=new Date();
String str1=(String)o;
288 多态练习：调用方法和属性
练习：
1.若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，
* 系统将不可能把父类里的方法转移到子类中。编译看左边，运行看右边
*
* 2.对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，
* 这个实例变量依然不可能覆盖父类中定义的实例变量：编译运行都看右边
289 多态性练习：基本操作
建立InstanceTest 类，在类中定义方法method(Person e);
*
* 在method中:
* (1)根据e的类型调用相应类的getInfo()方法。
* (2)根据e的类型执行：
* 如果e为Person类的对象，输出：“a person”;
* 如果e为Student类的对象，输出：“a student”“a person ”
* 如果e为Graduate类的对象，输出：“a graduated student”
* “a student” “a person”
版权声明：
本文来源网络，所有图片文章版权属于原作者，如有侵权，联系删除。
本文网址：https://www.bianchenghao6.com/h6javajc/25458.html