精华内容
下载资源
问答
  • 对象类型转换

    千次阅读 2018-04-01 23:01:13
    向上转型是指父类引用子类对象,就是子类对象转换成父类对象。 假设有父类Person类对象p和子类Student对象s,则 Person p; p=new Student(); //父类Person对象p引用子类Student新创建的对象 Student s=new ...

    1.向上转型

    向上转型是指父类引用子类对象,就是子类对象能转换成父类对象。

    假设有父类Person类对象p和子类Student对象s,则

    Person p;
    p=new Student();	//父类Person对象p引用子类Student新创建的对象
    Student s=new Student();
    p=s;				//父类Person对象p引用子类Student对象s
    也可以直接写成:
    Person p=new Student();//父类Person对象p引用子类Student新创建的对象

    当子类对象s赋给父类对象p时,是隐式转换,不用进行强制类型转换。对于上述例子,父类引用子类对象后只能引用父类中的成员变量和方法,而不能访问子类自己定义的成员变量和成员方法。

    所以综上所述向上转型的特点如下:

    (1)向上转型对象不能操作子类新增的成员变量(失掉了这部分属性),不能使用子类新增的方法(失掉了一些功能)。

    (2)向上转型对象可以操作子类继承或重写的成员变量,也可以使用子类继承的或重写的方法。

    (3)如果子类重写了父类的某个方法后,当对象的向上转型对象调用这个方法时一定是调用了这个重写的方法,因为程序在运行时知道,这个向上转型对象的实体是子类创建的,只不过损失了一些功能而已。

    (4)对象的向上转型对象再强制转换到该子类的一个对象,这时又具备了子类所有的属性和功能。

    2.向下转型

    向下转型是指子类引用父类对象,就是将父类对象能转换成子类对象,这时需要满足两个条件:一是必须执行强制类型转换;二是必须确保父类对象是子类的一个实例,否则抛出异常。

    假设有父类Person类对象p和子类Student对象s

    由于Student是Person的子类,下列语句是正确的:

    Person p=new Student();//父类Person对象p引用子类Student的对象
    Student s=(Student)p;	//父类对象p赋给子类对象s,当前p是子类Student的引用

    但是,下列语句有错误:

    Person p=new Person();//父类对象p引用父类Person的对象
    Student s=(Student)p;	//父类对象p不能赋给子类对象s,因为当前p不是子类的引用

    上述代码尽管能通过编译,但运行时将抛出ClassCastException异常,强制转换无法实现。

    所以综上所述向下转型的特点如下:

    (1)向下转型对象可以操作父类及子类成员变量和成员方法。

    (2)向下转型对象访问重写父类的方法时,操作的是子类的方法。

    (3)向下转型必须进行强制类型转换。

    (4)向下转型必须保证父类对象引用的是该子类的对象,如果引用的是父类的其他子类对象,会抛出类型不匹配异常。

    3.instanceof运算符

    父类对象能转换成子类对象的条件是父类对象原本就是子类的实例。为了确保向下转型时,父类对象引用的是子类的对象,引入instanceof运算,该运算符用来判断该引用变量是否属于该类或该类的子类。

    instanceof运算的格式为:

    引用变量名 instanceof 类名

    如果该引用变量引用的是这个类的对象,或这个类的子类的对象,则运算结果为true;否则为false。

     

    展开全文
  • C# 对象类型转换

    千次阅读 2016-08-03 17:24:36
    C# 对象类型转换

    在日常开发时,经常需要将对象从一种类型转换为另一种类型。CLR允许将对象转换为它的(实际)类型或者它的任何基类型。

    C#不要求任何特殊语法即可将对象转换为它的任何基类型,因为向基类型的转换被认为是一种安全的隐式转换。然而,将对象转换为它的某个派生类型时,C#要求开发人员只能进行显式转换,因为这种转换可能在运行时失败。可以理解为:父类强制转换成子类,子类隐式转换成父类

        internal class Employee
        {
        }
    
        class Program
        {
            static void Main(string[] args)
            {
            // 子类隐式转换成父类,不需要转换
            // 因为new返回一个Employee对象,而Object是Employee的基类
            Object o = new Employee();
            // 子类可以自动转父类 可以这么理解把子类的实例em的地址赋值给了o1, o1的地址就是em的地址
            // 这时就可以调用Employee 类的方法,点出Employee 类的属性
            Employee em = new Employee();
            Object o1 = em;
    
                // 父类强制转换成子类, 需要转换
                // 因为Employee派生自Object
                Employee e = (Employee)o;
            }
        }

    在运行时,CLR会检查转型操作,确定总是转换为对象得实际类型或者它的任意类型。下面的代码虽然能通过编译,但会在运行时抛出InvalidCastException异常:

        internal class People
        {
        }
    
        internal class Employee : People
        {
        }
    
        internal class Manager : Employee
        {
        }
    
        class Program
        {
            static void Main(string[] args)
            {
                // 创建实例的时候没有将父类引用到子类对象,是无法转换的
                // PromoteEmployee不能运行成功
                People p = new People();
                PromoteEmployee(p);
    
                // 创建实例的时候将父类引用到子类对象,是可以转换的
                // PromoteEmployee能运行成功
                People p1 = new Employee();
                PromoteEmployee(p1);
    
                // Manager"属于"(IS-A)Employee对象
                // PromoteEmployee能运行成功
                Manager m = new Manager();
                PromoteEmployee(m);
    
                // DateTime不是从Employee派生的
                // PromoteEmployee不能运行成功
                DateTime newYears = new DateTime(2011, 10, 1);
                PromoteEmployee(newYears);
            }
    
            static void PromoteEmployee(Object o)
            {
                // 编译器在编译时无法准确地获知对象0引用的是什么类型,因此允许代码通过编译
                // 但在运行时,CLR知道了o引用的是什么类型(在每次执行转型的时候)
                // 所以它会核实对象的类型是不是Employee或者从Employee派生的任何类型
                Employee e = (Employee)o;
            }
        }

    使用C#的is和as操作符来转型
    在C#语言中进行转换的另一种方式是使用is操作符。is检查对象是否兼容于指定类型,返回Boolean值true或false。注意,is操作符永远不抛出异常,例如以下代码:

            static void Main(string[] args)
            {
                Object o = new Object();
                Boolean b1 = (o is Object);    //True
                Boolean b2 = (o is Employee);  //False
                Boolean b3 = (o is Nullable);  //False
            }

    is操作符通常像下面这样使用:

            static void Main(string[] args)
            {
                Object o = new Employee();
                if( o is Employee )
                {
                    Employee e = (Employee)o;
                }
            }

    在上诉代码中,CLR实际检查两次对象类型。is操作符首先核实o是否兼容于Employee类型。如果是,在if语句内部转型时,CLR再次核实o是否引用一个Employee。CLR的类型检查增强了安全性,但无疑会对性能造成一定的影响。这是因为CLR首先必须判断变量(o)引用的对象的实际类型。然后CLR必须遍历继承层次结构,用每个基类型去核对指定的类型(Employee)。由于这是一个相当常用的编程模式,所以C#专门提供了as操作符,目的就是简化这种代码的写法,同时提升其性能。

            static void Main(string[] args)
            {
                Object o = new Employee();
                Employee e = o as Employee;
                if(e != null)
                {
    
                }
            }

    在这段代码中,CLR核实o是否兼容于Employee类型;如果是,as放回对同一个对象的非null引用。如果o不兼容于Employee类型,as返回null。as操作符永远不抛出异常。注意,as操作符造成CLR只校验一次对象类型。if语句只检查e是否为NULL;这个检查的速度不校验对象的类型快得多。

    测试代码:

    namespace ConsoleApplicationTest
    {
        internal class B{}
    
        internal class D : B{}
    
        class Program
        {
            static void Main(string[] args)
            {
                Object o1 = new Object(); //OK
                Object o2 = new B(); //OK
                Object o3 = new D(); //OK
                Object o4 = o3; //OK
                B b1 = new B(); //OK
                B b2 = new D(); //OK
                D d1 = new D(); //OK
    
                B b3 = new Object(); //编译时错误,正确:Object b3 = new B();
                D d2 = new Object(); //编译时错误,正确:Object b3 = new D();
    
                B b4 = d1; //OK,子类可以自动转父类
                D d3 = b2; //编译时错误,正确:D d3 = (D)b2;
                D d4 = (D)d1; //OK
                D d5 = (D)b2; //OK
    
                D d6 = (D)b1; //运行时错误,创建实例的时候没有将父类引用到子类对象
                B b5 = (B)o1; //运行时错误,创建实例的时候没有将父类引用到子类对象
                B b6 = (D)b2; //OK,创建实例的时候将父类引用到子类对象
            }
        }
    }
    展开全文
  • Java语言允许某个类型的引用变量引用子类的实例,而且...例如,Creature 类表示生物类,Animal 类表示动物类,该类对应的子类有 Dog 类,使用对象类型表示如下: Animal animal=new Dog(); Dogdog=(Dog)animal; ...

    Java 语言允许某个类型的引用变量引用子类的实例,而且可以对这个引用变量进行类型转换。如果把引用类型转换为子类类型,则称为向下转型;如果把引用类型转换为父类类型,则称为向上转型。
    例如,Creature 类表示生物类,Animal 类表示动物类,该类对应的子类有 Dog 类,使用对象类型表示如下:

    Animal animal=new Dog();
    Dogdog=(Dog)animal;    //向下转型,把Animal类型转换为Dog类型
    Creature creature=animal;    //向上转型,把Animal类型转换为Creature类型

    例 1

    下面通过具体的示例演示对象类型的转换。例如,父类 Animal 和子类 Cat 中都定义了实例变量 name、静态变量 staticName、实例方法 eat() 和静态方法 staticEat()。此外,子类 Cat 中还定义了实例变量 str 和实例方法 dogMethod()。
    父类 Animal 的代码如下:

    public class Animal
    {
        public String name="Animal:动物";
        public static String staticName="Animal:可爱的动物";
        public void eat()
        {
            System.out.println("Animal:吃饭");
        }
        public static void staticEat()
        {
            System.out.println("Animal:动物在吃饭");
        }
    }


    子类 Cat 的代码如下:

    public class Cat extends Animal
    {
        public String name="Cat:猫";
        public String str="Cat:可爱的小猫";
        public static String staticName="Dog:我是喵星人";
        public void eat()
        {
            System.out.println("Cat:吃饭");
        }
        public static void staticEat()
        {
            System.out.println("Cat:猫在吃饭");
        }
        public void eatMethod()
        {
            System.out.println("Cat:猫喜欢吃鱼");
        }
        public static void main(String[] args)
        {
            Animal animal=new Cat();
            Cat cat=(Cat)animal;    //向下转型
            System.out.println(animal.name);    //输出Animal类的name变量
            System.out.println(animal.staticName);    // 输出Animal类的staticName变量
            animal.eat();    //输出Cat类的eat()方法
            animal.staticEat();    //输出Animal类的staticEat()方法
            System.out.println(cat.str);    //调用Cat类的str变量
            cat.eatMethod();    //调用Cat类的eatMethod()方法
        }
    }

    通过引用类型变量来访问所引用对象的属性和方法时,Java 虚拟机将采用以下绑定规则:

    • 实例方法与引用变量实际引用的对象的方法进行绑定,这种绑定属于动态绑定,因为是在运行时由 Java 虚拟机动态决定的。例如,animal.eat() 是将 eat() 方法与 Cat 类绑定。
    • 静态方法与引用变量所声明的类型的方法绑定,这种绑定属于静态绑定,因为是在编译阶段已经做了绑定。例如,animal.staticEat() 是将 staticEat() 方法与 Animal 类进行绑定。
    • 成员变量(包括静态变量和实例变量)与引用变量所声明的类型的成员变量绑定,这种绑定属于静态绑定,因为在编译阶段已经做了绑定。例如, animal.name 和 animal.staticName 都是与 Animal 类进行绑定。

    对于 Cat 类,运行时将会输出如下结果:

    Animal:动物
    Animal:可爱的动物
    Cat:吃饭
    Animal:动物在吃饭
    Cat:可爱的小猫
    Cat:猫喜欢吃鱼

    强制对象类型转换

    Java 编译器允许在具有直接或间接继承关系的类之间进行类型转换。对于向下转型,必须进行强制类型转换;对于向上转型,不必使用强制类型转换。

    • 例如,对于一个引用类型的变量,Java 编译器按照它声明的类型来处理。如果使用 animal 调用 str 和 eatMethod() 方法将会出错,如下:

    animal.str=""; //编译出错,提示Animal类中没有str属性

    animal.eatMethod(); //编译出错,提示Animal类中没有eatMethod()方法

     

    • 如果要访问 Cat 类的成员,必须通过强制类型转换,如下:

    ((Cat)animal).str=""; //编译成功

    ((Cat)animal).eatMethod(); //编译成功

     

    • 把 Animal 对象类型强制转换为 Cat 对象类型,这时上面两句编译成功。对于如下语句,由于使用了强制类型转换,所以也会编译成功,例如:

    Cat cat=(Cat)animal; //编译成功,将Animal对象类型强制转换为Cat对象类型

     

    • 子类的对象可以转换成父类类型,而父类的对象实际上无法转换为子类类型。因为通俗地讲,父类拥有的成员子类肯定也有,而子类拥有的成员,父类不一定有。因此,对于向上转型,不必使用强制类型转换。例如:

    Cat cat=new Cat();

    Animal animal=cat; //向上转型,不必使用强制类型转换

     

    • 如果两种类型之间没有继承关系,那么将不允许进行类型转换。例如:

    Dog dog=new Dog();

    Cat cat=(Cat)dog; //编译出错,不允许把Dog对象类型转换为Cat对象类型

     

    展开全文
  • 关于对象类型转换为数组类型的问题。下面的代码一致想不通。 /** 2016年10月7日11:12:20 对象类型转化成数组类型 匪夷所思 **/ class A{ private $A = 'a'; } class B extends A{ private $A = 'b'; ...

    关于对象类型转换为数组类型的问题。下面的代码一致想不通。


    <?php 
    /**
    2016年10月7日11:12:20
    对象类型转化成数组类型
    匪夷所思
    **/
    
    class A{
    	private $A = 'a';
    }
    
    
    class B extends A{
    	private $A = 'b';
    	public $AA = 'c';
    }
    
    
    $b = new B();
    print_r((array)$b);
    /*
    	Array
    	(
    	    [BA] => b
    	    [AA] => c
    	    [AA] => a
    	)
    */


    展开全文
  •  简单理一下上面的类型转换过程:在第二个callA()方法时,传递给该方法的是一个B类型的对象。由于callA函数所接收的是一个A类型的对象,所以这里进行了一次类型转化(子类型对象转换为父类型对象)。接下来到了if...
  • 然后调用func1()方法 ,这时调用的是传过来的地址所指向内存空间中的func1()方法,而传过来的虽然是A类型的引用,但是该引用指向的内容中存储的是B类型对象,所以最终调用 的是B类型的func1()方法。...
  • C#把对象类型转化为指定类型,C#通用类型扩展方法类
  • c++中什么是对象类型转换?什么是向上转换和向下转换?具体应该要怎么做,可以举个与多态结合的例子吗?
  • C++里,对象类型转化问题是需要严加注意的一个问题,包括隐式转换,强制转化,旧式转化等种类,需要加以总结。本篇文章概括总结类型转化问题,并侧重于类型的隐式转换问题。关于强制转换的详细的内容放在下篇文章中...
  • Swift 对象类型转换

    千次阅读 2015-08-28 15:13:57
    Swift 中对象是可以转换的,应为面向对象就会涉及继承,子类,父类等等 有几点规则我们先说一下 子类对象可以直接转换为父类对象的 父类对象可以有条件的转换为子类对象,这个我们下边在讲 首先我们创建三个类 人 ...
  • * 而一个父类对象类型一般是不能转换为子类对象使用的。因为子类继承与父类,所以说子类中的 * 一些数据成员和方法父类中未必会有,但如果是一个父类对象引用实际引用的是一个子类对象, * 则可以强制将这个父类...
  • java:对象类型转换

    2020-02-22 11:47:34
    if(p instanceof Student){//判断p对象是不是属于Student,如果是强制类型转换成student类型 Student s=(Student) p; s.getSchool(); }else{ p.test(); } } public static void main(String[] args) { ...
  • OTT是OCI中访问对象类型数据的一个非常重要的工具,它将数据库中的对象类型或几何对象映射为C语言中的结构体,供OCI程序使用。在所有的支持oracle的操作系统中,OTT工具是以命令行方式工作的。要使用它,我们必须先...
  • java继承 对象类型转换 实例代码java继承 对象类型转换 实例代码java继承 对象类型转换 实例代码
  • 主要介绍了C++ 中类对象类型转化的实例详解的相关资料,这里提供实例帮助大家学习理解这部分内容,需要的朋友可以参考下
  • 对象的强制类型转换

    千次阅读 2018-07-21 13:35:13
    我们以前说过,将一个类型强制转换成另外一个类型的过程被称为类型转换。Java程序设计语言提供了一种专门用于进行类型转换的表示法。例如: double X = 3.405; int nx = (int) x; 将表达式x的值转换成整数类型,...
  • 将字符串类型转换对象类型:JSON.parse(参数) 将对象数据类型转换为字符串数据类型:JSON.stringify(参数)
  • 类的对象类型转换 类似于基本数据类型之间的强制类型转换。  存在继承关系的父类对象和子类对象之间也可以  在一定条件之下相互转换。  这种转换需要遵守以下原则:  1.子类对象可以被视为是其父类的一...
  • Python对象比较和类型转换

    千次阅读 2018-06-03 00:21:30
    Python对象比较和类型转换1、Python核心数据类型数字:int, long, float, complex(复数), bool(布尔)字符:str, unicode列表:list字典:dict元组: tuple文件:file可变集合:set 不可变集合:frozenset其他类型:类...
  • localStorage对JSON对象类型需要转换

    千次阅读 2017-05-20 15:19:52
    localStorage对JSON对象类型需要转换  localStorage.setItem()正确存储JSON对象方法是:存储前先用JSON.string
  • java中对象类型转换

    2017-05-03 09:01:40
    java中对象类型转换 1.向上类型转换  在java中对象的向上类型转换是安全的。  具体解释请参考以下代码及其注释: public class ExampleTest { public static void main(String[] args) { Animal animal=new ...
  • C# 对象类型转化

    2015-11-23 15:01:23
    可以检查对象是否与特定的类型兼容,可以用它来判断对象是否为给定的类型。 定义格式为 operand is type 在上述定义中,当type是一个类,而operand也是该类型,或继承了该类型,或封箱到该类型中时,结果为true;  ...
  • 当某个运算符的运算对象类型不一致,且其中某一个运算对象是无符号类型时,这个需要进行相应地类型转换,至于类型转换的结果,则 依赖于机器中各个整数类型的相对大小 。 当某个运算符的运算对象类型不一致,且...
  • java 对象的强制类型转换

    千次阅读 2019-04-21 11:34:00
    在java中强制类型转换分为基本数据类型和引用数据类型两种,这里我们讨论的后者,也就是引用数据类型的强制类型转换。 在Java中由于继承和向上转型,子类可以非常自然地转换成父类,但是父类转换成子类则需要强制...
  • 通过com.fastxml.jackson的ObjectMapper对象进行转换: ObjectMapper objectMapper = new ObjectMapper(); objectMapper.convertValue(Object fromValue, Class<T> toValueType);
  • RTTI(Run-Time Type Identification) 运行时类型识别,最先出现在C++里,引入这个机制是为了让程序在运行时能根据基类的指针或引用来获得该指针或引用所指的对象的实际类型。 Java中的RRTI则是源于《Thinking in ...
  • 对象类型只有一个,就是调用它的 getClass() 方法获得的类型;变量的类型在它定义的时候就决定了,而与它实际指向的对象类型无关。
  • link环境下,如何用发射实现对象到接口的类型转换?如何把对象发射转换成接口?

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,525,490
精华内容 610,196
关键字:

对象类型转换