JAVA-DAY9（面向对象--封装，继承，多态，重载，重写）

qq_53439751

已于 2022-08-12 00:38:49 修改

阅读量222

点赞数

文章标签： java 开发语言 servlet

于 2022-06-30 21:52:31 首次发布

本文链接：https://blog.csdn.net/qq_53439751/article/details/125533497

版权

1，指针可以指向对象：指针的数据类型和对象的数据类型必须一样；（Car car=new Dog() 这个是错误的，因为car的数据类型是Car类型）。

2，在有了继承之后，指针的数据类型可以和对象的数据类型不一样。如果存在继承关系，那么父类类型的指针可以指向子类类型的对象。例如：Dog，Pig，Cat这三个子类继承Animal父类

Dog dog =new Dog(); Cat cat=new Cat();//一定是正确的

Animal animal1=new Dog();Animal animal2=new Cat()//如果有继承关系Dog extends Animal就正确

Object object1=new Dog(); Object object2=new Dog();//正确。Object类型的指针可以指向任意类型对像。

这种将子类对象赋给父类指针的语法称为”向上转型“，隐式的。越向上转型，不可访问的对象就越多，越向上转型，指针数据类型越抽象。

3，继承是向上转型的前提，向上转型是多态的前提，向上转型的副作用：指针无法访问下级对象中的成员。”向下转型“需要显式的强制转换，通常伴随着instanceof做类型判断。指针向下转型为下级类型，就又可以访问下级对象中的成员了

如果使用了”向上转型"实现了多态指针，在用指针操作对象的时候又不想做“向下转型”，可以使用方法重写来实现

4，思考：Animal类型的指针为什么不能调用show（）方法，因为Animal没有show（）方法，我们需要从子类中调用show（）方法

（1）在父类Animal中添加一个show（）方法

animalArray[i].show();此时animalArray[i]不需要向下转型也可以调用show（）方法

（2）当子类中出现与父类的同名方法的时候，就存在方法重写的关系，那么此时当使用父类类型指针调用方法的时候，如果当前子类中存在满足重写关系的方法的时候，会自动向下去调用子类重写的方法。

5，abstract关键字：抽象可以修饰成员方法和类，成员方法被abstract修饰后，被称为方法/虚方法，没有{}方法体

类被abstract修饰后，被称为抽象类，不可以被实例化，当一个类中出现抽象方法时，这个类必须为抽象类，抽象方法必须出现在抽象类中，而抽象类中不一定必须有抽象方法。例如：Animal类被abstract修饰，成为抽象类。Animal animal=new Animal()；//报错，抽象类不可以被实例化，抽象类天生就是父类，天生就是被子类继承的。子类继承父类的时候，如果父类中有抽象方法，子类必须重写，除非把子类也变为抽象类，让子类的子类去重写（实现）。

Dog dog=new Cat();Cat cat=new Dog()//不正确

final的作用

修饰类--最终的
修饰变量，称为常量，值不可以修改。
修饰方法，称为最终方法，方法不可以被子类重写。
修饰类，称为最终类，类不可以被继承

abstract关键字是否可以与final同时出现？
或者这么问能不能同时用absract和final修饰类或者方法
答案：不能
原因：
1.abstract修饰的类称为抽象类，抽象类不能被实例化，只能被继承，而final是阻止类被继承
2.abstract修饰的方法称为抽象方法，抽象方法必须让子类重写，而final是阻止子类重写

final的变量能改吗？
如果final修饰的变量是基本数据类型，指向常量池，那么不可以改
如果final修饰的变量是引用类型数据，指向堆，那么指针不可以修改，但指针指向对象中的成员或者数组元素是可以改的

final修饰的数组能实现扩容吗？不能进行扩容

6，面向对象整理

（1）面向过程和面向对象是区别：

1）面向过程编程思想不考虑封装，继承，多态这些事情，直接定义数据为静态变量，用静态函数操作数据，基于过程编码。面向过程编码，代码不具有可复用性和可扩展性。（静态变量，静态方法，静态代码块）

