java多态性的理解

1.什么是多态？

        在面向对象语言中，父类/接口的多种不同实现方式即为多态。

2.多态的核心

         程序定义的引用变量具体指向的是哪个对象，具体调用的是哪个对象的方法，不是编译期间决定的，而是由运行期间决定的。因为在运行阶段才确定具体的类，这样就可以不用修改代码，就可以把引用变量绑定到具体的类的实现，该引用指向的对象的方法也随之改变，既不通过修改代码就可以实现动态的绑定具体的代码，让程序可以选择多个运行状态，这就是多态性。

3.多态存在的必要条件

         要有继承，子类继承父类；

         要有方法的重写，子类重写父类的方法；

          要有父类引用指向子类对象

看如下代码

        定义一个父类

public class Person {
	//属性
	private String name;
	private int age;
	private char gender;
	int i;
	//构造方法
	public Person(){}
	public Person(String name, int age, char gender){
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	//生成get/set方法
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
	public int getAge(){
		return age;
	}
	public void setAge(int age){
		this.age = age;
	}
	public char getGender(){
		return gender;
	}
	public void setGender(char gender){
		this.gender = gender;
	}
	public String toString(){
		return "name="+name+", age="+age+", gender="+gender;
	}
	//eat方法
	public void eat(){
		System.out.println("这是eat方法。。。");
	}
	//sleep方法
	 void sleep(){
		System.out.println("这是sleep方法。。。");
	}
}

    定义一个Student类，重写父类sleep()方法，有相同的变量i

public class Student extends Person{
	//属性
	private int score;
	int i = 10;
	//构造
	public Student(){}
	public Student(String name, int age, char gender, int score){
		super(name, age, gender);
		this.score = score;
	}
	//生成get/set方法
	public int getScore(){
		return score;
	}
	public void setScore(int score){
		this.score = score;
	}
	public String toString(){
		return "name="+getName()+", gender="+getGender()+", score="+score;
	}
//	@Override
//	public void eat() {
//		System.out.println("学生的eat方法。。。");
//	}
	@Override
	public void sleep() {
		System.out.println("学生的sleep方法。。。");
	}
	public void score(){
		System.out.println("学生的score方法。。。");
	}
}

定义一个Test类进行多态测试

public class Test {
	public static void main(String[] args) {
		//多态测试
		Person p = new Student("李四", 18, '男', 99);
		System.out.println(p.i);
		System.out.println(p.getName());
		p.eat();
		p.sleep();
		System.out.println(p);
	}
}

得到结果

0
李四
这是eat方法。。。
学生的sleep方法。。。
name=李四, gender=男, score=99

从上面的结果可以看出：父类有变量int i=10,子类有i=0，结果打印p.i=0，说明变量没有被继承和重写；方法被子类重写的可以是子类重写之后的结果。

总结：多态机制，只针对对象和方法，不针对属性---属性是没有多态性的；

          对于方法的多态，子类重写了父类的方法后，在通过对象的向上转型为父类实例化对象时，调用的方法应该是子类重写之后的方法；

           多态机制的前提：继承关系， 方法的重写，  父类的引用指向子类的对象；

            父类私有的方法，子类不能继承，既然不能继承，也就不能重写；

            对于方法的多态，子类没有重写，在通过对象的向上转型为父类实例化对象时，调用的是父类的方法；

            类型转换异常ClassCastException :直接进行对象的向下转换，没有进行对象的向上转换造成的；应该是先有对象的向上转型，然后才有对象的向下转型。