目录
第十三题
题目
Student类
Teacher类
main类
老师的代码
Student类
Teacher类
main类
第七问：定义多态数组
main类
运行结果
问题
原因
解决办法
老师代码：main类
结果
第八问
运行结果
第十四题
第十五题
题目
方法的多态
对象的多态
第十六题
第十三题
题目
先解决打印信息的问题
Person类
package com.hspedu.homework.homework13;
public class Person {
private String name;
private int age;
private char sex;
public Person(String name, int age, char sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public String showInfo(){
return "姓名:" + name + "\n年龄:" + age + "\n" + "性别:" + sex;
}
//play方法
public String play(){
return name + "爱玩";
}
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 char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
}
Student类
package com.hspedu.homework.homework13;
public class Student extends Person{
private String stu_id;
public Student(String name, int age, char sex, String stu_id) {
super(name, age, sex);
this.stu_id = stu_id;
}
@Override
public String showInfo() {
return super.showInfo() + "\n学号:" + stu_id;
}
@Override
public String play() {
return super.play() + "足球";
}
public void study(){
System.out.println("我承诺，我会好好学习");
}
public String getStu_id() {
return stu_id;
}
public void setStu_id(String stu_id) {
this.stu_id = stu_id;
}
}
Teacher类
package com.hspedu.homework.homework13;
public class Teacher extends Person{
private double work_age;
public Teacher(String name, int age, char sex, double work_age) {
super(name, age, sex);
this.work_age = work_age;
}
@Override
public String showInfo() {
return super.showInfo() + "\n工龄:" + work_age;
}
@Override
public String play() {
return super.play() + "象棋";
}
public void teach() {
System.out.println("我承诺，我会认真教课 ");
}
public double getWork_age() {
return work_age;
}
public void setWork_age(double work_age) {
this.work_age = work_age;
}
}
main类
在main类中创建对象并完成属性的初始化，然后按照打印要求，一一调用方法
package com.hspedu.homework.homework13;
public class HomeWork13 {
public static void main(String[] args) {
Teacher teacher = new Teacher("张飞", 30, '男', 5);
Student student = new Student("小明", 15, '男', "00023102");
System.out.println("老师的信息:");
System.out.println(teacher.showInfo());
teacher.teach();
System.out.println(teacher.play());
System.out.println("------------------");
System.out.println("学生的信息:");
System.out.println(student.showInfo());
student.study();
System.out.println(student.play());
}
}
老师的代码
老师主要是在子类中创建一个打印信息的方法，然后将各个方法都封装到打印信息的方法中，然后在main类中创建对象并直接调用就行
Student类
public void printInfo(){
System.out.println("学生的信息:");
System.out.println(super.showInfo());
System.out.println(stu_id);
study();
System.out.println(play());
}Teacher类
public void printInfo(){
System.out.println("老师的信息:");
System.out.println(super.showInfo());
System.out.println("工龄" + work_age);
teach();
System.out.println(play());
}main类
package com.hspedu.homework.homework13;
public class HomeWork13 {
public static void main(String[] args) {
Teacher teacher = new Teacher("张飞", 30, '男', 5);
teacher.printInfo();
System.out.println("------------------");
Student student = new Student("小明", 15, '男', "00023102");
student.printInfo();
}
}
第七问：定义多态数组
因为要输出属性，所以在Person类中重写toString方法
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", sex=" + sex +
'}';
}main类
在main类中创建多态数组，并进行冒泡排序
package com.hspedu.homework.homework13;
public class HomeWork13 {
public static void main(String[] args) {
Teacher teacher = new Teacher("张飞", 30, '男', 5);
//(7)定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序
System.out.println("=========多态数组==========");
Person[] person = new Person[4];
person[0] = new Student("诸葛亮",26,'男',"3000456");
person[1] = new Student("徐庶",24,'男',"3000457");
person[2] = new Teacher("卢植",50,'男',14);
person[3] = new Teacher("司马徽",48,'男',20);
System.out.println("=========排序之前========");
for (int i = 0; i < person.length; i++) {
System.out.println(person[i]);
}
Person temp = null;
for (int i = 0; i < person.length - 1; i++) {
for (int j = 0; j < person.length - 1 - i; j++) {
if(person[j].getAge() < person[j+1].getAge()){
temp = person[j];
person[j] = person[j+1];
person[j+1] = temp;
}
}
}
System.out.println("=========排序之后========");
for (int i = 0; i < person.length; i++) {
System.out.println(person[i]);
}
}
}
运行结果
问题
只输出了三个属性，子类特有的属性并没有输出
原因
没有在子类中重写toString方法
解决办法
在子类中重写toString方法，并用super调用父类的toString方法
老师代码：main类
在HomeWork13的main类之外写一个冒泡排序的方法，封装起来，然后在main方法中创建新对象并调用
package com.hspedu.homework.homework13;
public class HomeWork13 {
public static void main(String[] args) {
Teacher teacher = new Teacher("张飞", 30, '男', 5);
//(7)定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序
System.out.println("=========多态数组==========");
Person[] person = new Person[4];
person[0] = new Student("诸葛亮",26,'男',"3000456");
person[1] = new Student("徐庶",24,'男',"3000457");
person[2] = new Teacher("卢植",50,'男',14);
person[3] = new Teacher("司马徽",48,'男',20);
System.out.println("=========排序之前========");
for (int i = 0; i < person.length; i++) {
System.out.println(person[i]);
}
HomeWork13 homeWork13 = new HomeWork13();
homeWork13.bubbleSort(person);
System.out.println("=========排序之后========");
for (int i = 0; i < person.length; i++) {
System.out.println(person[i]);
}
}
public void bubbleSort(Person[] person){//传进来一个Person类数组，数组类的元素都是编译类型是Person类的对象
Person temp = null;
for (int i = 0; i < person.length - 1; i++) {
for (int j = 0; j < person.length - 1 - i; j++) {
if(person[j].getAge() < person[j+1].getAge()){
temp = person[j];
person[j] = person[j+1];
person[j+1] = temp;
}
}
}
}
}
结果
第八问
在HomeWork13中main类之外新建一个方法test
在main类中循环遍历，调用test方法（我原先的代码是传具体的对象进去，比如person[0]和person[2]）
//遍历多态数组，调用test方法
System.out.println("=====================");
for (int i = 0; i < person.length; i++) {
homeWork13.test(person[i]);
}运行结果
第十四题
package com.hspedu.homework.homework14;
public class HomeWork14 {
public static void main(String[] args) {
C c = new C();
//考察知识点：在调用子类的构造器时会默认调用父类的无参构造器
//this和super不能同时出现在构造器（都需要在构造器的第一行）
//可以用super调用父类指定的构造器
//this调用本类的成员
//输出结果
//1、我是A类
//2、hahah我是B类的有参构造
//3、我是c类的有参参构造
//4、我是c类的无参参构造
}
}
class A{
public A(){
System.out.println("我是A类");
}
}
class B extends A {
public B() {
System.out.println("我是B类的无参构造");
}
public B(String name) {
System.out.println(name + "我是B类的有参构造");
}
}
class C extends B{
public C(){
this("hello");
System.out.println("我是c类的无参构造");
}
public C(String name){
super("hahah");
System.out.println("我是c类的有参参构造");
}
}
第十五题
题目
方法的多态
package com.hspedu.homework.homework15;
public class HomeWork15 {
public static void main(String[] args) {
//什么是多态？多态具体体现在哪里？可以举例说明
//多态的定义：顾名思义就是多种形态，包括方法的多态和对象的多态
//是OOP的第三大特征，是建立在封装和继承的基础上的
//方法的多态：方法的重写和重载
A a = new A();
a.test1218();
B b = new B();
b.test1218();
b.f1(12,35);
b.f2(12,35.5);
}
}
class A{
public void test1218(){
System.out.println("A类的test1218方法");
}
}
class B extends A{
@Override
public void test1218() {//方法重写
System.out.println("B类重写A类的test1218方法");
}
public void f1(int n1, int n2){
System.out.println(n1+n2);
}
public void f2(int n3,double n4){
System.out.println(n3+n4);
}
}
对象的多态
package com.hspedu.homework.homework15;
public class HomeWork1501 {
public static void main(String[] args) {
//对象的多态(核心，重点，难点)
//（1）对象的编译类型和运行类型可以不一致
//（2）一个对象的编译类型在创建的时候就已经确定了，是不能变化的
//（3）运行类型是可以变化的，可以通过getClass()来查看运行类型（getClass()是Object类的方法）
//（4）编译类型看=左边，运行类型看=右边
AA03 obj = new BB03();//向上转型
AA03 b1 = obj;//b1和obj指向同一个对象
System.out.println("obj的运行类型=" + obj.getClass());
System.out.println("b1的运行类型=" + b1.getClass());
//运行类型是可以改变的
obj = new CC03();//也是向上转型，运行类型变成了CC03
System.out.println("obj的运行类型=" + obj.getClass());
obj = b1;//此时运行类型又变成了BB03
System.out.println("obj的运行类型=" + obj.getClass());
}
}
class AA03{
}
class BB03 extends AA03{}
class CC03 extends BB03{}
第十六题
在运行过程中，方法的调用是由对象的运行类型，运行类型是哪个类，就首先调用此类中的方法，如果此类中没有，按照继承的查找原则，依次向上查找并调用（同时需要遵循访问修饰符原则）
属性和对象不同，没有对象绑定机制是在哪里声明就在哪里调用，