2）面向对象编程（OOP）思想需要先抽象出实体的结构，并用类进行封装，用成员变量表达实体的属性，用成员方法封装对实体属性的操作，提供构造方法构造对象，基于对象编程。面向对象编码，代码具有可复用性和可扩展性。（成员变量，成员方法，构造方法）

举例：实现汽车租聘系统

面向过程的思想：定义多个静态数组，存储汽车各项数据，直接定义静态函数实现各种业务过程。

面向对象的思想：先抽象出汽车实体结构，并使用汽车类进行封装，然后创建汽车数组存储汽车实体的数据，再考虑业务功能实现。

（2）面向对象的三大特征：

1）封装：用成员变量来描述对象的属性，并用private /ˈpraɪvət/进行私有化封装，不对外暴露对象属性，防止外部对属性误操作。用成员方法来封装对属性的操作，并暴露给外部调用。典型的成员方法就是setter和getter，setter是提供给外部进行属性设值，getter是提供给外部读取属性的值。

2）继承：

1.继承是Java中类与类之间的一种关系

2.关键字：extends

3.发生继承的类称为子类，被继承的类称为父类。一个类只能有一个继承一个父类，一个父类可以有多个子类

4.java不支持多继承，只支持单继承，但支持多级继承。

5.如果一个类没有显示继承父类，则隐式继承Object类

6.子类可以继承父类的非私有化成员

7.父类的构造方法不能被子类继承，但是可以被super（）调用

8 .父类的静态成员与继承无关

9. 如果父类中有抽象方法，子类必须要重写，除非子类也是抽象类，让子类的子类去重写（实现）

3) 多态

先有继承而后有多态，多态的反义词是单态

1.指针的多态（数组的多态，参数的多态，返回值的多态，归根到底都是指针的多态）

指针是引用类型的变量，指针可以是静态变量，成员变量，局部变量/参数/返回值

如果指针是具体的子类类型，则指针是单态指针，只能指向具体的子类对象。例如：Dog dog；

如果指针是抽象的父类类型，则指针是多态指针，可以指向任意的子类对象。例如：Animal animal

2.方法的多态（1.基于重载实现 2.基于重写实现）

重载是编译时多态的体现

重写是运行时多态的体现

4）重载和重写的区别

重载（overload）是编译时多态的体现

1.重载发生在同一个类中，Java允许多个方法同名存在，但必须满足方法重载的要求

2.方法名相同，但是方法的参数列表不同（可以是参数个数不同，或者是参数类型不同）

5 ）.静态方法，构造方法，成员方法都可以重载

重载与面向对象无关

重写(override)是运行时多态的体现

1.重写发生在子类与父类之间，子类重写父类的方法，其目的是：当使用父类型的指针调用子类方法的时候，可以无需做向下转型。

2.子类方法与父类方法同名

3.访问修饰符要大于等于父类方法

4.参数的个数必须与父类一样，参数类型可以小于等于父类方法的参数类型

5.返回值类型可以小于等于父类方法的返回值类型

6）抽象类和抽象方法的关系

1，抽象类和抽象方法都需要使用abstract关键字修饰

2，抽象方法必须出现在抽象类中，抽象方法没有方法体，必须被子类重写

3，抽象类可以有抽象方法，也可以没有

7）普通类和抽象类的区别：

普通类可以实例化，也可以被继承。

抽象类不可以实例化，只能被继承。（实例化就是new构造方法（）创建对象）

8）向下转型和向上转型的区别

向上转型

1.将子类对象/指针赋给父类指针的语法称为“向上转型”，隐式的

2.继承是向上转型的前提，向上转型的目的是为了实现多态指针

3.向上转型的副作用：指针无法访问下级对象中的成员（除非发生重写）

向下转型

1.将父类型指针赋给子类型指针的语法称为 ”向下转型“需要显式的强制转换，通常伴随着instanceof做类型判断。否则可能会出现ClassCastException(类型转换异常)

2.指针向下转型为下级类型，就又可以访问子类中特有成员了（非重写的成员方法）

9）访问权限修饰符

修饰符		当前类	同包	子类	其他包
private	私有的	可见	不可见	不可见	不可见
（default）	默认的	可见	可见	不可见	不可见
protected	受保护的	可见	可见	可见	不可见
public	公有的	可见	可见	可见	可见