题目1

1.定义一个Person类 {name, age, job} ,初始化Person对象数组，有3个person对象，并安照 age从大到小进行排序,提示，使用冒泡排序。Homework01.java

public class Homework01 {public static void main(String[] args) {//初始化Person 对象数组，有3个person对象Person[] persons = new Person[3];persons[0] = new Person("mary",30, "PHP工程师");persons[1] = new Person("tom",50, "大数据工程师");persons[2] = new Person("smith",10, "JavaEE工程师");//输出当前对象数组for (int i = 0; i < persons.length; i++) {System.out.println(persons[i]);//不重写就是默认对象的.toString() ,后边要重写toString}//使用冒泡排序Person tmp = null;//临时变量，用于交换for(int i = 0; i < persons.length -1 ;i++) {//外层循环for(int j = 0; j < persons.length -1 - i; j++) {//内层循环//并按照 age 从 大到 小进行排序, 如果前面的人的age < 后面人的年龄，就交换// 要求按照名字的长度从小到大 if(persons[i].getName().length() > persons[i+1].getName().length())    if(persons[j].getAge() > persons[j+1].getAge()) {tmp = persons[j];persons[j] = persons[j+1];persons[j+1]= tmp;}}}System.out.println("排序后的效果");for (int i = 0; i < persons.length; i++) {System.out.println(persons[i]);//默认对象的.toString()}}/*定义一个Person类 {name, age, job}, 初始化Person 对象数组，有3个person对象，并按照 age 从 大到 小进行排序, 提示，使用冒泡排序 */
}
class Person {private String name;private int age;private String job;public Person(String name, int age, String job) {this.name = name;this.age = age;this.job = job;}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;}@Override  //重写toStringpublic String toString() {return "Person{" +"name='" + name + '\'' +", age=" + age +", job='" + job + '\'' +'}';}
}

题目2

写出四种访问修饰符和各自的访问权限

题目3

编写老师类 HomeworkO3.java
(1)要求有属性 “姓名name”，“年龄age”，“职称post”，“基本工资“salary”
(2)编写业务方法,introduce ()，实现输出一个教师的信息。
(3)编写教师类的三个子类：教授类(Professor)、副教授类、讲师类。工资级别分别为：教受为1.3、副教授为1.2、讲师类1.1。在三个子类里面都重写父类的introduce()方法。
(4)定义并初始化一个老师对象，调用业务方法，实现对象基本信息的后台打印。

方法1：把grade等级写在父类Teacher里

主类代码：

public class Homework03 {public static void main(String[] args) {Professor professor = new Professor("贾宝玉", 30, "高级职称", 30000, 1.3);professor.introduce();}
}
/*
(1) 要求有属性“姓名name”，“年龄age”，“职称post”，“基本工资salary”
(2) 编写业务方法， introduce（），实现输出一个教师的信息。*/
class Teacher {private String name;private int age;private String post;private double salary;//这里我们在增加一个工资级别,因为三个子类都有private double grade;public Teacher(String name, int age, String post, double salary, double grade) {this.name = name;this.age = age;this.post = post;this.salary = salary;this.grade = grade;}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 getPost() {return post;}public void setPost(String post) {this.post = post;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}public double getGrade() {return grade;}public void setGrade(double grade) {this.grade = grade;}public void introduce() {System.out.println("name: " + name + " age: " + age+ " post: " + post + " salary:" + salary + " grade:" + grade);}
}

子类Professor代码：

//子类
public class Professor extends Teacher {//特有属性可以自己增加，这里没有就不写了...public Professor(String name, int age, String post, double salary, double grade) {super(name, age, post, salary, grade);}@Overridepublic void introduce() {System.out.println(" 这是教授的信息 ");super.introduce();}
}

方法2：把grade等级写在每一个子类里

主类代码：

