Java-day12（面向对象中2 Debug 调试方法的重写多态性）

继承性练习一

在这里插入图片描述
Circle类：

package com.acoffee.exer;

public class Circle {
	private double radius;//半径
	
	public Circle() {
		this.radius = 1.0;
	}
	
	public void setRadius(double radius) {
		this.radius = radius;
	}
	
	public double getRadius() {
		return radius;
	}
	
	public double findArea() {
		return Math.PI*getRadius()*getRadius();
	}
	
}

Cylinder类：

package com.acoffee.exer;

public class Cylinder extends Circle{
	private double length;//高
	
	public Cylinder() {
		this.length = 1;
	}
	
	public void setLength(double length) {
		this.length = length;
	}
	
	public double getLength() {
		return length;
	}
	
	public double findVolume() {
		return findArea()*getLength();
	}
	
}

CylinderTest类：

package com.acoffee.exer;

public class CylinderTest {
	public static void main(String[] args) {
		
		Cylinder c = new Cylinder();
	
		c.setLength(2.0);
		c.setRadius(2.5);
		
		double volume = c.findVolume();
		System.out.println("圆柱的体积："+ volume);
		
		double area = c.findArea();
		System.out.println("底面圆的面积："+ area);
	}
}

Debug调试

在代码左侧双击打断点，然后Debug as就可以进入页面.

可能存在的问题：
当你去点击step info时没有进入到方法，而是直接进入下一行就直接跟step over一样，这个是因为Debug的配置出现了问题我们默认配置的是jre 但是我们需要配置jdk.

在这里插入图片描述

方法的重写

在这里插入图片描述

1.重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作
2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
1. 重写的规定：
方法的声明：权限修饰符返回值类型方法名(形参列表) throws 异常的类型{//方法体 }
约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊情况：子类不能重写父类中声明为private权限的方法
③ 返回值类型：
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型（具体放到异常处理时候讲）
子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的（不是重写）。

面试题：区分方法的重载与重写
1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

“两同一不同”：同一个类、相同方法名.
参数列表不同：参数个数不同，参数类型不同.

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

① 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
② 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
特殊情况：子类不能重写父类中声明为private权限的方法
③ 返回值类型：
父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)
④ 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

重载：不表现为多态性
重写：表现为多态性
在这里插入图片描述

Person类：

package com.acoffee.java;

public class Person {
	String name;
	int age;
	
	public Person(){
		
	}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println("吃饭");
	}
	public void walk(int distance) {
		System.out.println("走路的距离是："+distance+"公里");
	}
}

Student类：

package com.acoffee.java;

public class Student extends Person{
	String major;
	
	public Student() {
		
	}
	public Student(String major) {
		this.major = major;
	}
	public void study() {
		System.out.println("学习.喜专业是：+major");
	}
	//对父类中的eat方法进行了重写
	public void eat() {
		System.out.println("学生应该多吃有营养的食物");
	}
}

PersonTest类：

package com.acoffee.java;
/*
 * 	方法的重写(override/overwrite)
 * 1.重写：子类继承父类以后，可以对父类中同名同参的方法进行覆盖操作
 * 
 * 2.应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的
 * 	同名同参的方法时，实际执行的是子类重写父类的方法。
 * 
 */

public class PersonTest {
	public static void main(String[] args) {
		
		Student s = new Student("计算机科学与技术");
		s.eat();
		s.walk(10);
		
		s.study();
				
		Person p1 = new Person();
		p1.eat();
	}
}

我们这里是将 eat() 方法重写了.

测试四种权限修饰符
在不同包的子类中，不能调用Order类中声明为 private和确省权限属性、方法
不同包下的普通类（非子类）要使用Order类，不可以调用声明为private、确省、protected权限的属性、方法

super关键字：

写了super直接先在父类中找，先在直接父类中找，然后再在间接父类中去找。
在这里插入图片描述
当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用“Super.属性”的方式，表明调用的是父类中声明的属性。
但是通常情况下在开发的过程中一般在子父类中我们不会取相同的名字。

当子类重写了父类只能跟的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用“Super.属性”的方式，表明调用的是父类中声明的方法。

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

在这里插入图片描述

子类对象实例化的过程

1.从结果上来看：（继承性）
子类继承父类以后，就获取了父类中声明的属性或方法
创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

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

明确：虽然创建子类对象时调用了父类构造器，但是自始至终就只创建了一个对象，就是你new的那个对象。

继承和super课后练习
题目要求:

在这里插入图片描述
Account类：

package com.acoffee.exer1;

