Java整理（4）面向对象——中级篇（韩顺平课程）

一、包

1. 包的作用

• 区分相同名字的类（所在的包，也就是文件夹不同）
• 当类很多时，可以管理类（把功能相似的类放一个包中）
• 控制访问范围

2. 基本语法

• package：是个关键字，表示打包
• 例如：
  package com.hspedu
  com.hspedu：表示包名，以文件形式表示com文件夹下面有个hspedu文件夹，小圆点表示下一级目录。

3. 包的本质

其实际上就是创建不同的文件夹/目录来保存类文件。

4. 包的命名

4.1 命名规则

只能包含数字、字母、下划线、小圆点，但是不能用数字开头，而且不能是关键字或保留字。

4.2 命名规范

一般是小写字母+小圆点
一般是com.公司名.项目名.业务模块名

5. java中常用的包

• java.lang.* //lang包是基本包，默认引入，不需要再引入
• java.util.* //util包，系统提供的工具包，工具类，例如：Scanner
• java.net.* //网络包，用于网络开发
• java.awt.* //java的界面开发，及GUI

5. 注意事项

• package的作用是声明当前类所在的包，需要放在类文件的最上面，而且一个类文件中最多只有一句package XX。
• import指令放在package指令的下面，可以有多句且没有顺序要求。

5. 导入包

5.1 语法

• import 包名；
  上述主要目的是要使用该包下的所有类。
• import 包名.类名;
  上述主要目的是要使用该报下特定的类，建议使用这种方法。

5.2 举例

例如：
import java.util.*; //指将java.util包下所有的类都引入
import java.util.Scanner；//指只引入一个类，及Scanner类

二、访问修饰符

1. 基本介绍

java提供四种访问控制修饰符号，用于控制方法或属性（成员变量）的访问权限（范围）。

• 公开级别：用public修饰，对子类和同一个包中的类公开
• 受保护级别：用protect修饰，对子类和同一包中的类公开
• 默认级别：没有修饰符号，向同一个包的类公开
• 私有级别：用private修饰，只有类本身可以访问，不对外公开
  

2. 注意事项

• 修饰符可以用来修饰类中的属性，成员方法以及类
• 只有默认和public才能修饰类，并且遵循上述访问权限的特点
• 成员方法的访问规则和属性完全一样
• 子类中要注意

三、面向对象编程三大特征

1. 封装

1.1 封装介绍

封装（encapsulation）就是把抽象出的数据（属性）和对数据的操作（方法）封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作（方法），才能对数据进行操作。

1.2 封装的优点

• 隐藏实现细节
• 可以对数据进行验证，保证安全合理

1.3 实现步骤

（1）将属性进行私有化（private），以达到非本类不能直接访问到该属性，即透明化处理。
（2）提供一个公共的（public）set方法，用于对传递的数据进行验证，进而赋值与该属性。
（3）提供一个公共的（public）get方法，用于获取属性的值。

1.4 对属性进行set、get的方法快速生成

（1）在程序编辑区（所要生成该方法的类中），右键点击->选择Generate

（2）选择Getter and Setter 或先选择Getter，再选择Setter

（3）选择所要生成Setter和Getter的属性，点击OK

（4）效果

2. 继承

2.1 目的

当多个类存在相同的属性（成员变量）和方法时，可以从这些类中抽象处父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends关键字来声明继承父类即可。

2.2 语法

class 子类名 extends 父类名{

}

2.3 规则及叫法

• 子类会自动拥有父类定义的属性和方法
• 父类又叫超类或基类
• 子类又叫派生类

2.4 优势

• 代码的复用性提高了
• 代码的扩展性和维护性提高了

2.5 注意事项

（1）子类继承了所有的属性和方法，非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访问，要通过父类提供公共的方法去访问。
（2）子类必须调用父类的构造器， 完成父类的初始化。
（3）当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过。
（4）如果希望指定去调用父类的某个构造器，则显式的调用一下 : super(参数列表)。
（5）super 在使用时，必须放在构造器第一行(super 只能在构造器中使用)。
（6）super() 和 this() 都只能放在构造器第一行，因此这两个方法不能共存在一个构造器。
（7）java 所有类都是 Object 类的子类, Object 是所有类的基类。
（8）父类构造器的调用不限于直接父类！将一直往上追溯直到 Object 类(顶级父类)。
（9）子类最多只能继承一个父类(指直接继承)，即 java 中是单继承机制。
（10）不能滥用继承，子类和父类之间必须满足 is-a 的逻辑关系。
（11）加载类信息时，先加载父类，然后加载子类信息。

2.6 友情提示

（1）继承规则与修饰符规则不同，子类访问时，要同时遵循这两种规则。继承规则（子类不能继承父类的私有属性或方法的规则）；修饰符规则（指修饰访问符的规则）。
（2）访问修饰符：所遇情况有，同类、同包、子类、不同包，共这四种类型。但是它们可以交叉出现一些情况。例如：同包下的子类、不同包下的子类的情况。此时要遵循优先级关系：同类>同包>子类>不同包。
（3）若父类中有有参构造器，则子类也必须有构造器，有参/无参都可，且需要用super对父类有参构造器传参。
（4）一个类中有隐式的默认构造器（无参构造器，空函数），即使自己建立个无参构造器（非空函数），也会把隐式默认构造器覆盖掉。除非自己建个显式的无参构造器（空函数），来代替隐式的默认构造器。

