public class Person {

private String name;

private int age;

private String gender;

public Person(String name, int age, String gender) {

this.name = name;

this.age = age;

this.gender = gender;

}

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setAge(int age) {

this.age = age;

}

public int getAge() {

return age;

}

public void setGender(String gender) {

this.gender = gender;

}

public String getGender() {

return gender;

}

public String say() {

return "姓名:" + name + ",年龄:" + age + ",性别:" + gender;

}

public void sayHello() {

System.out.println("打个招呼");

}

}

public class Chinese extends Person {

private String shuxiang;

public Chinese(String name, int age, String gender, String shuxiang) {

super(name, age, gender);

this.shuxiang = shuxiang;

}

public void setShuxiang(String shuxiang) {

this.shuxiang = shuxiang;

}

public String getShuxiang() {

return shuxiang;

}

public void spring() {

System.out.println("过大年");

}

@Override

public String say() {

return super.say() + ",属相:" + shuxiang;

}

@Override

public void sayHello() {

System.out.println("吃了吗?");

}

}

public class American extends Person {

private boolean hasGun;

public American() {}

public American(String name, int age, String gender, boolean hasGun) {

super(name, age, gender);

this.hasGun = hasGun;

}

public void setHasGun(boolean hasGun) {

this.hasGun = hasGun;

}

public boolean isHasGun() {

return hasGun;

}

public void christmas() {

System.out.println("Merry Christmas!!");

}

@Override

public void sayHello() {

System.out.println("How are you?");

}

}

public class PersonTest {

public static void main(String[] args) {

Person[] ps = new Person[5]; // 多态数组, 可以保存任意类型的子类对象

ps[0] = new Chinese("张三", 30, "男", "牛");

ps[1] = new American("Jack", 25, "male", true);

ps[2] = new Person("某人", 15, "未知");

ps[3] = new American("Rose", 32, "female", false);

ps[4] = new Chinese("李四", 40, "女", "羊");

for (Person p : ps) {

System.out.println(p.say());

}

System.out.println("-------------------------");

// 因为在同一个数组中, 并且所有对象都有age属性, 所以就可以对所有元素进行冒泡排序

for (int i = 0; i < ps.length - 1; i++) {

for (int j = 0; j < ps.length - 1 - i; j++) {

if (ps[j].getAge() > ps[j + 1].getAge()) {

Person tmp = ps[j];

ps[j] = ps[j + 1];

ps[j + 1] = tmp;

}

}

}

for (Person p : ps) {

System.out.println(p.say());

}

}

}

public class Person extends Object {…}

public class Student extends Person {…}

public class Graduate extends Person {…}

-------------------------------------------------------------------

public void method1(Person e) {

         if (e instanceof Person)

                   // 处理Person类及其子类对象

         if (e instanceof Student)

                   //处理Student类及其子类对象

         if (e instanceof Graduate)

                   //处理Graduate类及其子类对象

}

较高级的基本数据类型

较低级的基本数据类型

自动类型转化

强制类型转化

父类（如：Person）

子类（如：Student）

向下转型

使用instanceof进行判断

向上转型

class PersonTest5 {

public static void test(Person p) { // 多态参数, 提高了兼容性!!

p.sayHello(); //方法中父类中定义,所以直接调用,

//p.spring(); // 多态副作用, 子类特有成员不能访问

// 必须对对象的真实身份进行检测

if (p instanceof Chinese) { // 造型有风险, 使用须谨慎!!!

Chinese ch = (Chinese)p; // 造型: 对象是什么类型还原成什么类型

ch.spring(); // 子类特有的成员的访问,必须要经过造型.

} else if (p instanceof American) {

((American)p).christmas();

} else if (p instanceof Person){

System.out.println("普通人一枚");

}

}

public static void main(String[] args) {

Person[] ps = new Person[5]; // 多态数组, 可以保存任意类型的子类对象

Chinese c1 = new Chinese("张三", 30, "男", "牛");

American a1  = new American("Jack", 25, "male", true);

Person p1 = new Person("某人", 15, "未知");

American a2 = new American("Rose", 32, "female", false);

Chinese c2 = new Chinese("李四", 40, "女", "羊");

ps[0] = c1;

ps[1] = a1;

ps[2] = p1;

ps[3] = a2;

ps[4] = c2;

System.out.println("-------------------------");

for (Person p : ps) {

test(p); // 不同的子类对象作为实参调用方法, 方法的执行也不一样.

}

}

}