Java(多态练习 instanceof)

/*
 题目:
 (多态,instanceof)有如下代码
class Animal
{
 	private String name;
	// 1
}
class Dog extends Animal
{
	//2
}
class Cat extends Animal
{
	//3
}
public class TestAnimal
{
	public static void main(String args[]){
	Animal[] as = new Animal[]{
	new Dog("Pluto"),
	new Cat("Tom"),
	new Dog("Snoopy"),
	new Cat("Garfield")
};
	Dog[] dogs = getAllDog(as);
	for(int i = 0; i<=dogs.length; i++)
	{
		System.out.println(dogs[i].getName());
	}
}
public static Dog[] getAllDog(Animal[] as)
{
	//4
}
}
程序填空:
a) 在 //1, //2, //3 处填上适当的get/set 方法和构造方法
b) 完成//4 处的填空。getAllDog 方法从一个Animal 数组中挑选出所有的Dog 对象,并把这些对象放在一个Dog 数组中返回。

*/
package MyTest;

class Animal
{
	private String name;
	// 1
	public String getName()
	{
		return this.name;
	}
	public void setName(String name)
	{
		this.name = name;
	}
}

class Dog extends Animal
{
	// 2
	Dog(String name)
	{
		this.getName();
		this.setName(name);
	}
}

class Cat extends Animal
{
	// 3
	Cat(String name)
	{
		this.getName();
		this.setName(name);
	}
}

public class TestAnimal
{

	/*
	 * @param args
	 */
	public static void main(String[] args)
	{
		Animal[] as = new Animal[]
		{
				new Dog("Pluto"),
				new Cat("Tom"),
				new Dog("Snoopy"),
				new Cat("Garfield")
	    };
		Dog[] dogs = getAllDog(as);
		for (int i = 0; i < dogs.length; i++)
		{
			System.out.println(dogs[i].getName());
		}
	}

	public static Dog[] getAllDog(Animal[] as)
	{
		// 4
		Dog[] dog = new Dog[as.length];
		int len = as.length;
		int j = 0;
		for(int i = 0;i<len;i++)
		{
			if(as[i] instanceof Dog)
			{
				dog[j] = (Dog)as[i];
				j++;
			}
		}
		//////////////////
		Dog[] dg = new Dog[j];
		for(int i = 0;i<j;i++)
		{
			dg[i] = dog[i];
		}
		//////////////////
		return dg;

		/*
		 方法二:
		 public static Dog[] getAllDog(Animal[] as)
	     {
		  // 4
			List<Dog>dd = new ArrayList<Dog>();
			for(int i=0; i<as.length; i++)
			{
				//System.out.println(as[i].getClass().getName());

				if (as[i].getClass().getName().contains("Dog"))//( as[i] instanceof Dog )
				{
					dd.add((Dog)as[i]);
				}
			}
			int size = dd.size();
			Dog[] cc = (Dog[])dd.toArray(new Dog[size]);
			return cc;
		}
		*/
	}
}

  

时间: 2024-11-09 03:48:52

Java(多态练习 instanceof)的相关文章

java中的instanceof

instanceof是Java.php的一个二元操作符(运算符),和==,>,<是同一类东西.由于它是由字母组成的,所以也是Java的保留关键字.它的作用是判断其左边对象是否为其右边类的实例,返回boolean类型的数据.可以用来判断继承中的子类的实例是否为父类的实现.相当于c#中的is操作符.java中的instanceof运算符是用来在运行时指出对象是否是特定类的一个实例.instanceof通过返回一个布尔值来指出,这个对象是否是这个特定类或者是它的子类的一个实例. instanceof

Java多态对象的类型转换和动态绑定

Java多态对象的类型转换这里所说的对象类型转换,是指存在继承关系的对象,不是任意类型的对象.当对不存在继承关系的对象进行强制类型转换时,java 运行时将抛出 java.lang.ClassCastException 异常. 在继承链中,我们将子类向父类转换称为"向上转型",将父类向子类转换称为"向下转型". 很多时候,我们会将变量定义为父类的类型,却引用子类的对象,这个过程就是向上转型.程序运行时通过动态绑定来实现对子类方法的调用,也就是多态性. 然而有些时候为

Java多态之向下转型

目录 Java多态之向下转型 强制类型转换 instanceof Java多态之向下转型 往期回顾:我们学习了向上转型和动态绑定的概念,可以知道在继承关系中,将一个子类对象赋值给父类的引用变量,调用父类的方法,在实际运行时,就可以根据子类中重写的方法执行不同的操作.其中有一个弊端,就是在向上转型的过程中,其实丢失了一部分子类特有的功能,毕竟它只允许调用父类中的方法.那么,如何在这时调用子类中的方法呢,这时就需要与向上转型相对应的方法,就是所谓的:向下转型. 向上转型是自动就能完成的,向下转型则需

Java多态小总结

多态,又可以称为动态绑定,即在运行时确定类型,比如: 1 class A { 2 void draw(){ 3 //输出“A” 4 } 5 } 6 class B { 7 void draw(){ 8 //输出“B” 9 } 10 11 } 这种关系里,如果调用A a = new B(); 此时,被称为向上转型,a的类型可能在很早之前被生命,而在这时候被明确指明是其子类型, 我们如果要去调用draw()方法的时候,会调用输出“B”,这样,便是Java中的“多态”.我们称其为“向上转型”. 但是,

java 中的instanceof的用法

instanceof 运算符是Java.php的一个二元操作符(运算符),和==.>.<是同一类东西.由于它是由字母组成的,所以也是Java的保留关键字.它的作用是判断其左边对象是否为其右边类的实例,返回boolean类型的数据.可以用来判断继承中的子类的实例是否为父类的实现.相当于c#中的is操作符.java中的instanceof运算符是用来在运行时指出对象是否是特定类的一个实例.instanceof通过返回一个布尔值来指出.  用法:result = object instanceof

JAVA多态示例

这多态,我觉得是最利害的.在开发大型程序中. 但,也是需要经过足够多的实践经验才能随心利用的. class Quadrangle{ private Quadrangle[] qtest = new Quadrangle[6]; private int nextIndex = 0; public void draw(Quadrangle q){ if(nextIndex < qtest.length){ qtest[nextIndex] = q; System.out.println(nextIn

java多态讲解

JAVA多态 一.相关的类结构 class A ...{ //create by danielinbiti public String show(D obj)...{ return ("A and D"); } public String show(A obj)...{ return ("A and A"); } } class B extends A...{ public String show(B obj)...{ return ("B and B&q

Java多态特性:重载和覆写的比较

Java重载: 在同一个类中 方法具有相同的名字,相同或不同的返回值,但参数不同的多个方法(参数个数或参数类型) public class MethoDemo{ public static void main(String args[]){ int one = add(10,20) ; // 调用整型的加法操作 float two = add(10.3f,13.3f) ; // 调用浮点数的加法操作 int three = add(10,20,30) ; // 调用有三个参数的加法操作 Syst

Java多态-继承与清理

通过组合和继承方法来创建新类时,永远不必担心对象的清理问题,子对象通常会留给垃圾回收器进行处理.如果确是遇到清理问题,那必须用心为新的类创建dispose()方法(在这里我们选用此名).并且由于继承的缘故,如果我们有其他作为垃圾回收一部分的特殊清理动作,就必须在导出类中覆盖被继承的dispose()方法.当覆盖被继承的diopose()方法时,务必记住调用基类版本dispose()方法:否则,基类的清理动作就不会发生.下例便是一个证明: package polymorphism; class C