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;

多态的意义

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