标签分类 技术文章:
当前位置:首页 > Java技术文章 > Java对象类型的判断详解

Java对象类型的判断知识点整理

  • 发布时间:
  • 作者:码农之家原创
  • 点击:211

这篇文章主要知识点是关于Java、对象类型、判断、java对象类型转换和多态性(实例讲解) 的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子书

Java JDK 8学习笔记
Java JDK 8学习笔记全书扫描版
  • 类型:Java大小:92.3 MB格式:PDF出版:清华大学出版社发行部作者:林信良
立即下载

更多Java相关的学习资源可以参阅 Java电子书程序设计电子书 等栏目。

Java对象类型的判断详解

instanceof

判断某个对象是否是某个类的实例或者某个类的子类的实例。它的判断方式大概是这样的:

public<T> boolean function(Object obj, Class<T> calzz) {
    if (obj == null) {
      return false;
    }
    try {
      T t = (T) obj;
      return true;
    } catch (ClassCastException e) {
      return false;
    }
  }

Class.equals()

这种方式比较的类型,一定是本身才返回true,子类或者父类都返回false;

 // B是A的子类,C是B的子类
    B b = new B();
    // false
    System.out.println(b.getClass().equals(A.class));
    // true
    System.out.println(b.getClass().equals(B.class));
    // false
    System.out.println(b.getClass().equals(C.class));

PS:b.getClass().equals(A.class)等同于b.getClass() == A.class

Class.isInstance()

这个方法跟instanceof完全等价。

 // B是A的子类,C是B的子类
    B b = new B();
    // true
    System.out.println(A.class.isInstance(b));
    // true
    System.out.println(B.class.isInstance(b));
    // false
    System.out.println(C.class.isInstance(b));

Class.isAssignableFrom

判断某个类是否是另一个类和其子类。

 // B是A的子类,C是B的子类
    // false
    System.out.println(B.class.isAssignableFrom(A.class));
    // true 
    System.out.println(B.class.isAssignableFrom(B.class));
    // true
    System.out.println(B.class.isAssignableFrom(C.class));

以上所述是小编给大家介绍的Java对象类型的判断详解整合,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对码农之家网站的支持!

java对象类型转换和多态性(实例讲解)

对象类型转换

分为向上转型和向下转型(强制对象转型)。 向上转型是子对象向父对象转型的过程,例如猫类转换为动物类;向下转型是强制转型实现的,是父对象强制转换为子对象。 这和基础数据类型的转换是类似的,byte在需要时会自动转换为int(向上转型),int可以强制转型为byte(向下转型)。

对于对象转型来说, 向上转型后子对象独有的成员将不可访问 。 意思是,在需要一只动物时,可以把猫当作一只动物传递,因为猫继承自动物,猫具有动物的所有属性。但向上转型后,猫不再是猫,而是被当作动物看待,它自己独有的属性和方法就不可见了。换句话说,向上转型后,只能识别父对象中的内容。

可以通过"引用变量 instanceof 类名"的方式来判断引用变量 所指向的对象 是否属于某个类,也就是说"对象是不是某类",例如声明一个猫类对象的引用"Cat c",然后"c instanceof Animal"表述的意思是"对象c是一种动物吗?"对于instanceof返回true的对象,都可以转换为类对象,只不过有些可能需要强制转换。

向上转型可以自动进行,这本就是符合逻辑的,狗类继承自动物类,它本身就是一只动物,因此在需要动物类的时候,丢一只狗过去就会自动向上转型成动物类。但这时狗已经不是狗,而是动物,所以狗独有的成员不再可见。

强制转换的方式和基础数据类型强制转换一样,都是在待转换对象前加上目标类型,例如将动物a强制转换为狗d: Dog d = (Dog)a 。

下面是一个对象类型转换的示例,很好地分析了能否转型、转型后能否访问某些成员等等。

class Animal {
 String name;
 Animal(String name) {this.name = name;}
}

class Cat extends Animal {
 String eyecolor;
 Cat(String name,String color) {super(name); this.eyecolor = color;}
}

class Dog extends Animal {
 String furcolor;
 Dog(String name,String color) {super(name); this.furcolor = color;}
}

