目录
第一题
思路分析：
1.Person p = new Student();这就是一个向上转型，让父类的引用指向子类的对象，但是向上转型不能访问子类的属性和方法 我们在写代码时看的是编译类型 在运行是看的是运行类型
p.run();
p.eat();
所有只能访问父类的两个方法
2.向下转型只能强转父类的引用，不能强转父类的对象
如果写成Student s = (Student) Person就会报错
应该写成Student s = (Student) p
向下转型语法
子类类型 引用名 =（子类类型）父类引用; 注意是父类的引用
向下转型后可以访问子类的属性和方法
Student s = (Student) p;//向下转型
因为父类有和子类相同的方法所以只能调用其中之一 具体调用那个根据情况而定
属性没有重写之说，属性的值看编译类型 方法看运行类型
package idea.homework.homework11;
public class homework11 {
public static void main(String[] args) {
//person person = new Person();
Person p = new Student();//向上转型 让父类的引用指向子类的对象 不能访问子类的属性和方法
//在写代码时看的是编译类型 在运行是看的是运行类型
p.run();
p.eat();
//2)只能强转父类的引用，不能强转父类的对象 如果写成Student s = (Student) Person就会报错
//应该写成Student s = (Student) p
//向下转型语法 子类类型 引用名 =（子类类型）父类引用; 注意是父类的引用
//向下转型后可以访问子类的属性和方法
//
Student s = (Student) p;//向下转型
//因为父类有和子类相同的方法所以只能调用其中之一 具体调用那个根据情况而定
//属性没有重写之说，属性的值看编译类型 方法看运行类型
s.run();
s.eat();
s.study();
}
}
class Person {
public void run() {
System.out.println("person run");
}
public void eat() {
System.out.println("person eat");
}
}
class Student extends Person {
public void run() {
System.out.println("student run");
}
public void study() {
System.out.println("student study..");
}
}
第二题
思路分析：
说出==和equals的区别
==是比较运算符 ==左右两边是基本数据类型时判断的是两个值是否相同 左右两边是引用类型时默认判断的时地址是否相同
equals方法
在没有重写equals方法时 默认调用object的equals方法判断的时地址是否相同 重写了equals方法后，判断的是两个对象的内容是否相同 equals不能用于基本数据类型 Java所有的类都可以使用equals
package idea.homework.homework12;
public class homework12 {
public static void main(String[] args) {
//12.说出==和equals的区别
/*
==是比较运算符
==左右两边是基本数据类型时判断的是两个值是否相同
左右两边是引用类型时默认判断的时地址是否相同
equals方法
在没有重写equals方法时 默认调用object的equals方法判断的时地址是否相同
重写了equals方法后，判断的是两个对象的内容是否相同
equals不能用于基本数据类型
Java所有的类都可以使用equals
*/
}
}
第三题
思路分析：
1.我们要发现，一开始我们在定义学生类和老师类的时候，这两个类中我们都有name age 等属性，所有我们把该属性抽出来，做成一个Person类，这个我们子类子需要继承父类就可以了
2.创建一个Person数组，因为Students和Teacher都继承了Person了所有，可以存放到Person数组中，使用冒泡排序，按照年龄进行排序，注意在比较的时候，比较的是年龄，但是在交换的时候，交换的可不是年龄，因此在定义辅助变量的时候，需要定义一个Person类型的
homework13类
package idea.homework.homework13;
public class homework13 {
public static void main(String[] args) {
/*
(1)做一个Student类，Student类有名称(name)，性别(sex)，年龄
(age)，学号(stu_id)，做合理封装，通过构造器在创建对象时将4个属性赋值。
（2）写一个Teacher类，Teacher类有名称（name），性别（sex），年年龄：30 龄（age)，工龄（work_age)，做合理封装，通过构造器在创建对象时将性别：男 4个属性赋值。
（3）抽取一个父类Person类，将共同属性和方法放到Person类
（4）学生需要有学习的方法（study），在方法里写生“我承诺，我会好王飞爱玩象棋 好学习。 。
(5)教师需要有教学的方法(teach)，在方法里写上“我承诺，我会认真教学
（6）学生和教师都有玩的方法（play），学生玩的是足球，老师玩的是象棋，此方法是返回字符串的，分别返回“xx爱玩足球”和“xx爱玩象棋”
（其中xx分别代表学生和老师的姓名）。因为玩的方法名称都一样，所以 要求此方法定义在父类中，子类实现重写。
（7）定义多态数组，里面保存2个学生和2个教师，要求按年龄从高到低排序，
(8)定义方法，形参为Person类型，功能：调用学生的study或教师的teach方法
*/
//创建了一个Person数组，也就是多态数组，该数组可以存放Student 和 Teacher
Person[] p = new Person[4];
//为数组进行初始化
p[0] = new Student("jack", '男', 2);
p[1] = new Student("tom", '男', 1);
p[2] = new Teacher("many", '男', 3);
p[3] = new Teacher("smith", '男', 4);
//使用冒泡排序，按照年龄进行排序，注意在比较的时候，比较的是年龄，但是在交换的时候，交换的可不是年龄，因此在定义辅助变量的时候，需要定义一个Person类型的
for (int i = 0; i < p.length - 1; i++) {
for (int j = 0; j < p.length - 1 - i; j++) {
if (p[j].getAge() > p[j + 1].getAge()) {
Person tmp = p[j];
p[j] = p[j + 1];
p[j + 1] = tmp;
}
}
}
//遍历数组
for (int i = 0; i < p.length; i++) {
//在输出p[i]的时候等价于p[i].toString()
System.out.println(p[i]);
}
System.out.println();
//遍历数组
for (int i = 0; i < p.length; i++) {
//对数组中的元素进行比较，如果运行类型是Student那么就调用student中的方法
if (p[i] instanceof Student){
((Student) p[i]).study();
//对数组中的元素进行比较，如果运行类型是teacher那么就调用teacher中的方法
}else if (p[i] instanceof Teacher){
((Teacher)p[i]).teach();
}else {
System.out.println("不做处理");
}
}
}
}
Person类
package idea.homework.homework13;
/**
* Person类——父类
*/
public class Person {
//因为两个子类中，都有name age 等属性，那么我们把共同的部分给提取出来，做成一个父类
private String name;
private char sex;
private int age;
public Person(String name, char sex, int age) {
this.name = name;
this.sex = sex;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
// （6）学生和教师都有玩的方法（play），学生玩的是足球，老师玩的是象棋，此方法是返回字符串的，分别返回“xx爱玩足球”和“xx爱玩象棋”
// （其中xx分别代表学生和老师的姓名）。因为玩的方法名称都一样，所以 要求此方法定义在父类中，子类实现重写。
//这是父类特有的方法
public String play() {
return this.name + "爱玩";
}
//重新写toString方法是为了方便对象的输出
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", sex=" + sex +
", age=" + age +
'}';
}
}
Student类
package idea.homework.homework13;
public class Student extends Person{
// (1)做一个Student类，Student类有名称(name)，性别(sex)，年龄
// (age)，学号(stu_id)，做合理封装，通过构造器在创建对象时将4个属性赋值。
private String stu_id;
public Student(String name, char sex, int age) {
super(name, sex, age);
}
public String getStu_id() {
return stu_id;
}
public void setStu_id(String stu_id) {
this.stu_id = stu_id;
}
//（4）学生需要有学习的方法（study），在方法里写生“我承诺，我会好王飞爱玩象棋 好学习。 。
public void study(){
System.out.println(super.getName()+"我会好好学习");
}
@Override
public String play() {
return "象棋";
}
}
Teacher类
package idea.homework.homework13;
public class Teacher extends Person {
//（2）写一个Teacher类，Teacher类有名称（name），性别（sex），年年龄：30 龄（age)，工龄（work_age)，做合理封装，通过构造器在创建对象时将性别：男 4个属性赋值。
private int work_age;
public Teacher(String name, char sex, int age) {
super(name, sex, age);
}
public int getWork_age() {
return work_age;
}
public void setWork_age(int work_age) {
this.work_age = work_age;
}
//(5)教师需要有教学的方法(teach)，在方法里写上“我承诺，我会认真教学
public void teach() {
System.out.println(super.getName() + "我承若我会认真教学");
}
@Override
public String play() {
return "足球";
}
}