面向对象（二）封装性、继承性、多态性

一、面向对象特征一：封装性

封装和隐藏：

特点：

高内聚：类的内部数据操作细节自己完成，不允许外部干涉。
低耦合：仅仅对外暴漏少量方法用于使用。

体现：私有化属性，设置公有的方法来获取和设置属性。需要权限修饰符来配合。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。

通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

权限修饰符：

修饰符	类内部	同一个包	不同包的子类	同一工程
private	yes
缺省	yes	yes
protected	yes	yes	yes
public	yes	yes	yes	yes

用来修饰的结构说明：
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public

类的成员之三：构造器

构造器：construct
作用：
1）创建对象
2）初始化对象

说明：

如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器
定义构造器的格式：权限修饰符类名(形参列表){}
一个类中定义的多个构造器，彼此构成了重载
一旦我们显示的定义了类的构造器之后，系统就不在提供默认的空参构造器
一个类中，至少会有一个构造器

构造器的特征：

它具有与类相同的名称。
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

例如：public Person(){} //无参构造器

属性赋值的先后顺序：

1）默认初始化
2）显示初始化
3）构造器初始化
4）通过"对象.方法" 或 "对象.属性"的方式赋值（set方法）

JavaBean

类是公有的
有一个无参的公共构造器
有属性，且有对应的get，set方法

this关键字的使用

1）this可以用来修饰属性和方法
this代表当前对象
2）this可以用来修饰和调用构造器
this代表当前正在创建的对象
调用构造器：
public Student(Integer number, Integer state) {
  this.number = number;
  this.state = state;
}

public Student(Integer number, Integer state, Double score) {
  this(number,state);//调用其他构造器，不能调用自己。
  this.score = score;
}

package关键字的使用

为了更好的实现项目中类的管理，提供包的概念。
使用package声明类或接口属性的包，声明在源文件的首行。
包，属性标识符，遵循标识符的命名规则/规范、见名知意。
每"."一次，就是一层文件目录。

补充：

同一个包下不能命名同名的接口、类。
不同包下不可以命名同名的接口、类。

MVC设计模式

模型层 model：bean/domain，dao，db
视图模型层view
控制器层controller：service，base，activity

import关键字的使用

语法：

import 包名.类名;

说明：

在源文件中显示的使用 import 结构导入指定包下的类、接口
声明在包的声明和类的声明之间
如果需要导入多个结构，则并列写出即可
可以使用 xxx.* 的方式，便是可以导入xxx包下的所有结构
如果使用的类或接口是 java.lang 包下定义的，则可以忽略 import 结构
如果使用的类或接口是本包下定义的，则可以省略 import 结构
如果在源文件中，是用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示
import static：导入指定类或接口中的静态结构：属性或方法

Eclipse中的快捷键

1.补全代码的声明: alt + /
2.快速修复: ctrl + 1
3.批量导包: ctrl + shift + o
4.使用单行注释: ctrl + / 
5.使用多行往释: ctrl + shift + /
6.取消多行注释: ctrl + shift + \
7.复制指定行的代码: ctrl + alt + down 或 ctrl + alt + up
8.删除指定行的代码: ctrl + d
9.上下移动代码: alt + up 或alt + down
10.切换到下一行代码空位: shift + enter
11.切换到上一行代码空位: ctrl + shift + enter
12.如何查看源码: ctrl +选中指定的结构 或 ctrl + shift + t
13.退回到前一个编辑的页面: alt + left
14.进入到下一个编辑的页面(针对于上面那条来说的): alt + right
15.光标选中指定的类，查看继承树结构: ctrl + t
16.格式化代码: ctrl + shift + f
17.在当前类中，显示类结构，并支持搜索指定的方法、属性等（类似于 eclipse 的 的 outline）: ctrl + o
18.批量修改指定的变量名、方法名、类名等: alt + shift + r
19.选中的结构的大小写的切换:变成大写: ctrl + shift + x
20.选中的结构的大小写的切换:变成小写: ctrl + shift + y
21.调出生成getter/setter/构造器等结构: alt + shift + s
生成 try-catch 等(surround with)：alt+shift+z
22.快速查找:参照选中的Word快速定位到下一个: ctrl + k
查看类的继承结构图(Show UML Diagram)：ctrl + shift + u

23.查看指定的结构使用过的地方: ctrl + alt + g
24.最大化当前的View: ctrl + m
25.直接定位到当前行的首位: home
26.直接定位到当前行的末位: end

二、面向对象特征二：继承性

继承性（extends）

1.继承的好处：

减少了代码的冗余，提高了代码复用性
便于功能的拓展
为多态性的实现提供了前提

2.继承性的格式：
class A extends B{}
A：子类、派生类、subclass
B：父类、超类、基类、superclass

2.1 体现：一旦子类A继承父类B以后，子类A就获取了父类B中声明的所有的属性和方法。

特别的，父类中声明的 private 的属性或方法，子类继承父类之后，仍然认为获取了父类中私有的结构。
只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

2.2 子类继承父类之后，还可以声明自己特有的属性或方法：实现功能的扩展。
子类和父类的关系，不同于子集和集合的关系。

3.继承性的规定：

