java面向对象的封装、继承、多态案例

Person父类

public class Person {
    private String name;
    private int age;

    public Person() {
        super();
    }   
    public Person(String name, int age) {
        super();
        setName(name);
        setAge(age);
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age > 0 && age < 150){
            this.age = age;
        }
        else{
            System.out.println("年龄不合理！！！");
        }
    }
    public void show(){
        System.out.println("我是" + getName() + ",今年" + getAge() + "岁了!");
    }
    public static void test(){
        System.out.println("Person类中的静态方法");
    }

}

Student子类继承Person父类

public class Student extends Person {
    private int id;

    public Student() {
        super();
    }

    public Student(String name, int age,int id) {
        super(name, age);
        setId(id);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if(id > 0){
            this.id = id;
        }else{
            System.out.println("学号不合理!!!");
        }
    }

    @Override
    public void show(){
        super.show();
        System.out.println("我的学号是: " + getId());
    }
    public static void test(){
        System.out.println("Person类中的静态方法");
    }
}

测试类

public class TestPersonStudent {

    public static void main(String[] args){
        //使用父类的引用指向父亲自己的对象
        Person p = new Person("zhangfei", 30);
        //调用Person类自己的show()方法
        p.show();

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

        //使用子类自己的引用指向子类自己的对象
        Student s = new Student("guanyu", 35, 1001);
        //当子类中没有show()方法时,则调用父类Person中的show()方法
        //当子类重写show方法后,则调用子类Student自己的方法
        s.show();

        System.out.println("----------------------");
        //使用父类的引用指向子类的对象，形成多态
        //发生Student类型向Person类型的转换，小范围向大范围转换，自动类型转换
        Person ps = new Student("liubei", 40, 1001);
        //解析:在编译阶段调用Person类的show()方法,在运行阶段调用Student的show方法
        ps.show();

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

        //使用ps调用非静态的方法进行测试
        //ps是Person类型自己的引用，因此可以调用Person类型自己的方法
        String str = ps.getName();
        System.out.println("获取到姓名的是: " + str);//liubei

        //ps.getId(); error

        System.out.println("-----------------------");
        //使用ps调用静态的方法进行测试,静态的方法推荐使用类名. 的方式访问
        //ps.test();
        Person.test();

        System.out.println("-----------------------");
        //如何实现子类中方法的调用呢?
        //Person类型向Student类型转换,大 => 小,需要强制类型转换
        //目标类型  变量名 = (目标类型)源类型的变量名;
        Student st = (Student)ps;
        int res = st.getId();
        System.out.println("res = " + res);

        //String sr = (String)ps; error
        //Teacher t = (Teacher)ps;//编译通过,运行时类型转换异常
        /* 如果修改的话
         * Person dd = new Teacher();  //使用父类的引用指向了子类的对象 这样就正确了
         * Teacher t = (Teacher)dd; 
         * int ee = t.getSex();
         * System.out.println("性别是" + ee);
         * */       
        //判断ps真正指向的对象类型是否为Teacher类型,若是则返回true,否则false
        if(ps instanceof Teacher){
            System.out.println("可以放心地进行强制类型转换了...");
        }else{
            System.out.println("不能进行强制类型转换!");
        }

    }
}

教师类

package xdl.day09;

public class Teacher extends Person {
/*    private int sex;

    public Teacher(){
        super();
    }
    public Teacher(int sex) {
        super();
        setSex(sex);
    }

    public int getSex() {
        return sex;
    }

    public void setSex(int sex) {
        this.sex = sex;
    }
    public void show(){
        super.show();
        System.out.println("我的性别是"+getSex());
    }
  */  
}

---

多态：
多态就是指同一种事物表现出来的多种形态。
如：
饮料：可乐、雪碧、乐虎、脉动……
图形：矩形、圆、三角形……
整数:byte b= 10; short s = 10; int i = 10;…

多态的语法格式：
父类类型 引用 = new 子类类型();
如:

Person p = new Student();
p.show();

解析：
在编译阶段p是Person类型，因此调用Person类自己的show()方法，若没有则编译报错；
在运行阶段p真正指向的对象是Student类型，因此最终调用Student类中自己的show()方法。

多态的效果
(1)对于指向子类对象的父类引用来说，在编译阶段只能直接调用父类的方法,不能直接调用子类。
(2)对于父子类都有的非静态方法来说，最终调用子类的重写版本；
(3)对于父子类都有的静态方法来说，最终调用父类中的版本，与指向的对象类型无关；

引用类型之间的转换
(1)引用类型之间的转换必须发生在父子类之间，分为自动类型转换 和 强制类型转换；
(2)其中子类类型向父类类型的转换需要发生自动类型转换即可；
其中父类类型向子类类型的转换需要发生强制类型转换才可以；
(3)若没有父子类关系发生强转是则编译报错，当拥有父子类关系发展强转是则编译通过。
若目标类型不是该引用真正指向的类型时，在运行阶段发生类型转换异常；
(4)为了避免上述错误的发生，通常只有进行强制类型转换就需要进行判断，格式如下：

        if(引用变量名 instanceof 数据类型){
            System.out.println("可以放心地进行强制类型转换了...");
        }else{
            System.out.println("不能进行强制类型转换!");
        }
    //-判断引用指向的对象是否为指定的数据类型，如是则返回true,否则返回false;

多态的意义
可以屏蔽不同子类的差异性编写通用的代码，从而产生不同的效果。