对多态的理解


先引用某位博主的原话，再对以下话的理解：原文链接

看Java核心技术这本书时，多态的内容讲解的很少，只是举个例子告诉我们怎样使用多态，而没有明确说明为什么使用多态的问题。

谈到面向对象的编程语言时不可避免的就会介绍继承，子类可以继承父类除private外的成员变量和方法，并且可以添加自己的成员变量与方法，以实现自己独特的功能。
但是如果在实际的开发中发现某个类的方法可以做出某些改进，但由于工程已经交付给用户使用，就不想增加不必要的麻烦！但以后再次创建该类的对象时就需要改进过来。
同时又不影响程序其他部分对该方法的调用。也就是说，如果再次创建该类的对象是不能做出改进的，应该由该类产生一个子类，并且子类将重写需要改进的方法，由于程
序中其他地方需要调用该方法，所以对象的类型如果被创建成子类的类型的话将不能被有效调用，这就需要用到向上转换了即创建一个子类对象但是将其类型转换为父类的
类型。这样做之后，程序的其他地方调用它时就能正确调用了，而且相应的方法也得到了改进。
由上可知：多态的存在有3个条件，1)要有继承 2)要有重写3)父类引用指向子类对象
个人理解：

打个比方有一个类A，在类B中得到引用，在类C中也得到引用
class A {
	public void go(){
		System.out.println("我要打篮球")
	}
}
class B {
	public  void UseA(A a){
		a.go()
	}
}
class C {
	public void UseA(A a){
		a.go()
	}
}

现在我想改一下A类中的go方法，但是根据七大设计原则，直接对A修改会违反开闭原则，所以我们最好写一个子类去继承A
class AChild extends A {
	@override
	public void go(){
		System.out.println("我要打乒乓球")
	}
} 

假如没有多态，那我们想用A的子类AChild，那就必须在B和C中把引用类型修改成AChild，也就是说要把B、C类里面的UseA类修改，那就违背了开闭原则。所以有了多态以后，我们只要创建一个需要修改的类的子类，以其父类作为引用类型，子类作为引用对象，就可以在修改想要修改的方法的同时又不影响其他类对该类的引用。
不知道我这样理解对不对，还请大佬们指出。

  
序言    ‘ 其实和抽象类的概念配合使用 ’




1.增加了程序的灵活性

以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)

2.增加了程序额可扩展性

通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用 　



多态例子（简易版）

peo = People()
dog = Dog()
pig = Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()


'''
这样我们新



多态例子（联动）

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class Dog(Animal): #动物的形态之:狗
    def talk(self):
        print('say wangwang')

class Cat(Animal): #属于动物的另外一种形态：猫
    def talk(self):
       print('say miao')

def func(animal): #对于使用者来说，自己的代码根本无需改动
    animal.talk()

cat1=Cat() #实例出一只猫
func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
# say miao

'''
这样我们新增了一个形态Cat，由Cat类产生的实例cat1
使用者可以在完全不需要修改自己代码的情况下。
使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
'''

概念：

声明父类变量来引用子类对象，或者声明接口变量来引用实现类对象

使用多态前提：

必须有继承或者实现条件下才能使用多态

 

语法规则：

父类的引用（变量）可以指向子类的对象

可以将子类的对象赋值给父类类型的变量

多态优点：

多态作用在形参上，可以接受更多的数据类型
	
多态作用在返回值类型上，可以返回更多的数据类型
多态特点：

多态情况下，子类和父类存在同名的成员属（静态和非静态）性时，访问的是父类的成员属性
	
多态情况下，子类和父类存在同名的非静态成员函数时，访问的是子类的非静态函数
	
多态情况下，子类和父类存在同名的静态成员函数时，访问的是父类的静态函数
	
多态情况下，接口和实现类中存在函数，调用时访问的是实现类的函数
多态的调用：

1、向上转型

Teacher teacher=new  Teacher();

//new 出来的称为对象的类型

//声明出来的 称之引用的类型

一般的情况： 对象类型和引用的类型是同一种数据类型

向上转型是指: 子类对象  赋予 父类的引用,向上转型是非常的安全

Person person=new Teacher();

2.向下转型

向下转型： 把父类引用 赋予子类引用

    Student student=new Person();//绝对错误

这是错误是Type mismatch: cannot convert from Person to Student 类型不匹配：无法从个人转换为学生

    Student student2= (Student) person ;

        student2.home();//绝对错误

这是错误是Teacher cannot be cast to duotai.Student    老师不能投给多台，学生

Person person1=new Student();

Student student1= (Student) person1 ;////向下转型不安全，能否转型成功取决于父类引用中保存的是哪个子类对象
student1.home();

必须判断父类引用中到底保存的是哪个类型的对象才可以向下转型，否则报错

instanceof

nstanceof 如果是，返回 ture 否则是false

写法格式：

Person person2 =new Teacher();
	
        if(person2 instanceof Teacher ){
	
            Teacher teacher1 = (Teacher)person2;
	
            teacher1.home();
	
            
	
        } 
代码如下：

public class Person {
	public String name;
	public String job;
	public int age;
	public char sex;
	
	public void present() {
		System.out.println("人高高兴兴地度过每一天");
	}
	public void work() {
		System.out.println("对工作认真地负责");
	}
}


public class Teacher extends Person {

	public void shool() {
			super.name="王五";
		job="师范大学";
		System.out.println(name+"在"+job+"教Java课");
	}
	public void home() {
		super.name="王五";
		System.out.println(name+"的家家庭充满知识的气氛");
	}
}

public class Student extends Person{
	String name="小花";
	protected void operating() {
		age=17;
		System.out.println(name+"在"+age+"上高三");
	}
	public void home() {
		
		System.out.println(name+"在家庭看书");
	}

}

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//	向上转型
		Teacher teacher=new  Teacher();
		teacher.shool();
		//向下转型 把父类引用 赋予子类引用
		// Type mismatch: cannot convert from Person to Student
		Student student=new Student() ;
		
		//Dog dog = (Dog)animal;  //向下转型
		student.operating();
		Person person=new Teacher();
		person.work();
		
		Person person1=new Student();
		Student student1= (Student) person1 ;
		student1.home();
		
		//instanceof 如果是，返回 ture 否则是false
		Person person2 =new Teacher();
		if(person2 instanceof Teacher ){
			Teacher teacher1 = (Teacher)person2;
			teacher1.home();
			
		} 

	}
	
}


 

我们知道面向对象有三大特性：封装、继承、多态。
1、封装的作用是隔离和代码重用。隔离其实是低耦合的考虑，使得模块之间的关连变小；代码重用就不用多讲了，就是多处需要同一个对象时不用重复实现。
而继承
2、继承的作用是代码重用。但我觉得除了代码重用，继承更大的用作就是为了多态的使用。下面主要介绍多态的作用。
3、多态
多态其实就是接口重用。多态和继承是紧密联系的，没有继承就没有多态，而多态使得继承更有意义。
多态的实现是由虚函数实现的。
我们可以看一个应用场景：
比如在发帖之前，我们要做很多loader动作：比如封禁词审核、图片审核、userinfo。那么我们可以定义一个抽象类
class interface{
virtual void startLoader();
}
然后构建一个数组interface* arr[]；将我们需要做loader动作的子类指针装进数组，之后我们就可以异步的调用相应的startLoader()
for auto it : arr{
　　pthread_create(&t_id,NULL,(void*)it->startLoader,NULL);
}
这样就可以实现一个接口多种不同的调用。
转载于:https://www.cnblogs.com/coderht/p/7499294.html