Java之理解多态详解

一、多态的概念

       继承关系使一个子类能继承父类的特征，并且附加一些新特征。子类是它的父类的特殊化，每个子类的实例都是其父类的实例，但是反过来不成立。例如：每个圆都是一个几何对象，但并非每个几何对象都是圆。因此，总可以将子类的实例传给需要父类型的参数。参考案例如下：

public class polymorphismdemo{
/** main method */
public static void main(string[] args){
  displayobject(new circle(1,"red",false));
  displayobject(new rectangle(1,1,"black",true));
}
 
public static void displayobject(geometriicobject object){
  system.out.println("created on "+ object.getdatecreated()+".color is"+object.getcolor());
}
}

created on mon mar 09 19:25:20 edt 2011.color is red

created on mon mar 09 19:25:20 edt 2011.color is black

       方法displayobject具有geometriicobject类型的参数。可以通过传递任何一个geometriicobject的实例来调用displayobject。使用父类对象的地方都可以使用子类的对象。这就是通常说的多态。简单来说，多态意味着父类型的变量可以引用子类型的对象。

二、多态的特点

 多态的前提：继承（即必须有子父类关系。）在使用多态后的父类引用变量调用方法时，会   调用子类重写后的方法。 定义格式：父类类型 变量名=new 子类类型();                                                                       父类引用指向子类对象,如：animal a = new cat(); 多态中，编译看左边，运行看右边

三、instanceof操作符

       instanceof是java的关键字。java关键字中的每个字母都是小写的。

       为了更好地理解类型转换，可以认为它们类似于动物、北极熊、熊猫之间的关系，其中动物类animal是北极熊类polar bear和熊猫类panda类的父类。北极熊是动物，所以，总是可以将 polar bear的实例安全地赋值给animal变量。该关键字用法是判断某个对象是否属于某种数据类型，返回值为布尔类型。

 
        fu zz=new xu();
        fu zzz=new yiting();
        if(f1 instanceof xu){
            system.out.println("zz是xu的类型");
        }
        else{
            system.out.println("zzz是yiting的类型");
        }

四、多态的转型

1、向上转型

       总是可以将一个子类的实例转换为一个父类的变量，称为向上转换，因为子类的实例总是它的父类的实例。

作用：

减少一些重复的代码对象实例化的时候可以根据不同需求实例化不同的对象

package project2;
	class animal{
		int num=100;
		void say(){
			system.out.println("it's an animal.");
		}
	}
 
	class cat extends animal{
		int num=50;
		void say(){
			system.out.println("it's a cat.");
		}	
		void bark(){
			system.out.println("喵喵喵!");
		}
	}
 
	public class project2{
		public static void main(string[] args) {
			animal cat=new cat();//向上转型	
			system.out.println(cat.num);
			cat.say();
//			cat.bark();
		}
	}

运行结果：

100
it's a cat.

向上转型不要强制转型，父类引用指向的或者调用的方法是子类的方法，这个叫动态绑定。向上转型后父类引用不能调用子类自己的方法。

2、向下转型

       把一个父类的实例转换为它的子类变量。必须使用转换标记（子类名）进行显示转换，向编译器表明你的意图。为使转换成功，必须确保要转换的对象是子类的一个实例。

作用：

        向上转型时 ，会遗失子类对象独有的其他方法；可以通过向下转型再重新转回。

package project2;
class animal{
	int num=100;
	void say(){
		system.out.println("it's an animal.");
	}
}
 
class cat extends animal{
	int num=50;
	void say(){
		system.out.println("it's a cat.");
	}	
	void bark(){
		system.out.println("喵喵喵!");
	}
}
 
public class project2{
	public static void main(string[] args) {
		animal cat=new cat();//向上转型
		cat cat2=(cat) cat;//向下转型
		system.out.println(cat2.num);
		cat2.say();
		cat2.bark();
	}
}

运行结果：

50
it's a cat.
喵喵喵!

五、方法重写

提示：要重写一个方法，需要在子类中使用和父类一样的签名来对该方法进行定义。

子类从父类中继承方法。有时，子类需要修改父类中定义的方法的实现，这称为方法重写。

以下几点值得注意：

重写的方法必须与被重写的方法具有一样的签名，以及一样或者兼容的返回类型。兼容的含义是重写方法的返回类型可以是被重写方法的返回类型的子类型。仅当实例方法可访问时，它才能被重写。如果子类中定义的方法在父类中是私有的，那么这两个方法完全没有关系。与实例方法一样，静态方法也能被继承。但是，静态方法不能被重写。如果父类定义的静态方法在子类中被重新定义，那么在父类中定义的静态方法将被隐藏。可以使用语法“父类名.静态方法名”调用隐藏的静态方法。防止继承和重写

       一个被final修饰的类和方法都不能被继承。被final修饰的数据域是一个常数。

       有时候，可能希望防止类被继承。在这种情况下，使用final修饰符表明一个类是最终类，是不能作为父类的。math类就是一个最终类。string、stringbuilder和stringbuffer类以及所有基本数据类型的包装类也都是最终类。例如，如下类a 就是最终类，不能被继承：

public final class a{
  //data fields,constructors, and methods omitted
}

       也可以定义一个方法为最终，最终方法不能被它的子类重写。例如如下，不能被重写：

public class test {
  //data fields,constructors, and methods omitted
 
  public final void m() {
    // do something
 }
}

注：修饰符public、protected、private、static、abstract以及final可以用在类和类的成员上，只有final修饰符还可以用在方法中的局部变量上。方法内的final局部变量就是常量。

六、小结

为了重写一个方法，必须使用与它的父类中的方法一样的签名、一样或者兼容的返回类型来定义子类中的方法。实例方法只有在可访问时才能重写。这样，私有方法是不能重写的，因为它是不能在类本身之外访问的。如果子类中定义的方法在父类中是私有的，那么这两个方法是完全没有关系的噢！静态方法与实例方法一样可以继承。但是，静态方法不能重写，如果父类中定义的静态方法在子类中重新定义，那么父类中定义的方法被隐藏。可以使用表达式obj instanceof aclass 测试一个对象是否是一个类的实例。可以使用final修饰符来表明一个类是最终类，是不能被继承的；也可以表明一个方法是最终的，是不能被重写的。

到此这篇关于java之理解多态详解的文章就介绍到这了,更多相关java多态内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！