多态的表现形式
0
所有回答(4)
0
重载多态, 继承多态,
重载多态:
如:public void show(int a)
{
out<<a<<endl;
}
public void show(string b)
{
out<<b<<endl;
}
继承多态,:
class person
{
string name;
public:
virtual void show()=0;
}
class student:public person
{
void show(){out<<"学生:"<<name<<endl;
}
class teacher:public person
{
void show(){out<<"老师:"<<name<<endl;
}
main函数里:
person per1=new student();
person per2=new teacher();
student.show();
teacher.show();
会显示不同结果
0
C++中，实现多态有以下方法：虚函数，抽象类，重载，覆盖
0
有两种主要体现：
1、方法的重载和覆盖
a)、重载
View Code
1 /**
2 * 重载：1参数的类型不同 2参数的个数不同 3 参数的顺序不同
3 * 与参数的返回值无关，与作用域无关
4 * 在继承中，父类方法除私有外，其它满足重载要求
5
6 */
7
8
9 class OverLoadFather
10 {
11 private int OverLoad(int i){
12 System.out.println("这是父类的int OverLoad(int i)方法！");
13 return i;
14 }
15
16 public int OverLoad(double i){
17 System.out.println("这是父类的int OverLoad(double i)方法！");
18 return (int)i;
19 }
20
21 int OverLoad(float i){
22 System.out.println("这是父类的int OverLoad(float i)方法！");
23 return (int)i;
24 }
25
26 protected int OverLoad(int i,int j){
27 System.out.println("这是父类的int OverLoad(int i,int j)方法！");
28 return i + j;
29 }
30 }
31
32 class OverLoadSub extends OverLoadFather
33 {
34 private int OverLoad(int i){
35 System.out.println("这是子类的int OverLoad(int i)方法！");
36 return i;
37 }
38
39 /*
40 * 重载与返回值的类型无关
41 public double OverLoad(int i){
42 System.out.println("这是子类的double OverLoad(int i)方法！");
43 return i;
44 }*/
45
46 public int OverLoad(double i){
47 System.out.println("这是子类的int OverLoad(double i)方法！");
48 return (int)i;
49 }
50
51 public int OverLoad(float i){
52 System.out.println("这是子类的int OverLoad(float i)方法！");
53 return (int)i;
54 }
55
56 public int OverLoad(int i,double j){
57 System.out.println("这是子类的int OverLoad(int i,double j)方法！");
58 return i + (int)j;
59 }
60
61 public int OverLoad(double i,int j){
62 System.out.println("这是子类的int OverLoad(double i,int j)方法！");
63 return (int)i + j;
64 }
65
66 public int OverLoad(int i,double j,float k){
67 System.out.println("这是子类的int OverLoad(int i,double j,float)方法！");
68 return i + (int)(j + k);
69 }
70
71 public int OverLoad(float i,int j,double k){
72 System.out.println("这是子类的int OverLoad(float i,int j,double k)方法！");
73 return (int)i + j +(int) k;
74 }
75 }
76 public class TestOverLoad{
77 public static void main(String[] args)
78 {
79 OverLoadSub ol =new OverLoadSub();
80 ol.OverLoad(3);
81 ol.OverLoad(3.0);
82 ol.OverLoad(3,3.0);
83 ol.OverLoad(3.0f,3,3.0);
84 ol.OverLoad(3,3,3.0);
85 }
86 }
b)、覆盖
1 class A{ // 定义类A
2 public void fun1(){ // 定义fun1()方法
3 }
4 public void fun2(){
5 }
6 }
7 class B extends A{
8 public void fun1(){ // 此方法被子类覆写了
9 }
10 public void fun3(){
11 }
12 };
13 public class Pol{
14 public static void main(String asrgs[]){
15 B b = new B() ; // 实例化子类对象
16 A a = b ; // 向上转型关系
17 a.fun1() ; // 此方法被子类覆写过
18 a.fun3() ;
19 }
20 }
2、对象的多态性（向上转型和向下转型）
a)、向上转型
1 class A{ // 定义类A
2 public void fun1(){ // 定义fun1()方法
3 }
4 public void fun2(){
5 }
6 }
7 class B extends A{
8 public void fun1(){ // 此方法被子类覆写了
9 }
10 public void fun3(){
11 }
12 };
13 public class Pol{
14 public static void main(String asrgs[]){
15 B b = new B() ; // 实例化子类对象
16 A a = b ; // 向上转型关系
17 a.fun1() ; // 此方法被子类覆写过
18 a.fun3() ;
19 }
20 }
b)、向下转型
1 class A{ // 定义类A
2 public void fun1(){ // 定义fun1()方法
3 }
4 public void fun2(){
5 }
6 }
7 class B extends A{
8 public void fun1(){ // 此方法被子类覆写了
9 }
10 public void fun3(){
11 }
12 }
13 public class Pol{
14 public static void main(String asrgs[]){
15 A a = new A() ; // 实例化了一个父类对象
16 B b = (B)a ; // 发生了向下转型关系
17 b.fun1() ;
18 b.fun2() ;
19 b.fun3() ;
20 }
21 }
0
package test;
public interface Animal {
// 动物叫
public void bark();
}
package test;
public class cat implements Animal {
// 猫叫的方式
@Override
public void bark() {
System.out.println("喵喵");
}
}
package test;
public class dog implements Animal {
// 狗叫方式
@Override
public void bark() {
System.out.println("旺旺");
}
}
如上面：动物是本身虚拟的，他有一种叫的本性；但是不知道动物是怎么叫的。然而猫，狗，去继承了动物类后，
就可以叫出不同的方式；自己感觉就是一种形态用于多种的地方
