黑马程序员——java基础——面向对象（3）多态

最新推荐文章于 2023-05-25 15:39:11 发布

Huberry

最新推荐文章于 2023-05-25 15:39:11 发布

阅读量542

点赞数

分类专栏：日记文章标签：黑马程序员 java 面向对象

本文链接：https://blog.csdn.net/Huberry/article/details/39052225

版权

日记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、多态

1、多态的基本概念

多态是指同一事物具有多种形态即为多态。

使用多态特性可以使一个对象具有多种形态，从而使对象可以具有更多的特性功能，服务于更多的环境。

在面向对象语言中，我们可以将函数的形参定义为一个父类类型，而在真正调用该函数时这个父类类型的所有子类对象都可以传入，根据传入的子类对象不同函数可以运行处多种形态。

2、多态的体现

1）父类的引用指向了自己子类的对象。

2）父类的引用也可以接收自己的子类对象。

如：两个类Animal和Cat，其中Cat继承了Animal

Animal a =new Cat();

其中就将父类型的 a 引用指向了子类的对象。

3、多态的条件

1）要有继承或者实现。

2）存在方法的重写。

4、多态的利弊

利：提高了程序的可扩展性和后期可以维护性。

弊：只能使用父类中的引用访问父类中的成员。也就是说使用了多态，父类型的引用在使用功能时，不能直接调用子类中的特有方法。

如：Animala =new Cat()；这代码就是多态的体现，假设子类Cat中有特有的抓老鼠功能，父类型的 a就不能直接调用。这上面的代码中，可以理解为Cat类型提升了，向上转型。如果此时父类的引用想要调用Cat中特有的方法，就需要强制将父类的引用，转成子类类型，向下转型。如：Catc = (Cat)a；

注：如果父类可以创建对象，如：Animal a = new Animal(); 此时，就不能向下转型了，Cat c = (Cat)a; 这样的代码就变得不容许，编译时会报错。所以千万不能出现这样的操作，就是将父类对象转成子类类型。

我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态至始至终都是子类对象在做着变化。

5、多态的特点

1）成员函数：

a）非静态函数：

编译时：要查看引用变量所属的类中是否有所调用的成员。(编译看左边)；

运行时：要查看对象所属的类中是否有所调用的成员。(运行右边)

简单说就是，非静态成员函数在多态调用时，编译看左边，运行看右边。

b）静态函数：

编译时、运行时都参考引用型变量所属的类中是否有调用的静态方法。(编译和运行都参考等号的左边)
2）成员变量：只看引用变量所属的类。(编译和运行都参考等号的左边)

如：Animal a = new Cat();//自动类型提升，猫对象提升了动物类型，但是特有功能无法访问。作用就是限制对特有功能的访问。--向上转型

Cat c = (Cat)a；//如果还想用具备动物猫的特有功能，你可以将该对象进行向下转型，向下转型的目的是为了使用子类中的特有方法。

ClassCastException：类型转换异常
注意：对于转型，自始至终都是子类对象在做着类型的变化。

6、多态的应用

1、定义好工具类，即将共同行为封装在一个类中。

2、对类型进行抽取，---->多态的产生。

3、操作同一父类型，对其中的子类型均可操作

二、内部类

1、内部类概念

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物的内容。如定义一个描述人的类，而手、心脏等都属于人，然它们又有自己的功能描述，这时可以在人这个描述类中，定义一个描述心脏的类，也就是内部类。

编译时，如果代码中有内部类，生成的class文件中会含有这样的文件：Test$1.class。编译器将会把内部类翻译成用$（美元符号）分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。

2、内部类的访问规则

1）内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式：外部类名.this。

2）外部类要访问内部类，必须建立内部类对象。

3、访问格式

1）当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。

格式：外部类名.内部类名变量名 =外部类对象.内部类对象；

如： Outer.Inner in =new Outer().new Inner();

当内部类在外部类中的成员位置上时，可以被成员修饰符所修饰。比如：

private：将内部类在外部类中进行封装。

static：内部类就局部static的特性。但是当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，直接访问static内部类的非静态成员的格式为：

new 外部类名.内部类名（）.方法名（）；

如：new Outer.Inner().function();

在外部其他类中，直接访问static内部类的静态成员格式为：

外部类名.内部类名.方法名（）；

如：Outer.Inner.function();

注意：

a）当内部类中定义了静态成员时，该内部类必须是static的。

b）当外部类中的静态方法访问内部类时，内部类也必须是static的。

c）在实际应用中，内部类通常被定义为private，而很少定义为public。

代码示例：

classOuter {
private static int num=3;
static class Inner {
void show(){
System.out.println(“show run”+num);
}
static void function(){//如果内部类中定义了静态成员，该内部类也必须是静态的。
System.out.println(“function”+num);
}
}
public void method() {
Inner in = new Inner();
in.show();
}
}
class InnerClassDemo {
public static void main(String[] args) {
Outer out = new Outer();
out.method();
//直接访问外部类中的内部类中的成员（除非用private修饰）
Outer.Inner in = new Outer().new Inner();
in.show();
//如果内部类是静态的，相当于一个外部类
Outer.inner in = new Outer.Inner();
In.show();
//如果内部类是静态的，成员是静态的。
Outer.Inner.function();
}
}