public class OCast {
 public static void main(String [] args) {
 Animal a = new Animal("animal");
 Cat c = new Cat("cat","blue");
 Dog d = new Dog("dog","black");

 System.out.println( a instanceof Animal);//return true
 System.out.println( c instanceof Animal);//return true
 System.out.println( d instanceof Animal);//return true
 System.out.println( a instanceof Cat); //return false

 System.out.println(a.name); //return animal
 a = new Dog("yellowdog","yellow"); //object Dog upcast to Animal
 System.out.println(a.name);  //return yellowdog
 System.out.println(a instanceof Animal); //return true
 System.out.println(a instanceof Dog); //return true
 //System.out.println(a.furcolor); //error! because a was regarded as Animal
 Dog d1 = (Dog)a; // because "a instanceof Dog" is true,so force cast Animal a to Dog
 System.out.println(d1.furcolor);  //return yellow
 }
}

对于上面的 a = new Dog("yellowdog",yellow) ,a是Animal类型,但此时 它指向的是Dog对象。也就是说它是Dog,所以也是Animal类 ,所以 a instanceof Animal); 和 a instanceof Dog; 都是true,这是它的"指针"决定的。 但因为它的类型是Animal类型,类型决定了能存储什么样的数据,对于已经存在的但不符合类型的数据都是不可见的,所以Animal类型决定了它只能看到Dog对象中的Animal部分 。

如下图:

java对象类型转换和多态性(实例讲解)

既然可以向上转型,配合instanceof的逻辑判断,就能实现很好的扩展性。例如,动物类的sing(Animal a)方法需要的是一个动物类,可以给它一只狗d,这时会向上转型(就像需要double类型却给了一个int数据一样),虽然转型了,但狗d的实际引用仍然是Dog对象,于是 if (a instanceof Dog) 判断为真,则调用能体现狗sing()方法特殊性的语句。如果传递一只猫,if判断一下并调用能体现猫sing()方法特殊性的语句。这样,任何时候想添加一只动物,都只需要增加一条if语句就可以了。

见下面的示例:

class Animal {
 String name;
 Animal(String name) {
 this.name = name;
 }
}

class Cat extends Animal {Cat(String name) {super(name);}}
class Dog extends Animal {Dog(String name) {super(name);}}

public class TestCast {
 public static void main(String [] args) {
 TestCast t = new TestCast(); 
 Animal a = new Animal("animal");
 Animal c = new Cat("cat");
 Animal d = new Dog("dog");
 t.sing(a);t.sing(c);t.sing(d);
 }

 void sing(Animal a) {
 if ( a instanceof Cat) {
  Cat cat = (Cat)a;
  System.out.println("cat is singing");
 } else if(a instanceof Dog) {
  Dog dog = (Dog)a;
  System.out.println("dog is singing");
 } else {
  System.out.println("not an instance of animal");
 }
 }
}

如果没有对象转型,那么Dog里要定义一次sing(),Cat里也要定义一次sing()。要增加一个动物类,动物类里也还要定义一次sing()。现在就方便多了,直接在sing()方法内部修改if语句就可以了。

注意,上面的sing()方法不属于Animal或其他子类的方法,而是独立定义在其他类里进行调用的。

多态

向上转型虽然在一定程度上提高了可扩展性,但提高的程度并不太高。以向上转型为基础,java的多态实现的扩展性更好更方便。

多态也叫动态绑定或后期绑定,它是执行期间进行的绑定,而非编译期间的绑定(这是静态绑定或称为前期绑定)。

多态的原理是:当向上转型后,调用一个被重写的方法时,本该调用的是父类方法,但实际上却会动态地调用子类重写后的方法。实际上,编译期间绑定的确实是父类方法,只不过在执行期间动态转调子类对应方法。

例如,Animal类的sing()方法,Cat和Dog类都重写了sing()方法。当需要一个Animal对象时,传递了一个Cat类,那么将调用Cat的sing()方法。动态绑定的逻辑正如下面的代码类似:

void sing(Animal a) {
 if ( a instanceof Cat) {
 Cat cat = (Cat)a;
 System.out.println("cat is singing");
 } else if(a instanceof Dog) {
 Dog dog = (Dog)a;
 System.out.println("dog is singing");
 } else {
 System.out.println("not an instance of animal");
 }
}

