黑马程序员------继承(三)

1.1 多态:可以理解为某一类事物存在的多种体现形态。

人:男人,女人

动物:猫,狗。

猫 x = new 猫();

动物 x = new 猫();

1,体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
2,前提
必须是类与类之间有关系。要么继承,要么实现。
通常还有一个前提:存在覆盖。

3,好处
多态的出现大大的提高程序的扩展性。

4,弊端:
提高了扩展性,但是只能使用父类的引用访问父类中的成员。

示例1:

 1 /*
 2 动物,
 3 猫,狗。
 4 */
 5
 6 abstract class Animal
 7 {
 8     abstract void eat();
 9
10 }
11
12 class Cat extends Animal
13 {
14     public void eat()
15     {
16         System.out.println("吃鱼");
17     }
18     public void catchMouse()
19     {
20         System.out.println("抓老鼠");
21     }
22 }
23
24
25 class Dog extends Animal
26 {
27     public void eat()
28     {
29         System.out.println("吃骨头");
30     }
31     public void kanJia()
32     {
33         System.out.println("看家");
34     }
35 }
36
37
38 class Pig extends Animal
39 {
40     public void eat()
41     {
42         System.out.println("饲料");
43     }
44     public void gongDi()
45     {
46         System.out.println("拱地");
47     }
48 }
49
50
51 class DuoTaiDemo
52 {
53     public static void main(String[] args)
54     {
55         //Cat c = new Cat();
56         //c.eat();
57
58         //Dog d = new Dog();
59         //d.eat();
60         //Cat c = new Cat();
61         /*
62         Cat c1 = new Cat();
63         function(c1);
64
65         function(new Dog());
66         function(new Pig());
67         */
68
69         //Animal c = new Cat();
70         //c.eat();
71
72
73         function(new Cat());
74         function(new Dog());
75         function(new Pig());
76
77
78
79     }
80     public static void function(Animal a)//Animal a = new Cat();
81     {
82         a.eat();
83         //a.catchMouse();
84     }
85
86 }

1.2 如何使用子类特有方法呢?

向上转型或者向下转型(示例2)

示例2:

 1 class Cat extends Animal
 2 {
 3     public void eat()
 4     {
 5         System.out.println("吃鱼");
 6     }
 7     public void catchMouse()
 8     {
 9         System.out.println("抓老鼠");
10     }
11 }
12
13
14 class Dog extends Animal
15 {
16     public void eat()
17     {
18         System.out.println("吃骨头");
19     }
20     public void kanJia()
21     {
22         System.out.println("看家");
23     }
24 }
25
26
27 class Pig extends Animal
28 {
29     public void eat()
30     {
31         System.out.println("饲料");
32     }
33     public void gongDi()
34     {
35         System.out.println("拱地");
36     }
37 }
38
39
40 class DuoTaiDemo2
41 {
42     public static void main(String[] args)
43     {
44         //Animal a = new Cat();//类型提升。 向上转型。
45         //a.eat();
46
47         //如果想要调用猫的特有方法时,如何操作?
48         //强制将父类的引用。转成子类类型。向下转型。
49         ///Cat c = (Cat)a;
50         //c.catchMouse();
51         //千万不要出现这样的操作,就是将父类对象转成子类类型。
52         //我们能转换的是父类应用指向了自己的子类对象时,该应用可以被提升,也可以被强制转换。
53         //多态自始至终都是子类对象在做着变化。
54                //Animal a = new Animal();
55               //Cat c = (Cat)a;
56
57
58
59         function(new Dog());
60         function(new Cat());
61
62
63     }
64     public static void function(Animal a)//Animal a = new Cat();
65     {
66         a.eat();
67         /*
68         if(a instanceof Animal)
69         {
70             System.out.println("haha");
71         }
72         else
73         */
74         if(a instanceof Cat)
75         {
76             Cat c = (Cat)a;
77             c.catchMouse();
78         }
79         else if(a instanceof Dog)
80         {
81             Dog c = (Dog)a;
82             c.kanJia();
83         }
84
85     }
86
87 }
88  

PS:

instanceof : 用于判断对象的类型。 对象 intanceof 类型(类类型 接口类型)


1.3 多态在成员变量和成员函数中的特点:

在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。
在运行时期:参阅对象所属的类中是否有调用的方法。
简单总结就是:成员函数在多态调用时,编译看左边,运行看右边。

在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类)。

在多态中,静态成员函数的特点:
无论编译和运行,都参考做左边。

