Java中的多态

Java中的多态主要包括：方法的多态和对象的多态

1.方法的多态

        Java中方法的多态，最主要的体现形式就是方法的重写与重载。

1.1 方法的重写

        方法的重写是指，在不同类中，书写除了方法体外，其他部分全保持一致的方法。当然方法重写的前提是存在继承关系。

class A{

        public void eat(){

                方法体1;

        }

}

class B extends A{

        public void eat(){

                方法体2;

        }

}

代码示例：

class Instrument {
	public void play() {
		System.out.println("弹奏乐器");
	}
}

class Wind extends Instrument {
	public void play() {
		System.out.println("弹奏Wind");
	}
}

1.2 方法的重载

        方法的重载与继承无关，方法的重载是指在同一个类里，方法名相同，返回值类型和修饰符可以不同（两个方法仅返回值、修饰符类型不同时，编译器会标红警告，不构成方法的重载），参数必须不同 (参数类型不同或者参数个数不同或者都不同) 的几个方法，最为熟悉的当属一个类的构造方法了。

//无参构造方法

class 类名(){

        方法体;

}

//有参构造方法

class 类名(参数){

        方法体;

}

 代码示例：

class Rat {
	String name;
	int age;
	String kind;

	public Rat() {

	}

    public Rat(String name){
        this.name=name;
    }
    
    public Rat(ing age){
        this.age=age;
    }
    
    public Rat(String name, String kind){
        this.name=name;
        this.kind=kind;
    }
	
    public Rat(String name, int age, String kind) {
		this.name = name;
		this.age = age;
		this.kind = kind;
	}
    
}

2.对象的多态

一个对象的编译类型（=左边）与运行类型（=右边）可以不同

编译类型定义对象时已经确定好，但运行类型可以改变

父类的引用指向子类对象

父类 父类引用 = new 子类();

Person person = new Child();

 2.1 多态的向上转型

        上述语法结构，又被称为多态的转型中的向上转型。

class Person {
	public void eat () {
		
	}
}
class Child extends Person {
	@Override
	public void eat() {
		System.out.println("吃");
	}
	public void sleep () {
		System.out.println("睡");
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Person person = new Child();//向上转型
        //可以调用子类重写的父类方法
		person.eat();
        //无法调用子类独有的方法
		//person.sleep();
	}

}

         这种格式实际上，是将子类对象赋值给了父类的引用，小范围的子类向大范围的父类转型，可以自动转型。

        同时使用这种方式的父类引用，可以调用子类中重写的父类方法，但无法使用子类自己独有的方法。

2.2 多态的向下转型

        多态向下转型的语法格式：

        父类 父类引用 = new 子类();

        子类 子类引用 =(子类类型) 父类引用;

        向下转型是大范围转小范围不能自行转型，需要强制类型转换。

        示例代码：

class Test {
	//Object 是所有类的父类
    //Object obj   相当于进行了一次向上转型  
    //Object obj=new Test();
	public void t (Object obj ) {
		String str = (String) obj; 
		System.out.println(str);
	}
}
public class Demo2 {
	public static void main(String[] args) {
		Test test = new Test();
		test.t("狗狗");
	}
}

         在示例代码中，Object类是所有类的父类，在使用子类引用test调用子类中的成员方法t的时候，因为方法t的参数类型要求是 Object，此时发生了一次向上转型，Object object = new Test();然后执行t方法中的第一条语句，String str =(String) obj; 一次向下转型就发生了，最后执行输出语句输出的 str 就是 string 类型的。

      instanceof

         用于比较操作

对象引用 instanceof 运行类型

        示例代码：

class A {}
class B extends A {}
public class Demo1 {
	public static void main(String[] args) {
		B b = new B();
		B b1 = new B();
		A a = new A();
		//instanceof  的左边放的对象的引用，右边是类
		System.out.println(b instanceof B);//true
		System.out.println(b1 instanceof B);//true
		//判断对象b是否是A的对象或者子类的对象
        //B类继承了A类，是A类的子类
		System.out.println(b instanceof A);//true
		System.out.println(a instanceof A);//true
		System.out.println(a instanceof B);//false
		
		A a2 = new B();
		System.out.println(a2 instanceof A);//true

        //a2本质是一个B类对象
		System.out.println(a2 instanceof B);//true
		
		Object object = new Object();
		System.out.println(object instanceof A);//false
		System.out.println(object instanceof Object);//true
		
		String string = "qwer";
		System.out.println(string instanceof Object);//true
	}
}

         对于结果进行观察，我们可以发现，只有对象引用的本质上的类是要比较的运行类型的类或子类时，结果才为true，否则为false，基于此，我们可以在向下转型时添加判定，给予足够的提示信息。