class Person{ public String getName(){...} }class Student extends Person{ public String getSchool(){...} }.....//学生是个人,所以创建学生对象以后,当然也就创建了一个人对象呀。所以下面代码是OK Person person = new Student(); 至于“接口缩小,方法减少”表示,子类继承父类以后,可以扩充更多方法,反过来看,从子类 转化为父类,“能用的”方法就少了。如上面的 Person person ,用person 就不能访问getSchool()了。
为什么会安全呢?我也很奇怪啊。 我现在对向上转型的理解是为了创建像C++里面的万能指针一样的东西 class Person{ public String getInformation(){ return("Person"); } }class Student extends Person{ public String getInformation(){ return("Student"); } }class Teacher extends Person{ public String getInformation(){ return("Teacher"); } }public class Test{ public static void main(String[] args){ Person p; p = new Person(); System.out.println(p.getInformation()); p = new Student(); System.out.println(p.getInformation()); p = new Teacher(); System.out.println(p.getInformation()); } }其中,Student的getInformation和Teacher的getInformation分别改写了Person的getInformation,因此在执行p.getInformation()时会出现不同的结果实现多态。这是我对向上转型的理解。至于安全性,我不太懂,难道说方法越少越安全?
你可以把多态理解成一个对象有多种类型比如你的例子 Student stu = new Student(); Teacher tch = new Teacher();stu 是一个 Student 类型的实例,但同时它又是 Person 的一个实例,它同时具有了 Student 和 Person 两个类型 tch 是一个 Teacher 的实例,但同时它也是 Person 的一个实例这是多态的一种情况。 楼主的这句话“由于向上转型是从一个较专用类型向较通用类型转,所以总是很安全的” 你可以这样理解:子类的对象必然是其父类的一个对象,因此子类向父类转型是很正常的。 正如你的模型中那样,一个学生肯定会是一个人,一个老师也一定是一个人,因此 Person p = new Student(); 是可以自动转型的,也是很安全的相对来说,父类向子类转型是不安全的,还是用你的模型,一个人(Person)是可能是一个Teacher,也可能是一个 Student,因此下面的语句可能会出运行时异常: Person p = ...... Student stu = (Student)p;
class Person{
public String getName(){...}
}class Student extends Person{
public String getSchool(){...}
}.....//学生是个人,所以创建学生对象以后,当然也就创建了一个人对象呀。所以下面代码是OK
Person person = new Student();
至于“接口缩小,方法减少”表示,子类继承父类以后,可以扩充更多方法,反过来看,从子类
转化为父类,“能用的”方法就少了。如上面的 Person person ,用person 就不能访问getSchool()了。
对于person 只是看到了student内部的person 所以用person 就不能访问getSchool()了
这就是“接口缩小,方法减少”
哈哈,我今天也刚好看到《Thingking in java》的这句话~貌似向上转型之后,我的理解是:作为转型之后的类型使用时,是用不到那些被缩小的接口和被减少的方法的,所以是安全的
父类是比子类更加“泛”的类型,也就是楼主说的更加“通用”的类型
例:水果 extends Object
桔子 extends 水果
西瓜 extends 水果很明显,一个“西瓜”的对象其实也是其父类“水果”的一个对象
所以
水果 obj = new 桔子();是安全的,也就是“由于向上转型是从一个较专用类型向较通用类型转,所以总是很安全的”另外,也可以得出结论,“向下转型是可能的,但是不一定是安全的”,比如
水果 obj1 = ......
桔子 obj2 = (桔子)obj1;
因为 obj1 可能是一个桔子,所以说这是可能的,但obj1 还可能是其它的水果,比如西瓜,苹果等最后还可以得出结论,不在一个体系中的转型是不可行的,比如再加一个模型:
学习用具 extends Object
尺子 extends 学习用具
钢笔 extends 学习用具很显然,“尺子”不可有是一个“苹果”,一个“桔子”也不可能是一个水果......所以下面的转型是会报编译错误:
学习用具 obj = (学习用具)(new 苹果());
我现在对向上转型的理解是为了创建像C++里面的万能指针一样的东西
class Person{
public String getInformation(){
return("Person");
}
}class Student extends Person{
public String getInformation(){
return("Student");
}
}class Teacher extends Person{
public String getInformation(){
return("Teacher");
}
}public class Test{
public static void main(String[] args){
Person p;
p = new Person();
System.out.println(p.getInformation());
p = new Student();
System.out.println(p.getInformation());
p = new Teacher();
System.out.println(p.getInformation());
}
}其中,Student的getInformation和Teacher的getInformation分别改写了Person的getInformation,因此在执行p.getInformation()时会出现不同的结果实现多态。这是我对向上转型的理解。至于安全性,我不太懂,难道说方法越少越安全?
Student stu = new Student();
Teacher tch = new Teacher();stu 是一个 Student 类型的实例,但同时它又是 Person 的一个实例,它同时具有了 Student 和 Person 两个类型
tch 是一个 Teacher 的实例,但同时它也是 Person 的一个实例这是多态的一种情况。
楼主的这句话“由于向上转型是从一个较专用类型向较通用类型转,所以总是很安全的”
你可以这样理解:子类的对象必然是其父类的一个对象,因此子类向父类转型是很正常的。
正如你的模型中那样,一个学生肯定会是一个人,一个老师也一定是一个人,因此
Person p = new Student();
是可以自动转型的,也是很安全的相对来说,父类向子类转型是不安全的,还是用你的模型,一个人(Person)是可能是一个Teacher,也可能是一个 Student,因此下面的语句可能会出运行时异常:
Person p = ......
Student stu = (Student)p;