public class Homework03 {public static void main(String[] args) {Teacher professor = new Professor("java", 223, "教授", 2300,"s");System.out.println(professor.introduce());}
}class Teacher{private String name;private int age;private String post;private double salary;//这里我们在增加一个工资级别,因为三个子类都有//private double grade;public Teacher(String name, int age, String post, double salary) {this.name = name;this.age = age;this.post = post;this.salary = salary;// this.grade =grade;}public String introduce(){return "教师信息为："+ "姓名"+name+"年龄"+age+"职称"+post+"薪水"+salary;}
//    public void introduce() {//        System.out.println("name: " + name + " age: " + age
//                + " post: " + post + " salary:" + salary + " grade:" + grade);
//    }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 getPost() {return post;}public void setPost(String post) {this.post = post;}public double getSalary() {return salary;}public void setSalary(double salary) {this.salary = salary;}@Overridepublic String toString() {return "Teacher{" +"name='" + name + '\'' +", age=" + age +", post='" + post + '\'' +", salary=" + salary +'}';}
}

子类Professor代码：

public class Professor extends  Teacher{private String grade;public Professor(String name, int age, String post, double salary, String grade) {super(name, age, post, salary);this.grade = grade;}@Overridepublic String introduce() {System.out.println("教授信息为");return super.introduce()+"级别为"+grade;}public String getGrade() {return grade;}public void setGrade(String grade) {this.grade = grade;}@Overridepublic String toString() {return "Professor{" +"grade='" + grade + '\'' +'}';}
}

题目4

通过继承实现员工工资核算打印功能 Homework04.java
父类:员工类(Employee)
子类:部门经理类(Manager)、普通员工类(Worker)
(1)部门经理工资=1000+单日工资* 天数* 等级（1.2)。=>奖金＋基本工资
(2)普通员工工资=单日工资 * 天数 * 等级(1.0); =>基本工资
(3)员工属性:姓名，单日工资,工作天数
(4)员工方法(打印工资)
(5)普遍员工及部门经理都是员工子类,需要重写打印工资方法。
(6)定义并初始化普通员工对象，调用打印工资方法输出工资，定义并初始化部门经理对象,调用打印工资方法输出工资

方法1：创建Manager对象时，奖金是多少并不是确定的，因为在构造器中，不给bonus，可以在主类通过setBonus动态设置奖金。（我认为这一步无所谓，用方法二也一样。）

主类和父类代码：