示例3

 1 class Fu
 2 {
 3     static int num = 5;
 4     void method1()
 5     {
 6         System.out.println("fu method_1");
 7     }
 8     void method2()
 9     {
10         System.out.println("fu method_2");
11     }
12     static void method4()
13     {
14         System.out.println("fu method_4");
15     }
16 }
17
18
19 class Zi extends Fu
20 {
21     static int num = 8;
22     void method1()
23     {
24         System.out.println("zi method_1");
25     }
26     void method3()
27     {
28         System.out.println("zi method_3");
29     }
30
31     static void method4()
32     {
33         System.out.println("zi method_4");
34     }
35 }
36 class  DuoTaiDemo4
37 {
38     public static void main(String[] args)
39     {
40         //Fu f = new Zi();
41         //System.out.println(f.num);
42         //Zi z = new Zi();
43         //System.out.println(z.num);
44
45         //f.method1();
46         //f.method2();
47         //f.method3();
48
49         Fu f = new Zi();
50         System.out.println(f.num);
51         f.method4();
52
53         Zi z = new Zi();
54         z.method4();
55         }
56 }
时间: 2024-12-28 15:14:38

黑马程序员------继承(三)的相关文章

黑马程序员-继承

类用于描述事物. 父类的由来,子类不断向上抽取. 继承: 1.提高了代码的复用性. 2.让类与类之间产生了关系,有了这个关系,才有了多态的特性. 注意:不要为了获取其他类的功能,简化代码而继承. 必须是类与类之间有所属关系才可以继承.所属关系is a. java不支持多继承.多继承带来隐患:当多个类中定义了相同的功能(如一个方法)时,当功能内容不同时,子类不确定要运行哪个.但是支持多实现.但是接口可以多继承. java支持多层继承.也就是一个体系.A extends B C extends A

黑马程序员------IO(三)

1.1 通过字节流演示读取键盘录入. System.out:对应的是标准输出设备,控制台.System.in:对应的标准输入设备:键盘. 代码 InputStream in=System.in; int by=in.read(); sop(by);结束录入 in.close(); 1.1.1 需求:通过键盘录入数据(示例1): 当录入一行数据后,就将该行数据进行打印.如果录入的数据是over,那么停止录入. 分析:键盘本身就是一个标准的输入设备.对于java而言,对于这种输入设备都有对应的对象.

黑马程序员------继承(一)

4.1 继承的描述 通过 extends 关键字让类与类之间产生继承关系.    多个类中存在相同属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需再定义这些属性和行为,只要继承那个类即可.    多个类可以称为子类,单独这个类称为父类或者超类. P.S.    1.子类可以直接访问父类中的非私有的属性和行为.    2.子类无法继承父类中私有的内容.    3.父类怎么来的?共性不断向上抽取而来的.

黑马程序员 面向对象(上) 封住,继承,多态,以及this和super的用法

---------------------- ASP.Net+Unity开发..Net培训.期待与您交流! ----------------------/* * 一.类的继承: 当多个类出现了相同的属性和行为时,我们可以把这些类中相同的属性和行为抽取出来 成为独立的一个类,然后让这些类分别去继承抽取类,再根据自己需求去实现别的功能 这样大大的增强的相同代码的复用性,也使代码变得美观 我们把这个抽取类叫做这些类的父类,这些类叫做抽取类的子类,子类是可以继承父类中 的所有信息. 在Java中所有的类

黑马程序员-OC面向对象继承关系和组合关系笔记

继承关系是描述类和类之间的关系,两个类分别称为子类和父类,子类继承了父类,子类就拥有了父类的属性和方法: 继承的关系特点描述出来就是:** "是" **  (例如:学生类 是 人类) 组合关系描述的语句是:**** "拥有" ***  (例如:学生有成绩这个属性,而成绩属性本来就是一个成绩类的对象 ) 继承示例代码: #import <Foundation/Foundation.h> //Animal类的声明 @interface Animal : NS

黑马程序员 【】java学习之路——TCP(三)客户端上传文件到服务器

------- <a href="http://www.itheima.com" target="blank">android培训</a>.<a href="http://www.itheima.com" target="blank">java培训</a>.期待与您交流! ---------- import java.io.*; import java.net.*; class

黑马程序员-----集合框架类(三) Map集合

黑马程序员-----集合框架类(三) Map集合 1.1 Map集合:该集合存储键值对.一对一对往里存.而且要保证键的唯一性. 1,添加. put(K key, V value) putAll(Map<? extends K,? extends V> m) 2,删除. clear() remove(Object key) 3,判断. containsValue(Object value) containsKey(Object key) isEmpty() 4,获取. get(Object ke

黑马程序员之——Java基础 IO流——第三部分

-----------android培训.java培训.java学习型技术博客.期待与您交流!------------ 第一讲:黑马程序员_毕向东_Java基础视频教程第20天-01-IO流(File概述) 一,File 类的了解: 用于将文件或者文件夹封装成对象. 方便对文件与文件夹进行操作. File对象可作为参数传递给流对象的构造方法. File 类的声明:public class File extends Object implements Serializable, Comparabl

黑马程序员------IO(五)

黑马程序员------IO(五) 1.1  操作对象(示例1)ObjectInputStream与ObjectOutputStream 被操作的对象需要实现Serializable. Serializable:用于给被序列化的类加入ID号,用于判断类和对象是否是同一个版本 类通过实现java.io.Serializable接口以启用序列化功能,Serializable只是一个标记接口. 1 示例1: 2 import java.io.*; 3 4 class ObjectStreamDemo 5