2018.1.8转型

对象转型casting

分向上转型和向下转型（数据转型或对象转型）。

 

1.一个基类的引用类型变量可以指向其子类对象

 

2.基类的引用不可以访问子类新增加的成员

 

3.可以是使用 引用变量instanceof类名来判断该引用型变量所指向的对象是否属于该类或该类的子类。//instanceof的用法

 

4.子类的对象可以当做基类的对象来使用称作向上转型(upcasting)，反之称为向下转型(downloading)。

 

class Animal{

 public String name;

 Animal(String name){

 this.name=name;

 }

}

class Cat extends Animal{

 public String eyesColor;

 Cat(String n,String c){

 super(n);

 //调用了父类构造方法，并把n传给了name，回忆Super的用法？？子类可以调用父类引用，无需再次定义

 eyesColor=c;

 //指定了自己的新增加的成员变量为c

 }

}

class Dog extends Animal{

 public String furColor;

 Dog(String n,String c){

 super(n);

 furColor=c;

 }

}

 

public class Test{

 public static void main(String args[]){

 Animal a=new Animal("name");

 //新的对象叫name

 Cat c=new Cat("catname","blue");

 Dog d=new Dog("dogname","black");

 

 System.out.println(a instanceof Animal);//true,是不是动物的实例之一？true

 System.out.println(c instanceof Animal);//true

 System.out.println(d instanceof Animal);//true

 System.out.println(d instanceof cat);//false，动物不一定是猫

 

 a=new Dog("bigyellow","yellow");

 /*1.父类引用指向子类对象，只能父类Animal的对象a只能看到name     bigyellow*/

 //2.看不到furColor yellow(子类新增加的，要想看到必须强制转换类型为Dog类型)

 

 System.out.println(a,name);//bigyellow

 System.out.println(a.furname);//!error

 System.out.println(a instanceof Animal);//true

 System.out.println(a instanceof Dog);//true

 Dog d1=(Dog)a;

 /*要加强制转换符，强制转换成dog再访问a新增的，因为它扩大了

 栈内存中引用堆内存的访问空间，变成了Dog a，而不是Animal a，这是特指父类引用对子类的访问

 不可以强制转换成Cat,因为他是定义Dog的属性，这要运行会出现异常。

 */

 
 System.out.println(d1.furColor);//yellow，


 }

}
 

public class Test{

 public static void main(String args[]){

 Test test=new Test();

 Animal a=new Animal("name");

 Cat c=new Cat("catname","blue");

 Dog d=new Dog("dogname","black");

 test.f(a);test.f(c);test.f(d);

 }

 public void f(Animal a){

 System.out.println("name:"+a.name);

 if(a instanceof Cat){

 Cat cat=(Cat)a;

 System.out.println(" "+cat.eyesColor+"eyes");

 }else if(a instanceof Dog){

 Dog dog=(Dog)a;

 System.out.println(" "+dog.furColor+" fur");

 }

 //1.父类引用指向子类对象的一个好处就是可扩展性好，易于修改，对于后期维护很方便

 }

}

 

 

3.instanceof有什么作用？

它是二元运算符，作用是判断一个引用类型的变量所指向的对象是否是一个类（或接口、抽象类、父类）的实例，即它的左边的对象是否是右边类的实例该运算符返回boolean类型的数据。（判断是否是左边的类是否是一个实例化的对象）

 

常见用法：

result=object instanceof class.如果Object是class的一个实例，则该运算符会返回true，反之，不是其实例或为object为null，则返回false。

 

public class Test{

 public static void main(String args[]){

 String s="hello";

 int[] a={1,2};

 if(s instanceof String){

 System.out.println("true");

 }

 if(a instanceof Object){

 System.out.println("true");

 }

 if(a instanceof int[]){

 System.out.println("true");

 }

 

 }

}

/*

运行结果：

true

true

true

*/

 

 

 

向下转型：父类使用子类特有的方法。

public class Person1{

 private String name;

 private long    age;

 private String gender;

 

 public Person1(){

 

 }

 

 public String getName(){

  return name;

 }

 public void setName(String name){

  this.name=name;

 }

 

 public long getAge(){

  return age;

 }

 public void setAge(){

  this.age=age;

 }

 

 public String getGender(){

  return gender;

 }

 public void setGender(){

  this.gender=gender;

 }

 

}

 

public class Teacher extends Person1{

 private String majorField;

 

 public String getMajorField(){

  return majorField;

 }

 public void setMajorField(String majorField){

  this.majorField=majorField;

 }

 public Teacher(){

  majorField="music";

 }

}

 

public class TestPerson1{

 public static void main(String[] args) {

     Person1 p=new Teacher();

     p.setName("黄家驹");

     p.setAge(30);

     p.setGender("男");

     if (p instanceof Teacher) {

      Teacher t=(Teacher) p;

      t.setMajorField("music");

      t.print();

     }

 }

}