以下是一个多态的例子

class Animal {
 private String name;
 Animal(String name) {this.name = name;}

 public void sing(){System.out.println("animal sing...");}
}

class Cat extends Animal {
 private String eyeColor;
 Cat(String n,String c) {super(n); eyeColor = c;}

 public void sing() {System.out.println("cat sing...");}
}

class Dog extends Animal {
 private String furColor;
 Dog(String n,String c) {super(n); furColor = c;}

 public void sing() {System.out.println("dog sing...");}
}

class Lady {
 private String name;
 private Animal pet;
 Lady(String name,Animal pet) {this.name = name; this.pet = pet;}
 public void myPetSing(){pet.sing();}
}

public class DuoTai {
 public static void main(String args[]){
 Cat c = new Cat("catname","blue");
 Dog d = new Dog("dogname","black");
 Lady l1 = new Lady("l1",c);
 Lady l2 = new Lady("l2",d);
 l1.myPetSing();
 l2.myPetSing();
 }
}

编译后的执行结果为:

cat sing...
dog sing...

在上面的示例中,Lady类的构造方法和她调用sing()方法的代码为:

Lady(String name,Animal pet) {this.name = name; this.pet = pet;}
public void myPetSing(){pet.sing();}

如果构造出Lady对象的pet是Cat对象c,这个c首先会向上转型为Animal类,也就是说Lady的pet属性虽然指向的是"Cat c"对象,但它只能看见其中的父对象Animal部分。那么 myPetSing(pet.sing();) 方法自然会调用Animal类的sing()方法。 以上过程是编译器所认为的过程,也是静态绑定或前期绑定的过程。

但编译完成后,虽然pet属性只能看见Animal部分,但实际在执行时pet.sing()却换转换为执行c.sing()。就相当于做了一次对象类型强制转换 Cat petx = (Cat)pet 。 这是动态绑定或后期绑定的过程,也称为多态。

实际上,对象在被new出来后,它所涉及到的方法都放在code segment内存区中的一个方法列表中,这个列表中包含了子类、父类的方法,只不过有些时候不可见的方法无法去调用。当执行程序时,内部的机制可以从方法列表中搜索出最符合环境的方法并执行它。

实现多态的技术的关键点在于:

(1). 定义一个父类引用f,并将其指向子类对象,即进行向上转型 ;

(2). 重写父类的方法,并使用父类引用f去引用这个方法。这样就可以面向父类进行编程 。

正如上面的示例中,将pet定义为Animal类而非具体的子类,并在方法中调用pet.sing()。如此依赖,就无需考虑pet到底是Cat/Dog,在进行功能扩展添加Bird类时,完全不用再修改Lady类的这段代码。

再例如,父类Animal,子类Dog,方法sing()。

class Animal {public void sing(A);}
class Dog extends Animal {public void sing(B);}

public class Test {
 Animal a = new Dog(); //父类引用变量a指向子对象Dog,此时将向上转型
 a.sing();  //使用父类引用变量a引用被重写的方法sing(),执行时将动态绑定到Dog的sing()
}

以上这篇java对象类型转换和多态性(实例讲解)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持码农之家。

以上就是本次给大家分享的关于Java的全部知识点内容总结,大家还可以在下方相关文章里找到java中jvm虚拟机栈的作用总、 java实现的密码强度检测功、 java实现杨辉三角两种输出、 等java文章进一步学习,感谢大家的阅读和支持。

上一篇:Java锁粗化与循环问题详解

下一篇:Java SDK实现离线签名代码详解

展开 +

收起 -

学习笔记
网友NO.849459

javascript self对象使用详解