public class Account {
	private int id; 
	private double balance;
	private double annualInterestRate;
	
	public Account(int id, double balance, double annualInterestRate) {
		this.id = id;
		this.balance = balance;
		this.annualInterestRate = annualInterestRate;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getId() {
		return id;
	}
	public void setBalance(double balance) {
		this.balance = balance;
	}
	public double getBalance() {
		return balance;
	}
	public void setAnnualInterestRate(double annualInterestRate) {
		this.annualInterestRate = annualInterestRate;
	}
	public double getAnnualInterestRate() {
		return annualInterestRate;
	}
	
	public double getMonthlyInterest() {
		return annualInterestRate / 12;
	} 
	public void withdraw (double amount) {
		if (balance > amount) {
			balance -= amount;
			return;
		}
		System.out.println("余额不足");
	}
	//存钱
	public void deposit (double amount) {
		if(amount > 0) {
			balance += amount;
		}
	}
}

AccountTest类：

package com.acoffee.exer1;
//写一个用户程序测试 Account 类。
//在用户程序中，创建一个账号为 1122、
//余额为 20000、 年利率 4.5%的 Account 对象。
//使用 withdraw 方法提款 30000 元，并打印余额。
//再使用 withdraw 方法提款 2500 元，
//使用 deposit 方法存款 3000 元，然后打印余额和月利 率
public class AccountTest {
	public static void main(String[] args) {
		Account acct = new Account(1122,20000,0.045);
		acct.withdraw(30000);
		System.out.println("你的账户的余额是："+acct.getBalance());
		
		acct.withdraw(2500);
		System.out.println("你的账户的余额是："+acct.getBalance());
		
		acct.deposit(3000);
		System.out.println("你的账户的余额是："+acct.getBalance());
	
		System.out.println("月利率为：" + acct.getMonthlyInterest() * 100+"%"); 
	}
}

CheckAccount类：

package com.acoffee.exer1;
/*创建 Account 类的一个子类 CheckAccount 
 * 代表可透支的账户，该账户中定义一个属性 overdraft 
 * 代表可透支限额。在 CheckAccount 类中重写 withdraw 方法，
 * 其算法如下： 
 * 如果（取款金额<账户余额）， 
 * 可直接取款 如果（取款金额>账户余额）， 
 * 计算需要透支的额度 判断可透支额 overdraft 
 * 是否足够支付本次透支需要，
 * 如果可以  将账户余额修改为 0，
 * 冲减可透支金额 如果不可以  
 * 提示用户超过可透支额的限额 */
public class CheckAccount extends Account {
	private double overdraft;
	
	public CheckAccount(int id, double balance, double annualInterestRate,double overdraft) {
		super(id, balance, annualInterestRate);
		this.overdraft = overdraft;
	}
	
	public double getOverdraft() {
		return overdraft;
	}

	public void setOverdraft(double overdraft) {
		this.overdraft = overdraft;
	}

	@Override
		public void withdraw(double amount) {
			if(amount < getBalance()) {//余额足够消费
				super.withdraw(amount);
			}else if(overdraft > amount - getBalance()){//透支额度+余额足够消费
				
				overdraft -= (amount - getBalance());
				setBalance(0);
				//或 super.withdraw(getBalance);
			}else {
				System.out.println("超过了透支限额！");
			}
	}
}

CheckAccuntTest类：

public class CheckAccuntTest {
	public static void main(String[] args) {
		CheckAccount acct = new CheckAccount(1122,20000,0.045,5000);
		
		acct.withdraw(5000);
		System.out.println("你的账户余额为："+acct.getBalance());
		System.out.println("你的透支额度为："+acct.getOverdraft());
		
		acct.withdraw(18000);
		System.out.println("你的账户余额为："+acct.getBalance());
		System.out.println("你的透支额度为："+acct.getOverdraft());
		
		acct.withdraw(3000);
		System.out.println("你的账户余额为："+acct.getBalance());
		System.out.println("你的透支额度为："+acct.getOverdraft());
	}
}

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

多态性的使用前提：①类的继承关系 ②方法的重写
在这里插入图片描述

面向对象特征之三：多态性
1.理解多态性：可以理解为一个事物的多种形态。
2.何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
3.多态的使用：虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。
4.多态性的使用前提： ① 类的继承关系 ② 方法的重写
5.对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

例一：
person类：

package com.acoffee.exer3;

public class Person {
	String name;
	int age;
	
	public void eat() {
		System.out.println("人：吃饭");
	}
	
