Java_多态_基础学习

• JAVA_多态01_多态的定义及使用

类中的方法具有通用性，在Java中使用一个父类类型引用一个子类类型的对象，根据子类对象的特征不同，得到不同的运行结果(书中定义)，例如：Animal a = new Cat();

代码如下：

package JAVA_01_多态;
/*
 * 		父类
 * */
public class Animal {

	public void eat() {
		System.out.println("动物吃东西");
	}
}

package JAVA_01_多态;
/*
 *		子类 
 */
public class Cat extends Animal{

	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

package JAVA_01_多态;
/*
 * 		测试类
 * */
public class AnimalDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//父类引用指向子类对象
		Animal a = new Cat();
	}

}

• JAVA_多态02_多态中成员访问的特点

1. 成员变量访问的特点：
   编译和运行都要看父类，我的理解就是父类中有的成员变量才可以使用，父类中没有的不可以使用，否则会报错，父类中和子类中的成员变量执行时会按照父类的变量来执行
2. 成员方法的访问特点：
   编译看父类，运行看子类，我的理解就是编译时父类有才可以（父类没有这个方法时执行时会报错），但是如果子类重写了父类的方法，运行时执行的是子类重写以后的结果，如果子类不重写，运行时按照父类的方法执行

共同点：无论是成员变量或成员方法，访问的一定是父类有的，没有的一定会报错

代码：

package JAVA_02_多态中成员访问特点;
/*
 * 		父类
 * */
public class Animal {
	public int age = 40;
	
	public void eat() {
		System.out.println("动物吃东西");
	}
}

package JAVA_02_多态中成员访问特点;
/*
 * 		子类
 * */
public class Cat extends Animal{
	public int age = 20;
	public int weight = 10;
	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void playGame() {
		System.out.println("猫捉迷藏");
	}
}

package JAVA_02_多态中成员访问特点;

/*
 * 		多态中成员访问特点:
 * 			成员变量：编译看左边，执行看左边
 * 			成员方法：编译看左边，执行看右边
 * 
 * 		因为成员方法有重写，成员变量没有重写所以特点不一样
 * */

public class AnimalDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//父类引用指向子类对象
		Animal a = new Cat();
		
		System.out.println(a.age);//编译看左边的引用，运行也要看左边
//		System.out.println(a.weight);   报错
		
		
		a.eat();      //编译看左边的引用，运行要看右边(重写以后的内容，如果没重写，那就按左边的来)
//		a.playGame();   报错
	}

}

• JAVA_多态03_多态的好处和弊端
  多态的好处：提高了程序的扩展性，表现为使用父类作为参数，使用具体的子类参与操作
  多态的弊端：不能使用子类的特有功能

代码：

package JAVA_03_多态的好处和弊端;
/*
 * 		父类
 * */
public class Animal {
	public void eat() {
		System.out.println("动物吃东西");
	}
}

package JAVA_03_多态的好处和弊端;
/*
 * 		子类
 * */
public class Cat extends Animal{
	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
}

package JAVA_03_多态的好处和弊端;
/*
 * 		子类
 * */
public class Dog extends Animal{
	@Override
	public void eat() {
		System.out.println("狗吃骨头");
	}
}

package JAVA_03_多态的好处和弊端;
/*
 * 		操作类
 * */
public class AnimalOperator {
//	public void useAnimal(Cat c) {   //相当于是 Cat c = new Cat();
//		c.eat();
//	}
//	
//	public void useAnimal(Dog d) {   //相当于是Dog d = new Dog();
//		d.eat();
//	}
	
	public void useAnimal(Animal a) {
		
		//Animal a = new Cat();
		//Animal a = new Dog();
		
		a.eat();
	}
}

package JAVA_03_多态的好处和弊端;
/*
 * 		测试类
 * */
public class AnimalDemo {
	public static void main(String[] args) {
		//创建动物操作类对象，调用方法
		AnimalOperator ao = new AnimalOperator();
		Cat c = new Cat();
		ao.useAnimal(c);
		
		Dog d = new Dog();
		ao.useAnimal(d);
	}
}

• JAVA_多态04_猫吃狗多态版
  首先做一个Animal类，类中有有参无参构造方法，写一个eat()方法，还有getXxx()和setXxx()方法，代码如下：

package JAVA_05_猫和狗;

public class Animal {
	private String name;
	private int age;
	
	public Animal() {}
	
	public Animal(String name,int age) {
		this.name = name;
		this.age = age;
	}
	
	public void eat() {
		System.out.println("动物吃东西");
	}
	
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	public void setAge(int age) {
		this.age=age;
	}
	public int getAge() {
		return age;
	}
}

然后写一个Cat类，继承Animal类，然后重写eat()方法，再写有参和无参的构造方法。代码如下：

package JAVA_05_猫和狗;

public class Cat extends Animal{
	public Cat() {}
	
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public Cat(String name,int age) {
		super(name,age);
	}
}

再写一个测试类，用多态的方式：

package JAVA_05_猫和狗;

public class AnimalDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Animal a = new Cat();
		a.setName("小花");
		a.setAge(18);
		System.out.println(a.getName()+","+a.getAge());
		
		a = new Cat("xiaor",19);
		System.out.println(a.getName()+","+a.getAge());
	}

}