Java 多态的基本操作

多态含义：
    .同一个对象在不同时刻表现出来的的不同形态
    .我自己的感觉是，把父类当作一个参考对象，通过在子类里面重写的方式，在其他类里面，实例化子类，然后调取父类的参考对象然后调取实例化的子类进行完成数据的调取；
    .上面的话简单点来说，就是我们在学继承的时候，通常就是在子类调取父类的值用，多态就是在方法重写的基础下，通过父类，来调取所有子类的重写的方法，
举例：猫
    .我们可以说是猫是猫，猫 cat = new 猫();
    .也可以说是猫是动物，动物 animal = new cat();
    .这里的猫在不同时候表现出来了不同状态，就是多态
多态的前提和体现
    .有继承和实现关系
    .有方法重写
    .有父类引用指向子类对象   
多态中成员的访问特点
    .成员变量：编译看左边，执行看左边 ->两者都存有共同名称的变量，就能访问得到，但是得到的是父类的成员变量
    .成员方法：编译看左边，执行看右边 ->两者都存有共同名称的变量，就能访问得到，但是得到的是子类的成员方法
为啥成员变量和成员方法的访问方式不一样？
    .因为成员方法有重写，而成员变量没有
多态的好处和弊端
  .多态的好处：提高了程序的扩展性
    .具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与此操作
  .多态的弊端：不能使用子类特有的功能
多态的转型 -> 多态的弊端：不能使用子类特有的功能->帮助我们使用子类的特有功能
  .向上转型
    .从子到父
    .父类引用子类对象
  .向下转型
    .从父到子
    .父类引用转为子类对象

---

以下为猫狗案例的多态版本  和   向下转型的案例

cat类 dog类 animal类 animaldemo类，详解还是需要看代码

需求：
    .请采用多态的思想实现猫和狗的案例，并在测试类中开始测试
思路：
  1.定义动物类（animal）
    .成员变量 姓名 年龄
    .构造方法 无参 带参
    .成员方法 get/set，吃饭()
  2.定义猫类（cat）继承动物类
    .构造方法 无参 带参
    .成员方法  重写吃饭()
  3.定义狗类（dog）继承动物类
    .构造方法 无参 带参
    .成员方法  重写吃饭()
  4.测试类
    .写代码测试 

 animaldemo类

package 多态案例_猫和狗;

public class animaldemo {
	/*
需求：
    .请采用多态的思想实现猫和狗的案例，并在测试类中开始测试
思路：
  1.定义动物类（animal）
    .成员变量 姓名 年龄
    .构造方法 无参 带参
    .成员方法 get/set，吃饭()
  2.定义猫类（cat）继承动物类
    .构造方法 无参 带参
    .成员方法  重写吃饭()
  3.定义狗类（dog）继承动物类
    .构造方法 无参 带参
    .成员方法  重写吃饭()
  4.测试类
    .写代码测试
    
	 */

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		//创建猫类对象的多态形式
		animal  a = new cat();      //无参猫
		a.setAge(5);
		a.setName("加菲");
		System.out.print(a.getAge()+"岁的猫 "+a.getName()+" 喜欢");
		a.eat();
		
		a = new cat("加洛特",15);     //有参猫
		System.out.print(a.getAge()+"岁的猫 "+a.getName()+" 喜欢");
		a.eat();
		
		
		//创建狗类对象的多态形式
		animal  b = new dog();       //无参狗
		b.setAge(7);
		b.setName("斯蒂芬");
		System.out.print(b.getAge()+"岁的狗 "+b.getName()+" 喜欢");
		b.eat();
		
		b = new dog("王大",8);     //有参狗
		System.out.print(b.getAge()+"岁的狗 "+b.getName()+" 喜欢");
		b.eat();
		

	}

}

animal类

package 多态案例_猫和狗;

public class animal {
	
	
	private String name;
	private int age;
	
//------成员变量------------------------------
	
	
	public void eat() {
		// TODO 自动生成的方法存根
		System.out.println("动物吃东西");

	}
	
	
//------成员方法------------------------------
	
	
	/**
	 * 
	 */
	public animal() {
		
	}
	/**
	 * @param name
	 * @param age
	 */
	public animal(String name, int age) {
		
		this.name = name;
		this.age = age;
	}
	
	
//------构造方法------------------------------
	
	
	/**
	 * @return name
	 */
	public String getName() {
		return name;
	}
	/**
	 * @param name 要设置的 name
	 */
	public void setName(String name) {
		this.name = name;
	}
	/**
	 * @return age
	 */
	public int getAge() {
		return age;
	}
	/**
	 * @param age 要设置的 age
	 */
	public void setAge(int age) {
		this.age = age;
	}
	

//------get/set------------------------------
	
	
	
	

}

dog类

package 多态案例_猫和狗;

public class dog extends animal {

	/**
	 * 
	 */
	public dog() {
		super();
		// TODO 自动生成的构造函数存根
	}

	/**
	 * @param name
	 * @param age
	 */
	public dog(String name, int age) {
		super(name, age);
		// TODO 自动生成的构造函数存根
	}
	
//------构造方法------------------------------
	
	@Override
	public void eat() {
		// TODO 自动生成的方法存根
		System.out.println("吃骨头");
	}
	
//------重写父类成员方法-----------------------
	

}

cat类

package 多态案例_猫和狗;

public class cat extends animal {

	/**
	 * 
	 */
	public cat() {
		super();
		// TODO 自动生成的构造函数存根
	}

	/**
	 * @param name
	 * @param age
	 */
	public cat(String name, int age) {
		super(name, age);
		// TODO 自动生成的构造函数存根
	}
	
//------构造方法------------------------------
	
	@Override
	public void eat() {
		// TODO 自动生成的方法存根
		System.out.println("吃鱼");
	}
	
//------重写父类成员方法-----------------------
	
	

}

多态的向下转型，为了解决子类中独有的方法无法访问的问题

分为三个类

cat类 animal类 animaldemo类

     多态的转型 -> 多态的弊端：不能使用子类特有的功能->帮助我们使用子类的特有功能
  .向上转型
    .从子到父
    .向上转型
  .向下转型
    .从父到子
    .父类引用转为子类对象

animaldemo类  

package 多态的转型;

public class animaldemo {
	/*
	 多态的转型 -> 多态的弊端：不能使用子类特有的功能->帮助我们使用子类的特有功能
  .向上转型
    .从子到父
    .向上转型
  .向下转型
    .从父到子
    .父类引用转为子类对象
	 */
	public static void main(String[] args) {
//		多态的方式创建对象
		animal a = new cat (); //向上转型  父类引用转为子类对象  把这个子类对象 给animal引用
		a.eat();
		
//		cat c = new cat ();
//		c.eat();
//		c.playGame();
		

		//向下转型 ,强制转换,想要访问子类中，独有的变量
		cat c = (cat)a;
		c.playGame();
		
		
		//这种方式也可以
		animal b =  a;   
		((cat) b).playGame();
		((cat) b).eat();
		
		
	
		
	}

}

cat类

package 多态的转型;

public class cat extends animal {
	@Override
	public void eat() {
		// TODO 自动生成的方法存根
		System.out.println("猫吃东西");
	}
	public void playGame() {
		System.out.println("猫捉迷藏");
	}

}

animal类

package 多态的转型;

public class animal {
	public void eat() {
		// TODO 自动生成的方法存根
		System.out.println("动物吃东西");

	}

}

---

 

总结：

在学会继承的基础上学多态没有什么问题，反而感觉还是很轻松，只是在内存图没有明白太多，不过我感觉都是小事情，非常稳妥。