20180117多态复习之二

多态：一种代码重用的机制。

分类：运行时多态（重写）和编译时多态（重载）。

/*代码举例*/
/*代码说明：督导监督教师教学和学生上课听课等情况*/
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.必须是父类声明，

实际是子类对象。

多态的作用特点：使得代码高效重用，也使得系统可扩展性强。

*/