自动转型与强制转型

自动转型与强制转型

 

1.要想实现自动转型必须要存在继承关系(也就是父子关系).

自动转型的格式:

父类名  对象名 = new 子类构造方法();

例：Student stu = new UNStudent();

自动类型转换，也称隐式类型转换，是指不需要书写代码，由系统自动完成的类型转换。由于实际开发中这样 的类型转换很多，所以Java语言在设计时，没有为该操作设计语法，而是由JVM自动完成。

(1).一个对象可以自动地由父类转型为子类对象，比如定义了一个“public class Student”类，让一个大 学生public class UNStudent extends Student，定义“Student stu=new UNStudent();”,这时 父类的stu对象就可以自动转型为子类的对象；父类转换成子类，调用重写方法。

 

    (2).如果子类中的函数中要传入父类对象的，在主函数中，定义了一个子类对象，则可以调用这个函数， 并传入子类的对象是可以的。

    (3).一个父类的对象的指向传给子类的对象时必须要强制转型，例如

    public void tc(Object st){

    //强制转型

    UNStudent us=(UNStudent)st; //us指向了st所指向的空间

    us.play();    //UNStudent为一个子类，play()是其中的方法    }  

强制类型转换，也称显式类型转换，是指必须书写代码才能完成的类型转换。该类类型转换很可能存在精度的 损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。

自动转型的缺点：

因为java的编译机制是固定的，所有要调用的方法，如果在对象名的类型中不存在，那么java的编译机制就会 跑出语法错误。

优点：

提高代码的重用性，减少代码量。

举例：学校中有英语老师，可以教大学生英语。

这个英语老师可以不可以教高中生？

这个英语老师可以不可以教初中生？

这个英语老师可以不可以教小学生？

不管是小学生，初中生，高中生还是大学生都是属于学生这一大类中的。

//这个代码是没有到自动转型的，看起来很麻烦

Teacher {

teach(UNStudent un){un.study();}

teach(GStudent g){g.study();}

teach(CStudent c){c.study();}

teach(XStudent x){x.study();}

}

//这个代码是用到自动转型的，这样子就简单的多了

Teacher {

teach(Student stu){stu.study();}

}

 

请看下边的代码示例：

 

 

//定义一个Student类

public class Student {

//声明一个姓名属性

public String name;

//声明一个学分属性

protected double score;

//定义一个不带参数的构造方法

public Student(){}

//定义一个带姓名参数的构造方法

public Student(String name){

this.name = name;

}

//定义设置姓名属性值的方法

protected void setName(String name){

//将参数n的值赋给属性name

this.name = name;

}

//定义获取姓名属性值的方法

public String getName(){

//使用return 返回name属性值

return name;

}

//定义一个学习方法

public void study(){

//让学分加1

score++;

//输出学生的信息

System.out.println(name+"学习中,学分是:"+score);

}

//重载一个学习方法

public void study(double score){

//把参数的值和学分的值相加

this.score+=score;

//输出学生的信息

System.out.println(name+"学习中,学分是:"+score);

}

/** 定义一个教师类

* @author wang

*

*/

public class Teacher {

private String name;//声明一个姓名属性

/**

* 定义设置姓名属性值的方法

*/

public void setName(String name){

this.name = name;

}

/**

* 定义获取姓名属性值的方法

*/

public String getName(){

return name;

}

/**

* 定义一个教学的方法，教的是学生，所以要传递一个学生对象作为参数

*/

public void teach(Student stu){

//输出

System.out.println(name+"在教"+stu.getName()+"学习英语");

stu.study();

}

}

 

//定义一个UNStudent类

public class UNStudent extends Student {

//重写父类不带参数的学习方法

public void study(){

System.out.println("我是大学生，我的学习方式不同啦！");

}

//定义一个玩的方法

public void play(){

System.out.println("我是大学生，我在打多塔！");

}

}

 

 

 

//定义程序的测试类

public class Test {

//定义主函数

public static void main(String [] args){

//实例化一个UNStudent类的对象

Student un = new UNStudent();

//调用设置名字的方法

un.setName("王英华");

//实例化一个UNStudent类的对象

UNStudent un2 = new UNStudent();

//调用设置名字的方法

un2.setName("王英华2");

//实例化一个Teacher类的对象

Teacher tea = new Teacher();

//调用教学的方法

tea.teach(un);

tea.teach(un2);

}

}

 

运行结果为：

 

null在教王英华学习英语

我是大学生，我的学习方式不同啦！

null在教王英华2学习英语

我是大学生，我的学习方式不同啦！

 

 

总结：子类的指向转化为父类的指向（父类的指向要）强制转型（为子类的指向），父类的指向转化为子类的指向（父类的指向会）自动转型（为子类的指向），但是在这里注意，不同类型的绝不能转换。

我是老师，我可以教学生（父类），

public class teach(Student,s){

s.student

}

我可以教大学生（子类），

定义父类：学生学习方法

public class Students{

public void study(){

print("学生学习")；

}

}

定义子类：大学生学习方法

public class UnStudent extends Students{

public void study(){

print("大学生学习")；

}

}

我（教师）现在要教大学生

public class Manage（）{

psvm（）{

Student stu = new UNStudent；

Teacher tea = new Teacher（）；

tea.teach(stu); // 父类转成了子类。

}

}