Javascript self对象指窗口本身,它返回的对象跟window对象是一模一样的,也正因为如此,window对象的常用方法和函数都可以用self代替window,本文章向大家介绍self对象的使用方法和实例, 我们知道,打开任何一个网页,浏览器会首先创建一个窗口,这个窗口就是一个window对象,也是js运行所依附的全局环境对象和全局作用域对象。self 指窗口本身,它返回的对象跟window对象是一模一样的。也正因为如此,window对象的常用方法和函数都可以用self代替window。举个例子,常见的写法如“self.close();”,把它放在a标记中:“a href="javascript:self.close();"关闭窗口/a”,单击“关闭窗口”链接,当前页面关闭。 javascript self对象使用实例: htmlheadscript language="JavaScript" type = "text/javascript"!--if (top==self){ var main_frame = "http://www.manongjc.com"; var cur_url = self.location.href; var setframes = main_frame + "?" + cur_url; location.href = setframes;}//--/script/headbody/body/html 感谢阅读,希望能帮助到大家,谢谢大家对本站的支持! ……

网友NO.679968

JavaScript类数组对象转换为数组对象的方法实例分析

本文实例分析了JavaScript类数组对象转换为数组对象的方法。分享给大家供大家参考,具体如下: 1、类数组对象: 拥有 length 属性,可以通过下标访问; 不具有数组所具有的方法。 2、为什么要将类数组对象转换为数组对象? 数组对象Array有很多方法: shift 、 unshift 、 splice 、 slice 、 concat 、 reverse 、 sort ,ES6又新增了一些方法: forEach 、 isArray 、 indexOf 、 lastIndexOf 、 every 、 some 、 map 、 filter 、 reduce 等。由于类数组不具有数组所具有的操作数组的方法,将类数组转换为数组之后就能调用这些强大的方法,方便快捷。更多JavaScript数组的方法请见:https://www.jb51.net/article/144359.htm 3、类数组对象转换为数组对象的方法: 1) Array.prototype.slice.call(arrayLike) 或 Array.prototype.slice.call(arrayLike, 0) 或 [].slice.call (arrayLike) 或 [].slice.call (arrayLike, 0) var div1 = Array.prototype.slice.call(document.querySelectorAll('div'), 0);var div2 = Array.prototype.slice.call(document.querySelectorAll('div'));var div3 = [].prototype.slice.call(document.querySelectorAll('div'), 0);var div4 = [].prototype.slice.call(document.querySelectorAll('div')); 2) Array.from(arrayLike) var divs = Array.from(document.querySelectorAll('div')); 3) 原生JavaScript转换 var length = arrayLike.length;var arr = [];for (var i = 0; i length; i++) { arr.push(arrayLike[i]); return arr;} 4、JavaScript如何……

网友NO.758410

java 中Spark中将对象序列化存储到hdfs

java 中Spark中将对象序列化存储到hdfs 摘要: Spark应用中经常会遇到这样一个需求: 需要将JAVA对象序列化并存储到HDFS, 尤其是利用MLlib计算出来的一些模型, 存储到hdfs以便模型可以反复利用. 下面的例子演示了Spark环境下从Hbase读取数据, 生成一个word2vec模型, 存储到hdfs. 废话不多说, 直接贴代码了. spark1.4 + hbase0.98 import org.apache.spark.storage.StorageLevelimport scala.collection.JavaConverters._import java.io.Fileimport java.io.FileInputStreamimport java.io.FileOutputStreamimport java.io.ObjectInputStreamimport java.io.ObjectOutputStreamimport java.net.URIimport java.util.Dateimport org.ansj.library.UserDefineLibraryimport org.ansj.splitWord.analysis.NlpAnalysisimport org.ansj.splitWord.analysis.ToAnalysisimport org.apache.hadoop.fs.FSDataInputStreamimport org.apache.hadoop.fs.FSDataOutputStreamimport org.apache.hadoop.fs.FileSystemimport org.apache.hadoop.fs.FileUtilimport org.apache.hadoop.fs.Pathimport org.apache.hadoop.hbase.client._import org.apache.hadoop.hbase.{HBaseConfiguration, HTableDescriptor, TableName}import org.apache.hadoop.hbase.filter.FilterListimport org.apache.hadoop.hbase.filter.PageFilterimport org.apache.hadoop.hbase.filter.RegexStringComparatorimport org.apache.hadoop.hbase.filter.SingleColumnValueFilterimport org.apache.hadoop.hbase.filter.CompareFilter.CompareOpimport org.apache.hadoop.hbase.mapreduce.TableInputFormatimport org.apache.hadoop.hbase.protobuf.Pro……

<
1
>

Copyright 2018-2019 xz577.com 码农之家

版权责任说明