目录
第一题
思路分析：
在执行这句话时new Demo().test(); 会先去调用Demo类的无参构造器
//new Demo().test();表示的是创建一个匿名对象，该匿名对象的使用特点就是，，使用一次之后就会自动销毁
所以 new Demo().test(); 这句话相当于做了两件事情
第一件事情就是 Demo demo = new Demo();
第二件事情就是 demo.test();
但是区别不同的是，匿名对象在使用一后就会自动的销毁，
但是使用匿名对象还是创建了一个对象，因此会先去执行Demo类的无参构造器，而在无参构造器中，会默认有一个super();
这样就会去访问父类的无参构造器 然后这只是完成了对象的创建，还没有去调用方法，调用方法的时候，分别使用了super 和 this 那么一个是去父类查找，一个是去本类查找
所以 输出的内容是 Test , Demo , Rose , jack
在执行这句话时new Demo("john").test(); 会先去调用Demo类的有参构造器
//new Demo("john").test();表示的是创建一个匿名对象，该匿名对象的使用特点就是，，使用一次之后就会自动销毁
/所以 new Demo("john").test(); 这句话相当于做了两件事情
第一件事情就是 Demo demo = new Demo("john");
第二件事情就是 demo.test();
但是区别不同的是，匿名对象在使用一后就会自动的销毁， 但是使用匿名对象还是创建了一个对象，因此会先去执行Demo类的有参构造器，而在有参构造器中，会有一个super(s);这样就会去访问父类的带一个参数的构造器
我们仔细看父类的构造器做了什么事
Test(String name){
this.name = name;
}
this.name 表示的是当前类的对象所以Rose被修改成了John 首先我们使用super(s);传入给父类的构造器，所有此时构造器中的形参 也就是 String name 就是 John 然后在父类的构造器中 又有了这么一句话 this.name=name; 我们知道this查找的是当前类中的属性，所有此时Test类的name属性是Rose,现在就被修改成了john 所有在当我们去调用Test方法的时候，输出的就是 john 和 Jack 因为在使用super去访问父类的name属性的时候，此时已经不在是Rose了，因为在对象初始化的时候 就已经被修改了
package idea.homework.homework07;
//public class homework07 {
// public static void main(String[] args) {
//
// }
//}
// 7.写出程序结果
class Test {
String name = "Rose";
Test() {
System.out.println("Test");//1 Test
}
Test(String name) {
this.name = name;//this.name 表示的是当前类的对象所以Rose被修改成了John
}
}
class Demo extends Test {
String name = "Jack";
Demo() {
super();//构造器默认会有一个super
System.out.println("Demo");//2 Demo
}
Demo(String s) {
super(s);//传进去的参数是John 调用父类的有参构造器
}
public void test() {
System.out.println(super.name);//3 Rose 5John
System.out.println(this.name);//4 jack 6Jack
}
public static void main(String[] args) {
//在执行这句话时new Demo().test(); 会先去调用Demo类的无参构造器
//new Demo().test();表示的是创建一个匿名对象，该匿名对象的使用特点就是，，使用一次之后就会自动销毁
/*
所以 new Demo().test(); 这句话相当于做了两件事情
第一件事情就是 Demo demo = new Demo();
第二件事情就是 demo.test();
但是区别不同的是，匿名对象在使用一后就会自动的销毁，
但是使用匿名对象还是创建了一个对象，因此会先去执行Demo类的无参构造器，而在无参构造器中，会默认有一个super();这样就会去访问父类的无参构造器
然后这只是完成了对象的创建，还没有去调用方法，调用方法的时候，分别使用了super 和 this 那么一个是去父类查找，一个是去本类查找
所有 输出的内容是 Test , Demo , Rose , jack
*/
new Demo().test();//匿名对象
//在执行这句话时new Demo("john").test(); 会先去调用Demo类的有参构造器
//new Demo("john").test();表示的是创建一个匿名对象，该匿名对象的使用特点就是，，使用一次之后就会自动销毁
/*
所以 new Demo("john").test(); 这句话相当于做了两件事情
第一件事情就是 Demo demo = new Demo("john");
第二件事情就是 demo.test();
但是区别不同的是，匿名对象在使用一后就会自动的销毁，
但是使用匿名对象还是创建了一个对象，因此会先去执行Demo类的有参构造器，而在有参构造器中，会有一个super(s);这样就会去访问父类的带一个参数的构造器
我们仔细看父类的构造器做了什么事
Test(String name) {
this.name = name;//this.name 表示的是当前类的对象所以Rose被修改成了John
}
首先我们使用super(s);传入给父类的构造器，所有此时构造器中的形参 也就是 String name 就是 John 然后在父类的构造器中
又有了这么一句话 this.name=name; 我们知道this查找的是当前类中的属性，所有此时Test类的name属性是Rose,现在就被修改成了john
所有在当我们去调用Test方法的时候，输出的就是 john 和 Jack 因为在使用super去访问父类的name属性的时候，此时已经不在是Rose了，因为在对象初始化的时候
就已经被修改了
*/
new Demo("john").test();//匿名对象
}
}
第二题
思路分析：
1.这是一个模拟存款和取款的题，主要思路就是在取款和存款的方法中的逻辑，判断，例如需要用户输入，y才可以存款或者取款，输入n才可以退出，如果输入其他的内容，那么就给出相应的错误信息
homework08类
package idea.homework.homework08;
import java.util.Scanner;
/*
要求：
(1)在上面类的基础上扩展 新类CheckingAccount对每次存款和取款都收取1美元的手续费
(2)扩展前一个练习的BankAccount类，新类SavingsAccount每个月都有利息产生
((earnMonthlylnterest方法被调用)，并且有每月三次免手续费的存款或取款。在earnMonthlylnterest方法中重置交易计数
*/
public class homework08 {
public static void main(String[] args) {
SavingsAccount savingsAccount = new SavingsAccount(1000, 3);
Scanner scanner = new Scanner(System.in);
int a = 0;
System.out.println("请选择1 存款 2取款 3退出");
a = scanner.nextInt();
for (; ; ) {
if (a == 1) {
savingsAccount.deposit(100);
break;
} else if (a == 2) {
savingsAccount.withdraw(100);
break;
} else if (a == 3) {
return;
}
}
}
}
BankAccount类
package idea.homework.homework08;
/*
要求：
(1)在上面类的基础上扩展 新类CheckingAccount对每次存款和取款都收取1美元的手续费
(2)扩展前一个练习的BankAccount类，新类SavingsAccount每个月都有利息产生
((earnMonthlylnterest方法被调用)，并且有每月三次免手续费的存款或取款。在earnMonthlylnterest方法中重置交易计数
*/
public class BankAccount {
private double balance;//余额
//构造器
public BankAccount(double initialBalance) {
this.balance = initialBalance;
}
//存款
public void deposit(double amount) {
balance += amount;
}
//取款
public void withdraw(double amount) {
balance -= amount;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
CheckingAccount类
package idea.homework.homework08;
/*
要求：
(1)在上面类的基础上扩展 新类CheckingAccount对每次存款和取款都收取1美元的手续费
(2)扩展前一个练习的BankAccount类，新类SavingsAccount每个月都有利息产生
((earnMonthlylnterest方法被调用)，并且有每月三次免手续费的存款或取款。在earnMonthlylnterest方法中重置交易计数
*/
public class CheckingAccount extends BankAccount {
public CheckingAccount(double initialBalance) {
super(initialBalance);
}
@Override
//重写存款的方法
public void deposit(double amount) {
super.deposit(amount - 1);
}
@Override
//重写取款的方法
public void withdraw(double amount) {
//因为取款的时候要加收一块钱的手续费，假如你取的钱是9块钱 实际上取出来10块钱 因为要多收一块钱的手续费
super.withdraw(amount + 1);
}
}
SavingAccount类
package idea.homework.homework08;
//import com.super_.B;
import java.util.Scanner;
/*
要求：
(1)在上面类的基础上扩展 新类CheckingAccount对每次存款和取款都收取1美元的手续费
(2)扩展前一个练习的BankAccount类，新类SavingsAccount每个月都有利息产生
((earnMonthlylnterest方法被调用)，并且有每月三次免手续费的存款或取款。在earnMonthlylnterest方法中重置交易计数
*/
public class SavingsAccount extends BankAccount {
//因为一共月有三次机会可以免利息所以定义一个变量保存次数
//在定义一个利率
private int count;
private double rate = 0.01;
Scanner scanner = new Scanner(System.in);
public SavingsAccount(double initialBalance, int count) {
super(initialBalance);
this.count = count;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
@Override
//取款
public void withdraw(double amount) {
while (true) {
System.out.println("请输入 y/n 确定要继续取款吗 ");//提示信息是否要继续取款
String a = scanner.next();//定义一个String变量用来接受用户的输入由用户来决定是否继续存款或者取款
if ("y".equals(a)) {//当用户输入y时 表示用户确认取款
if (getBalance() > 0) {//并且余额大于0才允许操作
if (count > 0) {//根据本月剩下的免费次数决定是否收取手续费
count--;//先对每月剩下的免费次数先--当免费次数为0后收取手续费
System.out.println("当月免费次数还剩下" + count + "次");
super.withdraw(amount);
System.out.println("当前余额为=" + getBalance());
} else {//每次次数用完的取款
super.withdraw(amount + 1);
System.out.println("当前余额为=" + getBalance());
}
} else {//当余额小于0时，不允许存款
System.out.println("存款小于0不允许取款了");
return;
}
} else if ("n".equals(a)) {//当用户输入n时表示用户不取款退出程序并提示信息
System.out.println("退出取款");
return;
} else {//只有输入y或者n才可以，，否则无限循环
System.out.printf("输入错误重新输入");
}
}
}
@Override
//存款
public void deposit(double amount) {
while (true) {
System.out.println("请输入 y/n 确定要继续存款吗 ");//提示信息是否要继续存款
String a = scanner.next();//定义一个String变量用来接受用户的输入由用户来决定是否继续存款或者取款
if ("y".equals(a)) {//当用户输入y时 表示用户确认存款
if (count > 0) {//根据本月剩下的免费次数决定是否收取手续费
count--;
System.out.println("当月免费次数还剩下" + count + "次");
super.deposit(amount);
System.out.println("当前余额为=" + getBalance());
} else {//免费次数用完了
super.deposit(amount - 1);
System.out.println("当前余额为=" + getBalance());
}
} else if ("n".equals(a)) {//当用户输入n时表示用户不存款退出程序并提示信息
System.out.println("退出存款");
return;
} else {//输入的如果不是y或者n就一直循环
System.out.println("请输入正确的选项");
}
}
}
public void earnMonthlylnterest() {//每个月初，我们统计上个月的利息，同时将count=3
count = 3;
super.deposit(getBalance() * rate);
}
}
第三题
思路分析：
1.这题主要是重写equals方法，在一进入该方法的时候，就去判断，当前对象是否和传入参数的对象的类型是否相同，如果是直接返回true，如果不是就判断传入的参数是不是Doctor类的子类型，如果是就判断值是否相同，如果不是说明不是Doctor类型，直接返回false
homework10类
package idea.homework.homework10;
public class homework10 {
public static void main(String[] args) {
/*
10.编写Doctor类 (name, age,job,gender,sall
相应的getter()和setter0方法，5个参数的构造器，重写父类的equals()方法：publicboolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同
*/
Doctor doctor = new Doctor("jack", 1, "医生", '男', 100);
Doctor doctor1 = new Doctor("jack", 1, "医生", '男', 100);
System.out.println(doctor1.equals(doctor));
}
}
Doctor类
package idea.homework.homework10;
/**
* 医生类
*/
public class Doctor {
/*
10.编写Doctor类 (name, age,job,gender,sall
相应的getter()和setter0方法，5个参数的构造器，重写父类的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同
*/
private String name;
private int age;
private String job;
private char gender;
private double salary;
public Doctor(String name, int age, String job, char gender, double salary) {
this.name = name;
this.age = age;
this.job = job;
this.gender = gender;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getJob() {
return job;
}
public void setJob(String job) {
this.job = job;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
//重新写equals方法
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof Doctor) {
//向下转型
Doctor doctor = (Doctor) obj;
if (doctor.age == this.age && doctor.name.equals(this.name) && doctor.job.equals(this.job) && doctor.gender == this.gender && doctor.salary == this.salary) {
return true;
}
}
return false;
}
}