	public void walk() {
		System.out.println("人：走路");
	}
}

Man类：

package com.acoffee.exer3;

public class Man extends Person{
	boolean isSmoking;
	
	public void earnMonry() {
		System.out.println("男人负责挣钱养家");
	}
	
	public void eat() {
		System.out.println("男人多吃肉，长肌肉");
	}
	
	public void walk() {
		System.out.println("男人要霸气的走路");
	}
}

Woman类：

package com.acoffee.exer3;

public class Woman extends Person {
	boolean isBeauty;
	
	public void goShopping() {
		System.out.println("女人喜欢购物");
	}
	
	public void eat() {
		System.out.println("女人少吃要减肥");
	}
	
	public void walk() {
		System.out.println("女人秀气的走路");
	}
}

PersonTeat类：

package com.acoffee.exer3;


public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.eat();
		
		Man man = new Man();
		man.eat();
		man.age = 25;
		man.earnMonry();
		
		//************************
		//对象的多态性：我们声明的是父类 调
		//用的是子类的对象。即父类的对象指
		//向子类的对象
		Person p2 = new Man();
		Person p3 = new Woman();
		//多态的使用：当调用子父类同名参数的方法是，实际
		//执行的是子类重写父类的方法---虚拟方法调用
		p2.eat();
		p2.walk();
		//p2.earnMoney();是不能调用的
	}
}

必须要Person中要有这个方法才能调用，当父类没有这个方法时，直接调子类的方法时调用不了的，即编译期，只能调父类中声明的方法，但是在运行期是运行的子类的方法，即编译看左边执行看右边。
Person p2 = new Man();

例二：

package com.atguigu.java4;

import java.sql.Connection;


//多态性的使用举例一：
public class AnimalTest {
	
	public static void main(String[] args) {
		
		AnimalTest test = new AnimalTest();
		test.func(new Dog());
		
		
		test.func(new Cat());
	}
	
	public void func(Animal animal){//Animal animal = new Dog();
		animal.eat();
		animal.shout();
		
		if(animal instanceof Dog){
			Dog d = (Dog)animal;
			d.watchDoor();
		}
	}
// 如果没有多态性我们就只能这样去调用dog类和cat类.	
//	public void func(Dog dog){
//		dog.eat();
//		dog.shout();
//	}
//	public void func(Cat cat){
//		cat.eat();
//		cat.shout();
//	}
}


class Animal{
	
	
	public void eat(){
		System.out.println("动物：进食");
	}
	
	public void shout(){
		System.out.println("动物：叫");
	}
	
	
}

class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头");
	}
	
	public void shout(){
		System.out.println("汪！汪！汪！");
	}
	
	public void watchDoor(){
		System.out.println("看门");
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼");
	}
	
	public void shout(){
		System.out.println("喵！喵！喵！");
	}
}

//举例二：

class Order{
	
	public void method(Object obj){
		
	}
}

//举例三：
class Driver{
	
	public void doData(Connection conn){//conn = new MySQlConnection(); / conn = new OracleConnection();
		//规范的步骤去操作数据
//		conn.method1();
//		conn.method2();
//		conn.method3();
		
	}
	
}

执行结果：
在这里插入图片描述

面试题：多态性是编译时行为还是运行时行为？
多态性是运行时行为.

证明：

import java.util.Random;

//面试题：多态是编译时行为还是运行时行为？
//证明如下：
class Animal  {
 
	protected void eat() {
		System.out.println("animal eat food");
	}
}
class Cat  extends 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 ();
		}
	}
	public static void main(String[] args) {
		int key = new Random().nextInt(3);

		System.out.println(key);

		Animal  animal = getInstance(key);
		
		animal.eat();		 
	}
}

方法的重载与重写

在这里插入图片描述

每日一练：

1. 什么是多态性？什么是虚拟方法调用？
对象的多态性：父类的引用指向子类的对象。
Person p = new Man();
p.eat();
调用方法时，编译时看左边，运行时看右边。

****2. 一个类可以有几个直接父类？（只有一个）一个父类可有多少个子类？（多个）子类能获取直接父类的父类中的结构吗？（可以）子类能否获取父类中private权限的属性或方法？(可以的)
A is a B

3. 方法的重写(override/overwrite)的具体规则有哪些？
方法名、形参列表相同
权限修饰符
返回值
抛出的异常

4. super调用构造器，有哪些具体的注意点
this(形参列表)：本类重载的其它的构造器
super(形参列表):调用父类中指定的构造器
一个类中有n个构造器，最多有n – 1个this，至少有一个1个super