public class Homework04 {public static void main(String[] args) {Manager manage = new Manager("刘备", 100, 20, 1.2);//设置奖金manage.setBonus(3000);//打印经理的工资情况manage.printSal();Worker worker = new Worker("关羽",50, 10, 1.0);worker.printSal();}
}//父类员工Employee
class Employee {//属性//员工属性：姓名，单日工资，工作天数private String name;private double daySal;private int workDays;//分析出还有一个属性等级private double grade;//方法[构造器，getter 和 setter]//打印工资方法//方法 void printSal() {}public void printSal() {System.out.println(name + " 工资=" + daySal * workDays * grade);}public Employee(String name, double daySal, int workDays, double grade) {this.name = name;this.daySal = daySal;this.workDays = workDays;this.grade = grade;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getDaySal() {return daySal;}public void setDaySal(double daySal) {this.daySal = daySal;}public int getWorkDays() {return workDays;}public void setWorkDays(int workDays) {this.workDays = workDays;}public double getGrade() {return grade;}public void setGrade(double grade) {this.grade = grade;}
}

子类经理Manager代码：


public class Manager extends Employee {//特有属性private double bonus;//创建Manager对象时，奖金是多少并不是确定的，因为老师在构造器中，不给bonus，可以通过setBonuspublic Manager(String name, double daySal, int workDays, double grade) {super(name, daySal, workDays, grade);}//方法:重写父类的 printSal@Overridepublic void printSal() {//因为经理的工资计算方式和Employee不一样，所以我们重写System.out.println("经理 " + getName() + " 工资是="+ (bonus + getDaySal() * getWorkDays() * getGrade()));}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}
}

子类普通员工Worker代码：

public class Worker extends Employee{//分析普通员工没有特有的属性public Worker(String name, double daySal, int workDays, double grade) {super(name, daySal, workDays, grade);}//重写printSal//因为普通员工和Employee输出工资情况一下，所以直接调用父类的printSal()@Overridepublic void printSal() {System.out.print("普通员工 ");//自己的输出信息super.printSal();//调用父类的方法，复用代码}
}

方法2：创建Manager对象时，在构造器中给bonus。

主类和父类代码：

public class Homework04 {public static void main(String[] args) {Manager s = new Manager("大猛子", 100, 20, 1.2, 1000);s.printSal();Worker worker = new Worker("小猛子", 80, 30, 1.0);worker.printSal();}
}class Employee {private String name;private double daySal;private int workDays;private double grade;public void printSal() {System.out.println(name + "的工资=" + daySal * workDays * grade);}public Employee(String name, double daySal, int workDays, double grade) {this.name = name;this.daySal = daySal;this.workDays = workDays;this.grade = grade;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getDaySal() {return daySal;}public void setDaySal(double daySal) {this.daySal = daySal;}public int getWorkDays() {return workDays;}public void setWorkDays(int workDays) {this.workDays = workDays;}public double getGrade() {return grade;}public void setGrade(double grade) {this.grade = grade;}
}

子类经理Manager代码

public class Manager extends  Employee{private double bonus;@Overridepublic void printSal() {//super.printSal();System.out.println("经理 "+getName()+" 工资为："+(bonus + getDaySal()*getWorkDays()*getGrade()));}public Manager(String name, double daySal, int workDays, double grade, double bonus) {super(name, daySal, workDays, grade);this.bonus = bonus;}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}
}

子类普通员工Worker代码：

public class Worker extends Employee {public Worker(String name, double daySal, int workDays, double grade) {super(name, daySal, workDays, grade);}@Overridepublic void printSal() {System.out.print("普通员工 ");super.printSal();}
}

题目5

设计父类一员工类。子类:工人类(Worker),农民类(Peasant),教师类(Teacher),科学家类(Scientist).服务生类(Waiter)。
(1)其中工人,农民,服务生只有基本工资sal
(2)教师除基本工资外还有课酬(元/天) classDay, classSal
(3)科学家除基本工资外,还有年终奖bonus
(4)编写一个测试类,将各种类型的员工的全年工资打印出来
HomeworkO5.java 放在com.hspedu.homework.homework5包

主类代码：

public class Homework05 {public static void main(String[] args) {Worker jack = new Worker("jack", 10000);jack.setSalMonth(15);//灵活修改带薪月份jack.printSal();Peasant smith = new Peasant("smith", 20000);smith.printSal();//老师测试Teacher teacher = new Teacher("顺平", 2000);//老师有课时费teacher.setClassDays(360);teacher.setClassSal(1000);teacher.printSal();//科学家Scientist scientist = new Scientist("钟南山", 20000);scientist.setBonus(2000000);scientist.printSal();}
}

父类员工Employee代码：
注意：这里年薪有的发12个月，有的13个15个，变化设置成属性，然后不加入构造器，而是用get和set在主类设置。

public class Employee { //父类//属性//分析有一个带薪的月份 13 , 15, 12private String name;private double sal;private int salMonth = 12;//方法//打印全年工资public void printSal() {System.out.println(name + " 年工资是: " + (sal * salMonth));}public Employee(String name, double sal) {this.name = name;this.sal = sal;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getSal() {return sal;}public void setSal(double sal) {this.sal = sal;}public int getSalMonth() {return salMonth;}public void setSalMonth(int salMonth) {this.salMonth = salMonth;}
}

子类农民工Peasant

public class Peasant extends Employee {//子类//属性//农民,服务生只有基本工资 sal//方法public Peasant(String name, double sal) {super(name, sal);}//年工资@Overridepublic void printSal() {System.out.print("农民 ");super.printSal();}
}

子类工人 worker 代码：

public class Worker extends Employee{ //子类//属性//工人,农民,服务生只有基本工资 salpublic Worker(String name, double sal) {super(name, sal);}//方法@Overridepublic void printSal() {System.out.print("工人 ");super.printSal();//使用父类的printSal()}
}

子类Teacher代码：
注意：这里 classDays 和 classSal没有放入构造器，也是在主类用set方法设置。

public class Teacher extends Employee{//子类//特有属性private int //课时费public Teacher(String name, double sal) {super(name, sal);}//方法-重写printSal@Overridepublic void printSal() { //老师不能使用super.printSal()，要重写下System.out.print("老师 ");System.out.println(getName() + " 年工资是: "+ (getSal() * getSalMonth() + classDays * classSal ));}public int getClassDays() {return classDays;}public void setClassDays(int classDays) {this.classDays = classDays;}public double getClassSal() {return classSal;}public void setClassSal(double classSal) {this.classSal = classSal;}
}

子类Scientist代码：
注意：这里 bonus 没有放入构造器，也是在主类用set方法设置。

public class Scientist extends Employee{ //子类//特有属性//年终奖 bonusprivate double bonus;//方法public Scientist(String name, double sal) {super(name, sal);}//重写年工资打印@Overridepublic void printSal() {System.out.print("科学家 ");System.out.println(getName() + " 年工资是: " + (getSal() * getSalMonth() + bonus));}public double getBonus() {return bonus;}public void setBonus(double bonus) {this.bonus = bonus;}
}

题目6

1、super访问父类。(不仅局限于父类，还可以往上一类)

2、this先从本类访问(本类所有的成员都可以访问)，本类没有再去父类或者超类，但是，this在本类访问了name，就不能再访问超类的name了。假如this在父类中访问了一个成员，就不能再去超类访问了。。

题目7

题目8

主类代码：

public class Homework08 {public static void main(String[] args) {// 第1小问测试checkingAccount
//        CheckingAccount checkingAccount = new CheckingAccount(1000);
//        checkingAccount.deposit(10);// 1010 - 1 = 1009
//        checkingAccount.withdraw(9);//1009 - 9 = 1000 -1= 999
//        System.out.println(checkingAccount.getBalance());//测试SavingsAccountSavingsAccount savingsAccount = new SavingsAccount(1000);savingsAccount.deposit(100);savingsAccount.deposit(100);savingsAccount.deposit(100);System.out.println(savingsAccount.getBalance());//1300  三次免息savingsAccount.deposit(100);System.out.println(savingsAccount.getBalance());//1400-1=1399//月初，定时器自动调用一下 earnMonthlyInterestsavingsAccount.earnMonthlyInterest();//统计利息System.out.println(savingsAccount.getBalance());//1399 + 13.99 =1412.99savingsAccount.withdraw(100);//免手续System.out.println(savingsAccount.getBalance());//1412.99 -100 =1312.99savingsAccount.withdraw(100);//免手续savingsAccount.withdraw(100);//免手续System.out.println(savingsAccount.getBalance());//1412.99 -200 =1112.99savingsAccount.deposit(100);//扣手续费System.out.println(savingsAccount.getBalance());//1112.99 + 100 = 1212.99 - 1 = 1211.99}
}

子类checkingAccount代码：

/*
在上面类的基础上扩展 新类CheckingAccount对每次存款和取款都收取1美元的手续费*/
public class CheckingAccount extends BankAccount{//新的账号//属性public CheckingAccount(double initialBalance) {super(initialBalance);}@Overridepublic void deposit(double amount) {//存款super.deposit(amount - 1);//巧妙的使用了父类的 deposit//1 块钱转入银行的账号}@Overridepublic void withdraw(double amount) {//取款super.withdraw(amount + 1);//比如说取10元，加上手续费就是要取11元//1 块钱转入银行的账号}
}

子类SavingsAccount代码：

/*
扩展前一个练习的BankAccount类，
新类SavingsAccount每个月都有利息产生(earnMonthlyInterest方法被调用)，
并且有每月三次免手续费的存款或取款。在earnMonthlyInterest方法中重置交易计数*/
public class SavingsAccount extends BankAccount {//分析//新增加属性private int count = 3;private double rate = 0.01;//利率public void earnMonthlyInterest() {//每个月初，我们统计上个月的利息，同时将count=3count = 3;super.deposit(getBalance() * rate); //调用的是父类}@Overridepublic void deposit(double amount) {//判断是否还可以免手续费if(count > 0) {super.deposit(amount);} else {super.deposit(amount - 1);//1 块转入银行}count--;//减去一次}@Overridepublic void withdraw(double amount) {//取款//判断是否还可以免手续费if(count > 0) {super.withdraw(amount);} else {super.withdraw(amount + 1);//1 块转入银行}count--;}public SavingsAccount(double initialBalance) {super(initialBalance);}public int getCount() {return count;}public void setCount(int count) {this.count = count;}public double getRate() {return rate;}public void setRate(double rate) {this.rate = rate;}
}

题目9

设计一个Point类，其x和y坐标可以通过构造器提供。提供一个子类LabeledPoint，其构造器接受一个标签值和x,y坐标,比如:new LabeledPoint("Black”,1929,230.07),写出对应的构造器即可。HomeworkO9.java

此题的用意在于：已知需求，反写构造器

public class Homework09 {public static void main(String[] args) {new LabeledPoint("Black",1929,230.07);}
}class Point {private double x;private double y;public Point(double x, double y) {this.x = x;this.y = y;}
}class LabeledPoint extends Point {//特有属性private String label;public LabeledPoint(String label, double x, double y) {super(x, y);this.label = label;}//方法
}

题目10

编写Doctor类{name, age, job, gender, sal}
相应的getter()和setter()方法，5个参数的构造器，重写父类(Object)的equals(方法:public boolean equals(Object obi)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同。 Homework10.java

提示：此题可以参考学习笔记第八章（中）的 8.12.2 如何重写equals 方法

public class Homework10 {public static void main(String[] args) {//测试Doctor doctor1 = new Doctor("jack", 20, "牙科医生", '男', 20000);Doctor doctor2 = new Doctor("jack", 20, "牙科医生", '男', 20000);System.out.println(doctor1.equals(doctor2));//T  equals重写了，是判断属性是否相同。}
}class Doctor {//属性//{name, age, job, gender, sal}private String name;private int age;private String job;private char gender;private double sal;//5个参数的构造器public Doctor(String name, int age, String job, char gender, double sal) {this.name = name;this.age = age;this.job = job;this.gender = gender;this.sal = sal;}//方法//相应的getter()和setter()方法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 getSal() {return sal;}public void setSal(double sal) {this.sal = sal;}//重写父类(Object)的equals()方法：public boolean equals(Object obj)，并判断测试类中创建的两个对象是否相等。相等就是判断属性是否相同public boolean equals(Object obj) {//判断两个比较对象是否相同if (this == obj) { //两个对象是同一个，就返回真return true;}//判断obj 是否是 Doctor类型或其子类//过关斩将 校验方式if (!(obj instanceof Doctor)) { //不是的话return false;}//向下转型, 因为obj的运行类型是Doctor或者其子类型Doctor doctor = (Doctor)obj;return this.name.equals(doctor.name) && this.age == doctor.age &&this.gender == doctor.gender && this.job.equals(doctor.job) && this.sal == doctor.sal;}
}

题目11

考察向上转型，向下转型。
可以参考文章文章https://blog.csdn.net/m0_50736744/article/details/121377193中的 8.11.5 多态注意事项和细节讨论-向上转型和向下转向部分。

小总结：其实访问方法时，可以理解成访问方法看运行类型(右边)-指输出结果。
可以参考文章https://blog.csdn.net/m0_50736744/article/details/121377193中的8.11.6 课堂练习的2

题目12

题目13

注意：本题7、8小问好好领会。（7、8小问需要重写toString方法）

主类代码：7,8小问放在了主类

public class Homework13 {public static void main(String[] args) {//测试老师Teacher teacher = new Teacher("张飞", '男', 30, 5);teacher.printInfo();//测试Student student = new Student("小明", '男', 15, "00023102");System.out.println("-----------------------------------");student.printInfo();//封装//定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序Person[] persons = new Person[4];  //多态数组用父类创建persons[0] = new Student("学生jack", '男', 10, "0001");persons[1] = new Student("学生mary", '女', 20, "0002");persons[2] = new Teacher("smith", '男', 36, 5);persons[3] = new Teacher("scott", '男', 26, 1);//创建对象Homework13 homework13 = new Homework13();homework13.bubbleSort(persons);//输出排序后的数组System.out.println("---排序后的数组-----");for(int i = 0; i < persons.length; i++) {System.out.println(persons[i]);}//遍历数组，调用test方法System.out.println("=======================");for (int i = 0; i < persons.length; i++) {//遍历多态数组homework13.test(persons[i]);}}//定义方法，形参为Person类型，功能：调用学生的study或教师的teach方法//分析这里会使用到向下转型和类型判断public void test(Person p) {if(p instanceof Student) {//p 的运行类型如果是Student((Student) p).study();} else if(p instanceof  Teacher) {((Teacher) p).teach();} else {System.out.println("do nothing...");}}//方法,完成年龄从高到底排序public void bubbleSort(Person[] persons) {Person temp = null;for (int i = 0; i < persons.length - 1; i++) {for (int j = 0; j < persons.length - 1 - i; j++) {//判断条件, 注意这里的条件可以根据需要，变化if(persons[j].getAge() < persons[j+1].getAge()) {temp = persons[j];persons[j] = persons[j + 1];persons[j + 1] = temp;}}}}
}

父类Person类：

/*抽取一个父类Person类，将共同属性和方法放到Person类 */
public class Person {//父类private String name;private char gender;private int age;//方法public Person(String name, char gender, int age) {this.name = name;this.gender = gender;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public char getGender() {return gender;}public void setGender(char gender) {this.gender = gender;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}//编写一个play 方法, 把共有的输出内容写到父类public String play() {return name + "爱玩";}//返回一个基本信息/*姓名：张飞年龄：30性别：男*/public String basicInfo() {return "姓名: " + name + "\n年龄: " + age + "\n性别: " + gender;}@Overridepublic String toString() {return "Person{" +"name='" + name + '\'' +", gender=" + gender +", age=" + age +'}';}
}

子类Student类：

/*学生需要有学习的方法（study），在方法里写生“我承诺，我会好好学习。” */
public class Student extends Person{ ////属性private String stu_id;//方法public Student(String name, char gender, int age, String stu_id) {super(name, gender, age);this.stu_id = stu_id;}public String getStu_id() {return stu_id;}public void setStu_id(String stu_id) {this.stu_id = stu_id;}//我承诺，我会好好学习public void study() {System.out.println(getName() + "承诺，我会好好学习 java");}/*** 学生爱玩足球* @return*/@Overridepublic String play() {return super.play() + "足球";}//编写一个输出信息的方法，这样体现封装public void printInfo() {System.out.println("学生的信息:");System.out.println(super.basicInfo());System.out.println("学号: " + stu_id);study();//组合， 变化万千System.out.println(play());}@Overridepublic String toString() {return "Student{" +"stu_id='" + stu_id + '\'' +'}' + super.toString();}
}

子类Teacher类：

public class Teacher extends Person {//属性private int work_age;//方法public Teacher(String name, char gender, int age, int work_age) {super(name, gender, age);this.work_age = work_age;}public int getWork_age() {return work_age;}public void setWork_age(int work_age) {this.work_age = work_age;}//教师需要有教学的方法（teach），在方法里写上“我承诺，我会认真教学。public void teach() {System.out.println(getName() + "承诺，我会认真教学 java...");}/*** 老师爱玩象棋*/@Overridepublic String play() {return super.play() + "象棋";}//输出信息方法public void printInfo() {System.out.println("老师的信息：");System.out.println(super.basicInfo());System.out.println("工龄: " + work_age);teach();System.out.println(play());}@Overridepublic String toString() {return "Teacher{" +"work_age=" + work_age +'}' + super.toString();}
}

题目14

注意：千万别忘了B类中隐藏的那个Super

答案：我是A类，hahah我是B类的有参构造，我是c类的有参参构造，我是c类的无参构造

题目15

什么是多态 , 多态具体体现有哪些? (可举例说明)

答案：

多态:方法或对象具有多种形态，是0OP的第三大特征，是建立在封装和继承基础之上多态具体体现
1.方法多态
(1)重载体现多态(2)重写体现多态
2.对象多态
(1)对象的编译类型和运行类型可以不一致,编译类型在定义时，就确定，不能变化
(2)对象的运行类型是可以变化的,可以通过getClasss ( ) 来查看运行类型
(3)编译类型看定义时=号的左边，运行类型看=号的右边
3.举例说明

public class Homework15 {public static void main(String[] args) {AAA obj = new BBB();//向上转型AAA b1 = obj;System.out.println("obj的运行类型=" + obj.getClass());//BBBobj = new CCC();//向上转型System.out.println("obj的运行类型=" + obj.getClass());//CCCobj = b1;System.out.println("obj的运行类型=" + obj.getClass());//BBB}
}class AAA {//超类}
class BBB extends AAA {//父类}
class CCC extends BBB {//子类}

内存分析图顺序：黄–>红–>蓝

注意：这里obj的运行类型可以改变，但是编译类型不能改变，AAA obj就决定了obj的编译类型是AAA

题目16

java的动态绑定机制是什么? Homework16.java

答案：
1.当调用对象的方法时，该方法会和对象的内存地址/运行类型绑定。
2.当调用对象的属性时，没有动态绑定机制,哪里声明,那里使用。

java学习笔记(8) 第8章（下）- 面向对象编程(中级部分) - 练习题相关推荐

java学习笔记(13) 第13章 - 常用类
第13 章常用类-目录 13.1 包装类 13.1.1 包装类的分类.包装类和基本数据的转换.案例演示.课堂测试 13.1.2 包装类型和String 类型的相互转换 13.1.3 Integer 类 ...
Python快速编程入门#学习笔记08# |第8章：面向对象
目录 1. 面向对象概述 2. 类的定义 3.对象的创建与使用类的成员 4.属性 1.类属性 2.实例属性 5.方法 1.实例方法 2.类方法 3.静态方法 6.私有成员特殊方法 7.构造方法 8 ...
【转】MT7688学习笔记（6）——OpenWrt下串口编程
一.头文件操作串口需要包含的头文件: #include <stdio.h> /*标准输入输出定义*/ #include <errno.h> /*错误号定义*/ #includ ...
C++学习笔记：(七)C语言实现面向对象编程
面试官:C和C++有什么不同? 应聘者:一个是面向过程,一个是面向对象. 这样的答案在我看是不完全正确,因为面向过程编程和面向对象编程是编程思想,C++可以用面向过程的思想编程,同样,C语言也可以用面 ...
Java学习笔记类对象多态继承(下)
面向对象(下) 1.类的继承一.什么是继承,有什么用? 继承:在现实世界当中也是存在的,例如:父亲很有钱,几子不用努力也很有钱继承的作用: 基本作用:子类继承父类,代码可以得到复用.(这个不是重要 ...
JAVA学习笔记（第五章接口与继承）
一.什么是接口接口就像是一种模板,接口中放着没有内容的方法,类要是使用接口就必须声明接口中的方法.下面继续以LOL游戏为例: LOL的英雄,有些能够使用物理攻击,有些能够使用魔法攻击击,有些则两种攻 ...
java学习笔记(9) 第9章 Java项目-房屋出租系统
Java项目-房屋出租系统代码打包--百度网盘链接: 9.1 房屋出租系统-需求 9.1.1 项目需求说明 9.2 房屋出租系统-界面 9.3 房屋出租系统-设计(!!) 9.4 房屋出租系统-实现 ...
Java学习笔记-第十四章-NIO与NIO2
目录一.NIO 二.NIO2 1. NIO2架构 2. 操作路径 3. 属性读取与设定 4. 操作文档与记录 5. 读取/访问目录 6. 过滤/搜索文档一.NIO /*** 原始的dump** @ ...
java学习笔记20（Lambda表达式、函数式编程、流式计算、练习）
文章目录 11.3 学习内容 Lambda表达式 Lambda标准格式格式说明省略规则使用前提函数式接口预定义的函数式接口工作内容任务1 总结&明日计划 11.4 学习内容流式 ...

java学习笔记(8) 第8章（下）- 面向对象编程(中级部分) - 练习题

目录：

题目1

题目2

题目3

题目4

题目5

题目6

题目7

题目8

题目9

题目10

题目11

题目12

题目13

题目14

题目15

题目16

java学习笔记(8) 第8章（下）- 面向对象编程(中级部分) - 练习题相关推荐

最新文章

热门文章