一个类可以被多个子类继承。
一个类只能有一个父类。
子父类是相对的概念，允许多层继承。
子类继承父类之后，就获取了父类以及所有间接父类中声明的属性和方法。

4.如果我们没有显示的声明一个类的父类的话，则此类继承于 java.lang.Object 类
意味着，所有的 java 类具有 java.lang.Oject 类声明的功能。

1.eclipse中的Debug

设置断点
按键：F5进入方法，F6一行一行执行，F7从方法中出来，F8结束程序

resume：终止此处断点，进入下一处。
Terminate：强行终止
debug中 step into 功能失灵问题：更换eclipse jre为jdk的。

2.方法重写与权限修饰符

方法重写（override）

1.重写（override/overwrite）：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
2.应用：重写以后，当创建子类对象之后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
3.规定：
		方法的声明：权限修饰符 返回值类型 方法名(形参列表) throws 异常的类型{
						//方法体
					}
		约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法
	①子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
	②子类重写的方法的修饰符不小于父类被重写的方法的权限修饰符
		>特殊情况：子类不能重写父类中声明的private权限的方法
	③返回值类型：
		>父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
		>父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
		>父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同基本数据类型
	④子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型	
	
	子类和父类中的同名同参数的方法要么声明为非static的（考虑重写），要么都声明为static的（不是重写）

面试题：重载与重写的区别

二者的概念
重载：我们可以在同一个类中声明多个方法名相同形参列表不同的方法，彼此之间构成了重载，构造器也可以重载。
重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
重载和重写的具体规则
重载：不表现为多态性
重写：表现为多态性

权限修饰符

四种权限修饰符

在不同包的子类中，不能调用A类中声明为 private 和缺省权限的属性和方法。
在不同包下的不同类（非子类）只能调用A类中的 public 权限的属性和方法。

3.super关键字的使用

1.super理解为：父类的
2.super可以用来调用：属性、方法、构造器
3.super的使用：调用属性和方法
	3.1我们可以在子类的方法或构造器中，通过使用"super.属性"或"super.方法"的方式，显示的调用
	父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super."
	3.2特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则
	必须显示的使用"super.属性"的方式，表明调用的是父类中声明的属性。
	3.3特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，
	则必须显示的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
	
4.super调用构造器
	4.1我们可以在子类的构造器中显示的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
	4.2"super(形参列表)"的使用，必须声明在子类构造器的首行
	4.3我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现
	4.4在构造器的首行，没有显示的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super();
	4.5在类的多个构造器中，至少有一个类的构造器中使用"super(形参列表)"，调用父类中的构造器

4.子类对象实例化全过程

1.从结果上看：

子类继承父类以后，就获取了父类中声明的属性和方法；
创建子类对象，在堆空间中，就会加载所有父类中声明的属性。

2.从过程上看：

当我们通过子类的构造器创建子类对象时，我们一定会直接或间接地调用其父类构造器，
进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的参构造器为止。正因为加载过所
有的父类结构，所以才可以看到内存中有父类的结构，子类对象才可以进行调用。

明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，及即为new的子类对象。

三、面向对象特征三：多态性

多态性（Polymorphism）

理解多态性：可以理解为一个事物的多种形态。
何为多态性：
对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）
多态性的使用：虚拟方法使用
有了对象的多态性以后，我么在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。
总结：编译，看左边；运行，看右边。
多态性的使用的前提：
①类的继承关系
②方法的重写
对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
向上转型：多态

面试题

谈谈对多态性的理解？

实现代码的通用性。
Object类中定义的public boolean equals(Object obj){}
JDBC：使用java程序操作（获取数据库连接、CRUD）数据库
抽象类、接口的使用

多态是编译时行为还是运行时行为？
多态性是一个运行时行为。

1.向下转型

1.为什么使用向下转型？

有了对象的多态性以后，内存中实际上是加载了子类特有的属性和方法的，但是由于变量声明为父类类型，导致编译时，只能调用父类中声明的属性和方法。子类特有的属性和方法不能调用。
如何才能调用子类特有的属性和方法？使用向下转型

2.如何实现向下转型：使用强制类型转换符

Person p=new Student();//此时p并不能调用Student中重写的方法。
Student stu=(Student)p;//此时就可以了

3.使用时的注意点：

①使用强转时，可能会出现 ClassCastException 的异常。
②为了避免向下转型时出现 ClassCastException 的异常，我们在向下转型之前，先用 instanceof 进行判断，一旦返回 true，就进行向下转型。如果返回false，不进行向下转型。

2.instanceof关键字的使用

a instanceof A：
判断对象a是否是类A的实例，如果是，返回true，如果不是，返回false。

使用情景：为了避免向下转型时出现ClassCastException的异常，我们在向下转型之前，先用
instanceof进行判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

②如果a instanceof A返回true，则a instanceof B也返回true，其中类B是类A的父类。

③要求a所属的类与类A必须是子类和父类的关系，否则编译错误。

在这里插入图片描述

如果有收获！！！希望老铁们来个三连，点赞、收藏、转发。
创作不易，别忘点个赞，可以让更多的人看到这篇文章，顺便鼓励我写出更好的博客