多态：一种代码重用的机制。
分类：运行时多态（重写）和编译时多态（重载）。
/*代码举例*/
/*代码说明：督导监督教师教学和学生上课听课等情况*/
public class Person{
private String name;
private int age;
private char gender;
public Person(){
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public String getAge(){
return age;
}
public void setGender(char gender){
this.gender=gender;
}
public char getGender(){
return gender;
}
public void print(){
System.out.println("我是"+name+",年龄是"+age+"岁，我的性别是"+gender);
}
}
/*教师类*/
public class Teacher extends Person{
private String majorField;
public void setMajorField(String majorField){
this.majorField=majorField;
}
public String getMajorField(){
return majorField;
}
public Teacher(){
majorField=".net";
}
public Teacher(int a,char g){
}
public void print(){
super.print();
System.out.println(",我的授课方向是"+majorField);
}
//调用父类方法并在后面加上自己特有的内容
}
/*Student类*/
public class Student extends Person{
private String grade;
public void setGrade(String grade){
this.grade=grade;
}
public String getGrade(){
return grade;
}
public void print(){//重写
super.print();
System.out.println(",目前我上"+grade);
}
}
public class Supervisor{
//监督教师的方法
public void supervise(Teacher t){
System.out.println("开始监督");
System.out.println("1.表达准确");
System.out.println("2.讲解思路清晰");
}
//监督学生的方法
public void supervise(Student s){
System.out.println("开始监督...");
System.out.println("1.不迟到，早退，旷课");
System.out.println("2.课堂认真学习");
}
}
/*测试类*/
public class Test{
public static void main(String[] args) {
Supervisor supervisor=new Supervisor();
supervisor.supervisor(new Student());
supervisor.supervisor(new Teacher());
//上面这两行代码怎么理解？？
}
}
/*程序问题分析：
*1.学生和老师上课应该属于学生和老师的行为，不应该放在监督类中
*2.这个程序的扩展性不好，若要在督导类中添加新的人员，则需要增添新的类
*然后还要修改督导类。(要求：高内聚，低耦合)
*/
/*
*如何修改呢？
*1.learn方法放到person类中，并在teacher类和Person类中重写person类中上课方法
* public void learn(){
*
* }
*2.在督导类中修改监督方法supervise()，参数类型改为Person对象类型
*/
//代码修改如下
/*代码说明：督导监督教师教学和学生上课听课等情况*/
public class Person{
private String name;
private int age;
private char gender;
public Person(){
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age=age;
}
public String getAge(){
return age;
}
public void setGender(char gender){
this.gender=gender;
}
public char getGender(){
return gender;
}
public void print(){
System.out.println("我是"+name+",年龄是"+age+"岁，我的性别是"+gender);
}
public void learn(){
//后来加的一个learn的空方法
}
}
/*教师类*/
public class Teacher extends Person{
private String majorField;
public void setMajorField(String majorField){
this.majorField=majorField;
}
public String getMajorField(){
return majorField;
}
public Teacher(){
//this.majorField="";
this.(".net");
//调用构造方法必须是第一句，它调用本类中其它的构造器
}
public Teacher(String majorField){
this.majorField=majorField;
//this调用自己的属性
}
public void print(){
//System.out.println("执行Teacher中的print方法");
super.print();
System.out.println(",我的授课方向是"+majorField);
//调用自己的某个方法
}
//调用父类方法并在后面加上自己特有的内容
//真正实现的learn方法
public void learn(){
System.out.println("1.表达准确");
System.out.println("2.讲解思路清晰");
}
}
/*Student类*/
public class Student extends Person{
private String grade;
public void setGrade(String grade){
this.grade=grade;
}
public String getGrade(){
return grade;
}
public void print(){
super.print();
System.out.println(",目前我上"+grade);
}
//真正实现的learn方法
public void learn(){
System.out.println("1.不迟到，不早退。");
System.out.println("2.课堂上认真听讲");
}
}
/*监督者类*/
public class Supervisor{
public void supervise(Person p){
System.out.println("开始监督...");
p.learn();
/*两个监督方法变成一个，以此降低类之间的耦合性，
实现“低耦合”的要求，利于后期修改和增加特殊的类*/
}
}
/*测试类*/
public class Test{
public static void main(String[] args) {
Supervisor supervisor=new Supervisor();
supervisor.supervisor(new Student());
supervisor.supervisor(new Teacher());
}
}
/*说明：
supervise(Person p)中，这个监督方法所带的Person对象，在测试
类中给的实际对象是Student和Teacher对象，在运行”p.learn();”
语句的时候，可以是是Student和Teacher对象，也可以说是Person的任何一个子类对象。这就是多态，也叫表现形式多态，p就有多种表现形态。
多态的产生条件：1.必须有继承 2.有方法重写 3.必须是父类声明，
实际是子类对象。
多态的作用特点：使得代码高效重用，也使得系统可扩展性强。
*/
来源：https://www.cnblogs.com/shijinglu2018/p/8306395.html