多态的理解
什么是多态
定义：不同类的对象对同一个消息作出不同的响应。
解释：见如下代码
不同类的对象：子类cat和子类dog
同一个消息：调用eat()方法
不同的响应：分别为 cat eat 和 dog eat
//父类Animal
public class Animal { public void eat(){ System.out.println("animal eat"); } } //子类Cat public class Cat extends Animal{ @Override public void eat() { System.out.println("cat eat"); } } //子类Dog public class Dog extends Animal{ @Override public void eat() { System.out.println("dog eat"); } }
//测试
public class TestController {
public static void main(String[] args) {
Animal animal1 = new Cat();
Animal animal2 = new Dog();
animal1.eat();
animal2.eat();
}
}
结果：
cat eat
dog eat
由此引出多态存在的三个条件
多态存在的三个条件
1.有继承关系
Cat和Dog继承Animal
2.子类重写父类的方法
Cat和Dog重写父类Animal的eat方法
3.父类的引用变量指向子类对象
Animal animal1 = new Cat();
Animal animal2 = new Dog();
多态的作用
消除类型之间的耦合关系，即解耦。
举例：
你定义了一个接口，功能是存储文件。定义了一个下载工具类用来存储下载的文件。
//接口：存储文件 public interface SaveFile { void save(File file); } //下载工具类，有一方法为将下载的文件存储下来（调用上述接口） public class DownLoadTools { public static void downLoad(File file,SaveFile saveFile){ saveFile.save(file); } }
写了两个实现类，分别将文件存储在U盘和硬盘中。
//u盘存储
public class UDisk implements SaveFile{ @Override public void save(File file) { System.out.println("u盘存储"); } }
//硬盘存储 public class HardDisk implements SaveFile{ @Override public void save(File file) { System.out.println("硬盘存储"); } }
public static void main(String[] args) { File file = new File(""); SaveFile hardDisk = new HardDisk(); SaveFile uDisk = new UDisk(); DownLoadTools.downLoad(file,hardDisk); DownLoadTools.downLoad(file,uDisk); }
结果：
硬盘存储
u盘存储
此时如果需要将下载文件存储到CD中，只需要定义一个CDDisk实现类实现saveFile接口，无需更改downLoadTools下载工具类，这样downLoadTools类就不依赖于任何具体的类，这样就解除了与其他类之间的耦合性；
//CD存储 public class CdDISK implements SaveFile{ @Override public void save(File file) { System.out.println("cd存储"); } } //测试 public class Test { public static void main(String[] args) { File file = new File(""); SaveFile hardDisk = new HardDisk(); SaveFile uDisk = new UDisk(); SaveFile cdDisk = new CdDISK(); DownLoadTools.downLoad(file,hardDisk); DownLoadTools.downLoad(file,uDisk); DownLoadTools.downLoad(file,cdDisk); } }
结果：
硬盘存储
u盘存储
CD存储
补充说明1：只要一个方法操作的是类而非接口，那么你只能使用这个类及其子类。如果你想要将这个方法应用于不在此继承结构中的某个类，那么你就触霉头了。接口可以在很大程度上放宽这种限制（如上述的SaveFile接口），因此，他使我们可以编写可复用性更好的代码。——引用《thinking in java》的某一些话。
补充说明2：简单地说就是，没有多态，那么等号左边是啥右边就得是啥，这就叫耦合，有了多态，左边是父类（或者接口），右边是子类（或实现类），我只管调用父类（或者接口）里面的方法就是了，至于你子类（实现类）怎么去实现，那是你的事，你要修改一下实现，你只管去把子类（实现类）换掉，我这边一行代码都不用变，这就解耦了。
多态用在什么地方？
1.用在方法的参数中
情景：一个人养了一只宠物，现在调用person的keepPet(参数1)方法需要知道是什么宠物在吃饭
参数1给的是父类Animal的话，那么无论你后来需要养Lion,Tiger,Panda等等，都可以直接继承父类Animal，而Person的keepPet(参数1)方法不需要改变
若参数1给的是具体的Cat，Dog，Lion等等，那么你养了几只宠物，就需要写几个keepPet()方法，如keepPet(Cat cat)，keepPet(Dog dog)，keepPet(Lion lion)等。
public class Person {
//参数给的是父类Animal，那么调用的时候传参就可以是父类Animal的任意子类对象 public void keepPet(Animal animal){ animal.eat(); } } //父类Animal public class Animal { public void eat(){ System.out.println("animal eat"); } } //子类cat public class Cat extends Animal{ @Override public void eat() { System.out.println("cat eat"); } } //子类dog public class Dog extends Animal{ @Override public void eat() { System.out.println("dog eat"); } }
//测试
public class TestController {
public static void main(String[] args) {
Animal animal1 = new Cat();
Animal animal2 = new Dog();
Person person = new Person();
person.keepPet(animal1);
person.keepPet(animal2);
}
}
结果：
cat eat
dog eat
2.用在方法的返回类型中
前面的cat对象和dog对象都是直接new()的，现在设计一个工厂类，专门生产Animal
//以前
Animal animal1 = new Cat(); Animal animal2 = new Dog(); Person person = new Person(); person.keepPet(animal1); person.keepPet(animal2);
//现在
Animal animal1 = AnimalFactory.animalFactory("cat"); Animal animal2 = AnimalFactory.animalFactory("dog"); Person person = new Person(); person.keepPet(animal1); person.keepPet(animal2);
//工厂类方法，返回值类型是父类Animal,那么返回值就可以是Animal的所有的子类
public class AnimalFactory { public static Animal animalFactory(String animalName){ if(animalName.equals("cat")){ return new Cat(); }else if(animalName.equals("dog")){ return new Dog(); }else{ System.out.println("暂无该种动物"); return null; } } }
这实际上是设计模式中的工厂模式，当然如果类是一个完全独立的类，无相似的类，那么直接new()就行了。
