2021-08-21

最新推荐文章于 2021-12-21 17:10:32 发布

weixin_58702165

最新推荐文章于 2021-12-21 17:10:32 发布

阅读量59

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/weixin_58702165/article/details/119838941

版权

笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了Java中的多态性，包括其概念、实现方式、成员特点（成员变量、成员方法和静态方法）。通过实例展示了向上转型和向下转型的过程，并探讨了多态性的优点（如提高代码可维护性和可扩展性）和缺点（如无法直接访问子类特有成员）。最后，讨论了如何通过转型来访问子类特有的方法。

摘要由CSDN通过智能技术生成

多态
多态的概述和实现
多态成员的特点
多态中的向上转型和向下转型
多态的优点和缺点
多态的概述和实现
概念：多态是同一个行为具有不同表现形式或形态的能力，多态性是对象多种表现形式和体现。
多态的前提：
子父类的继承关系或子类实现父类接口
必须有方法的重写
父类引用指向子类对象
package com.itheima;

/**

@author 11137_yyss3t3
多态的前提：
子父类的继承关系
方法的重写
父类引用指向子类对象
*/
public class Demo1_1 {

public static void main(String[] args) {
Cat cat = new Cat();
cat.eat();
//父类引用指向子类对象
Animal a = new Cat();
a.eat();
}
}

/**

@author 11137_yyss3t3
*父类，动物类
*/
class Animal{
public void eat() {
System.out.println(“吃东西”);
}
}

/**

@author 11137_yyss3t3
*子类猫继承了动物类并且重写了eat()方法
*/
class Cat extends Animal{
@Override
public void eat() {
System.out.println(“猫吃鱼”);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
输出的结果为：
猫吃鱼
猫吃鱼
多态成员的特点
成员变量的特点：上代码
package com.itheima;

/**

@author 11137_yyss3t3
多态的成员特点：

 成员变量：编译看左边，运行看左边

```
 成员方法
```
```
 静态方法
```

*/
public class Demo1_2 {

public static void main(String[] args) {
	Dad dad = new Kid();
	System.out.println(dad.num);
}

}

class Dad{
int num = 20;
}
class Kid extends Dad{
int num = 10;
}
输出结果为：20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
父类引用指向子类对象，父亲类和儿子类中都有成员变量，变量不像方法一样有重写，变量是没有重写的概念的，所以运行的是父类方法的成员变量。如果父类中没有这个成员变量，程序会出现编译错误。
多态中成员变量的特点是：编译看左边，运行也看左边

成员方法的特点
package com.itheima;

/**

@author 11137_yyss3t3
多态的成员特点：
```
 成员变量
```

 成员方法：编译看左边，运行看右边

```
 静态方法
```

*/
public class Demo1_2 {

public static void main(String[] args) {
	//父类引用指向子类对象
	Dad dad = new Kid();
	dad.method();
}

}

class Dad{
public void method() {
System.out.println(“我是父类方法”);
}
}
class Kid extends Dad{
public void method() {
System.out.println(“我是子类方法”);
}
}
输出的结果为：我是子类方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
因为成员方法是可以重写的，所以会执行子类的方法。但是如果父类中没有method()方法，编译器会报错。
总结：编译看左边，运行看右边

静态方法的特点
package com.itheima;

/**

@author 11137_yyss3t3
多态的成员特点：
```
 成员变量
```
```
 成员方法
```

 静态方法：编译看左边，运行看左边

*/
public class Demo1_2 {

public static void main(String[] args) {
	//父类引用指向子类对象
	Dad dad = new Kid();
	dad.method();
}

}

class Dad{
public static void method() {
System.out.println(“我是父类静态方法”);
}
}
class Kid extends Dad{
public static void method() {
System.out.println(“我是子类静态方法”);
}
}
输出结果是：我是父类静态方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
分析：使用变量去调用静态方法，其实相当于变量类型的类名去调用，也就是Dad.method(),所以运行的是父类里面的静态方法。如果父类没有静态方法，编译报错。
总结：编译看左边，运行看左边

多态中的向上转型和向下转型
向上转型
package com.itheima;

/**

@author 11137_yyss3t3
多态的向上转型和向下转型
*/
public class Demo1_3 {

public static void main(String[] args) {
//父类引用指向子类对象,其实这就是向上转型
Animal01 a = new Dog();
a.eat();
}
}
class Animal01 {
public void eat() {
System.out.println(“吃东西”);
}
}

class Dog extends Animal01{
@Override
public void eat() {
System.out.println(“狗吃骨头”);
}

public void swim() {
	System.out.println("狗刨");
}

}
输出结果是：狗吃骨头
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
看上面代码狗类还有一个自己特有的方法游泳，现在是找不到子类的swim()方法的。如何才能运行swim()方法呢？

向下转型
package com.itheima;

/**

@author 11137_yyss3t3
多态的向上转型和向下转型
*/
public class Demo1_3 {

public static void main(String[] args) {
//父类引用指向子类对象,其实这就是向上转型
Animal01 a = new Dog();
Dog d = (Dog)a;//向下转型
d.swim();
}
}
class Animal01 {
public void eat() {
System.out.println(“吃东西”);
}
}

class Dog extends Animal01{
@Override
public void eat() {
System.out.println(“狗吃骨头”);
}

public void swim() {
	System.out.println("狗刨");
}

}
输出结果：狗刨
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
多态的优点和缺点
缺点：父类引用无法直接访问子类特有成员
优点：
可以提高可维护性
提高可扩展性
文章最后发布于:2020-06-30 23:28:05