2.7 IDEA下继承关系图

• 快捷键：ctrl+h
• 具体位置：代码编辑区的右上靠边部分，画圈地方。
  
• 效果：可以清晰看出当下类的继承关系，同时也验证了java的顶级父类是Object类，所有的类（自定义，Java自带类）都是Object的子类。
  

2.8 继承间的属性查找关系

当调用子类中的属性时，遵循以下规则：
（1）首先看子类是否有该属性
（2）如果子类有这个属性，并且可以访问，则调用子类的该属性
（3）如果子类没有这个属性，接着看父类有没有这个属性（如果父类有该属性，并且可以访问，则调用父类的该属性）
（4）如果父类没有这个属性，就按照（3）的规则，继续找上一级父类，直到Object这个顶级类

在继承中，类的方法同样也有这样的规则，也就是叫方法的重写/覆盖（override，范围在继承之间），注意区分重载（overload，范围在单个类中）。

2.9 继承间的属性内存存放

2.10 方法重写/覆盖（override）

2.10.1 介绍

通俗的说：方法重写就是子类中有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么就称子类的这个方法重写了父类的方法。

2.10.2 注意事项

（1）子类的方法的形参列表，方法名称，要和父类方法的形参列表，方法名称完全一样。
（2）子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类。
（3）子类方法不能缩小父类方法的访问权限（public>protected>默认>private）

2.10.3 方法重写和重载对比

2.11 super关键字

2.11.1 介绍

super 代表父类的引用，用于访问父类的属性、方法、构造器。

2.11.2 语法

（1）访问父类的属性，但不能访问父类的private属性，即super.属性名。
（2）访问父类的方法，但不能访问父类的private方法，即super.方法名(参数列表)。
（3）访问父类的构造器，即super(参数列表)，这条语句只能使用在方法构造器中，而且必须在构造器的第一句中，以及只能出现一句（一次）。

2.11.3 优势

（1）可以调用父类构造器，使得分工明确，且父类存在有参构造器时，子类必须使用父类构造器。
（2）当子类中有和父类中的属性或方法重名时，为了访问到父类的成员，则必须通过super。如果没有重名，则遵循上述属性与方法的重写对应的寻找方法。
（3）super不是单指子类的父类，也可以指父类的父类。

2.11.4 super和this的对比

2.11.5 注意事项

（1）就近原则，如果多个上级类（父类）中都有同名的成员，使用super访问时，则遵循就近原则。
（2）访问父类的构造器，只能使用在方法构造器中，而且必须在构造器的第一句中，以及只能出现一句（一次）。

3. 多态

3.1 介绍

方法或对象具有多种形态。是面向对象的第三大特征之一，多态是建立在封装和继承基础之上的。

3.2 多态体现

3.2.1 方法的多态

方法的重写和重载体现多态

3.2.2 对象的多态

（1）一个对象的编译类型和运行类型可以不一致。
（2）编译类型在定义对象时，就已确定，不能再改变。
（3）运行类型是可以变化的。
（4）编译类型一般指“=”号的左边，而运行类型一般指“=”的右边。
例如：Animal animal1 = new Dog();//Dog是Animal的子类，则变量animal1的编译类型是Animal，而运行类型是Dog。

3.3 多态实现的前提

两个对象（类）存在继承关系。

3.4 多态的向上转型

3.4.1 本质

父类的引用指向了子类的对象。

3.4.2 语法

父类类型 引用名（变量名）= new子类类型()；

3.4.3 特点

（1）可以调用父类中的所有成员方法，但需遵循访问权限。
（2）不能调用子类中特有成员方法，意思说可以调用子类方法对父类方法的重写方法。
（3）调用成员那些成员方法是由编译类型决定的。
（4）调用方法时，按照从子类(运行类型)开始查找方法。
（5）总的来说，多态的向上转型，能调用的函数名，看父类，若有重写的情况，则调用子类中的方法。

3.5 多态的向下转型

3.5.1 前提

必须先进行向上转型后，才能向下转型。

3.5.2 本质

使得该引用（变量）能够调用子类中特有的方法。

3.5.3 语法

子类类型 引用名 =（子类类型）父类引用;//进行了强制转换

3.6 多态中的属性（成员变量）

述只是针对于成员方法，跟属性（成员变量）无关，属性只与编译类型有关，也就是说向上转型时，所只能使用父类中的属性。

3.7 java的动态绑定机制

（1）当调用对象方法时，该方法会和该对象的运行类型（内存地址）绑定。
（2）当调用对象属性时，则无动态绑定机制，也就是说，在哪里声明，就在哪里使用。
例如：

3.8 多态的应用

3.8.1 多态数组

定义一个类型为父类类型的数组，里面保存的实际元素类型为子类类型。

3.8.2 多态参数

方法定义的形参为父类类型，而实参类型则为子类类型。