面向对象

约 7617 字大约 25 分钟

2026-03-19

1、面向对象

（1）与面向过程对比

面向过程：分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候依次调用。
面向对象：把构成问题的各个事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙一个事物在整个解决问题的步骤中的行为。

2、类及类的成员

2.1 类和对象

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

面向对象程序设计的重点是类的设计。设计类，就是设计类的成员（包含类的属性和方法）。

补充：几个概念的使用说明

属性 = 成员变量 = 域、字段= field
方法 = 成员方法 = 函数 = method
创建类的对象 = 类的实例化 = 实例化类

2.1.1 对象的创建与对象的内存解析

典型代码：

Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1; //没有新创建一个对象，共用一个堆空间中的对象实体。相当于引用

Java运行时的数据区包括：（其中前两个是线程共享的）

存储已被虚拟机加载的类信息、常量、静态变量、即编译器编译后的代码等据。
存放对象实例，几乎所有对象实例都在这里分配内存。
描述的是Java方法执行的内存模型：每个方法在执行的同时会创建一个StackFrame（方法运行时的基础数据结构）用于存储局部变量表、操作数栈、动态连接、方法出口等信息。
本地方法栈（Native Method Stack）与虚拟机类似，不过则为虚拟机使用的到Native方法服务。

（有的虚拟机如SunHotSpot会把本地方法栈个虚拟机合二为一）

程序计数器（Program Counter Register）可看作当前线程所执行的字节码的行号的标识器。

2.2 属性

2.2.1 与局部变量的对比

1、相同点

定义变量的格式：数据类型变量名 = 变量值;
变量都其对应的作用域
都可以被final修饰，定义为常量

2、不同点

1）在类中声明的位置的不同

属性：一般称为类的全局属性，直接定义在类的一对{}内，与方法同级
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2）关于权限修饰符的不同

属性：可以在声明属性时，指明其权限，使用权限修饰符。
- public： Java语言中访问限制最宽的修饰符，一般称之为“公共的”。被其修饰的类、属性以及方法不仅可以跨类访问，而且允许跨包（package）访问。
- private:：Java语言中对访问权限限制的最窄的修饰符，一般称之为“私有的”。被其修饰的类、属性以及方法只能被该类的对象访问，其子类不能访问，更不能允许跨包访问。
- protected：介于public 和 private 之间的一种访问修饰符，一般称之为“受保护的 ”。被其修饰的类，属性以及方法只能被类本身的方法及子类访问，即使子类在不同的包中也可以访问。体现了封装性。
  default：即不加任何访问修饰符，通常称为“默认访问模式”。该模式下，只允许在同一个包中进行访问。
作用域当前类同包下子孙类其他包
public ✔ ✔ ✔ ✔
protected ✔ ✔ ✔
default ✔ ✔
private ✔
局部变量：不可以使用权限修饰符。


作用域	当前类	同包下	子孙类	其他包
public	✔	✔	✔	✔
protected	✔	✔	✔
default	✔	✔
private	✔

3）在内存中加载的位置：

属性：加载到堆空间中（非static）
局部变量：加载到栈空间

4）静态变量

属性可以被static修饰，意为静态变量
局部变量不可以被static修饰

2.3 方法

1）方法：描述类应该具有的功能。

2）方法的参数概念

形参：形式上的参数，方法定义时，声明的小括号内的参数，直到调用时将实参传给形参。
实参：方法调用时，实际传递给形参的数据。

3）可变个数形参

// 可变个数形参的格式：数据类型 ... 变量名
public void method(String ...v) {
    
}

当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个，2个，...
可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。
换句话说，二者不能共存。
可变个数形参在方法的形参中，必须声明在末尾
可变个数形参在方法的形参中,最多只能声明一个可变形参。

2.3.1 重载(overloading)与重写(override 或 overwrite)

1）重载

定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

总结："两同一不同"：同一个类、相同方法名（返回值相同）参数列表不同：参数个数不同，参数类型不同

2）重写(override 或 overwrite)

定义：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作.

应用：重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，

重写的规则：

子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
返回值类型：
- 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
- 父类被重写的方法的返回值类型是基本数据类型或void，那么子类也只能是这些类型

3）区别

多态

重载：不表现为多态性。

重写：表现为多态性。

重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。

定义

重载的定义：Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。

重写的定义：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。

绑定状态

对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

而对于重写（多态）而言，只等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称

为“晚绑定”或“动态绑定”。

2.3.2 构造器（构造方法）

1）构造器的作用：

创建对象
初始化对象的信息

2）构造器的使用说明：

如果没显式的定义类的构造器的话，则
一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器。

定义构造器的格式：

权限修饰符  类名(形参列表) {
	// 初始化对象的信息
}

一个类中，至少会有一个构造器，多个构造器，彼此构成重载
如果构造器没有显示的为字段设定初始值，那么会被自动赋值：数值为0，布尔为false，对象为null。

可以用this(...)调用同类下的其它构造函数

public Employee(int age) {
    // calls Employee(String, Integer)
	this(Employee("xiaoming", age));
}

JavaBean的概念

简单的说是一个可重用的组件，在MVC设计模型中是model，又叫模型层

所谓JavaBean，是指符合如下标准的Java类：

类是公共的
有一个无参的公共的构造器
有具体的属性和对应的get、set方法

2.4 代码块（初始化块）

代码块的作用：用来初始化类、对象的信息

分类：静态代码块 vs 非静态代码块
注意：代码块要是使用修饰符，只能使用static

静态代码块

作用：初始化类的信息

特点：

如果一个类中定义了多个静态代码块，则按照声明的先后顺序执行
静态代码块的执行要优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构

非静态代码块：

作用：可以在创建对象时，对对象的属性等进行初始化

特点：

如果一个类中定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法
实例化子类对象时，涉及到父类、子类中静态代码块、非静态代码块、构造器的加载顺序： 由父及子，静态先行。

2.5 内部类

1.定义：Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类。

2.内部类的理解

一方面，作为外部类的成员：

能调用外部类的结构。
可以被static修饰（静态内部类）。
可以被4种不同的权限修饰。

另一方面，作为一个类：

类内可以定义属性、方法、构造器等。
可以被final修饰，表示此类不能被继承。
可以被abstract修饰（抽象的内部类）

3.内部类的分类

匿名内部类！！！

匿名内部类，顾名思义，就是不知道这个类到底是什么名字，也就是不知道类名。

它的本质是一个

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，

那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。

本质是一个实现了抽象父类中的抽象方法的匿名子类对象。

//定义一个抽象类
abstract test1{
    public abstract void show();
}

class test2{
    public static void main(String[] args) {
        //创建一个匿名内部类
        //本质是一个实现了 抽象父类中的抽象方法 的匿名子类对象。
        new test1() {
            @Override
            public void show() {
                System.out.println("123");
            }
        }.show();
    }
}

本质是一个实现了父接口中定义的方法的匿名子类对象。

//定义一个接口
interface test1{
    public void show();
}

class test2{
    public static void main(String[] args) {
        //创建一个匿名内部类
        //本质是一个实现了 父接口中定义的方法 的匿名子类对象。
        new test1() {
            @Override
            public void show() {
                System.out.println("123");
            }
        }.show();
    }
}

注意：匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】

强调：匿名内部类和匿名对象不是一回事！！！

成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式：

class A {
    ...
    //成员内部类
    class B {     
        ...
    }
}

局部内部类（方法内、代码块内、构造器内）

局部内部类是定义在一个方法或者一个作用域里面的类，

它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

class Outer{
    public void testInnerClass(){
        //声明在方法或其作用域内的类
        class Inner{
            ...
        }
    }
}

注意: 局部内部类就像是方法里面的一个局部变量一样，是不能被权限修饰符和 static 修饰的。

静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法

3、三大特征

特征一：封装性

为什么要引入封装性？

我们程序设计追求“高内聚，低耦合”。

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅对外暴露少量的方法用于使用。

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

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

封装性思想体现

体现一：将类的属性私有化(private)，同时提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

体现二：不对外暴露的私有的方法

体现三：单例模式（将构造器私有化）

体现四：如果不希望类在包外被调用，可以将类设置为默认的。

Java规定的四种权限修饰符

权限从小到大顺序为：private < 缺省 < protected < public
具体的修饰范围：

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

特征二：继承性

为什么要有类的继承性？(继承性的好处）

减少了代码的冗余，提高了代码的复用性
便于功能的扩展
为之后多态性的使用，提供了前提

继承性的格式：class A extends B{}

A: 子类、派生类、subclass
B: 父类、超类、基类、superclass

子类继承父类以后有哪些不同？

一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
- 特别的，父类中声明为private的属性或方法，子类继承父类以后，也认为是获取了父类中私有的结构。
只因为封装性的影响，使得子类不能调用父类的私有结构而已。
子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。

Java中继承性的说明：

类的单继承性：一个类只能有一个父类。
父子类是相对的概念。

java.lang.Object类的理解

如果我们没显式的声明一个类的父类的话，则此类继承于 Object 类
所有的java类（除java.lang.Object类之外都直接或间接的继承于 Object 类
意味着，所有的java类都具有 Object 类声明的功能。

关于子类对象的初始化（

在创建子类对象时，不仅要对自身成员变量初始化，而且还要对父类的成员变量初始化。

父类中静态成员变量和静态代码块

----> 子类中静态成员变量和静态代码块

----> 父类中普通成员变量和代码块，父类的构造函数

----> 子类中普通成员变量和代码块，子类的构造函数

其中静态变量、静态代码块这两个加载级别相同，按声明顺序加载。

特性三：多态性

多态性的理解

可以理解为一个事物的多种形态。

比如说一个事物既可以是它本身的状态，也可以是它父类的状态。

何为多态性

对象的多态性：父类的引用指向子类的对象（或子类的对象赋给父类的引用）

变量声明的是父类，实际指向的是子类的一个对象

比如：Object obj = new String();

此时的 obj 既有 String类的状态，也有 Object类的状态

多态性的使用：虚拟方法调用

有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。 总结：编译，看左边的类型；运行，看右边的类型。

多态性的使用前提

① 类的继承关系 ② 方法的重写

多态性使用的注意点：

对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）

关于向上转型和向下转型！！！

向上转型：多态

向下转型：

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

使用时的注意点：

① 使用强转时，可能出现ClassCastException的异常。

② 为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，

一旦返回true，就进行向下转型。如果返回false，不进行向下转型。

instanceof的使用：

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

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

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

面试题

谈谈你对多态性的理解？

实现代码的通用性。
Object类中定义的public boolean equals (Object obj)
JDBC:使用 Java程序操作(获取数据库连接、CRUD)数据库(MySQL、Oracle、DB2、SQL Server)
抽象类、接口的使用肯定体现了多态性。（抽象类、接口不能实例化）

多态是编译时行为还是

4、关键字

this

this可以调用当前对象的：属性、方法、构造器

1、this调用属性、方法 this.xxx

我们可以使用"this.属性" 或 "this.方法" 的方式，调用当前对象属性或方法。

但是，通常情况下，我们都择省略"this."。

特殊情况下，如果[ 构造 ]方法的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。比如构造器为属性赋值时：this.name = name ...

2、this调用构造器 this(形参列表)

我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中的其他构造器
构造器中不能通过"this(形参列表)"方式调用本身。
如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"。
一个构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器。

super

super可以调用父类中的：属性、方法、构造器

1、super调用属性、方法

在子类的方法或构造器中，我们可以使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的

属性或方法。

但是，通常情况下，我们习惯省略"super."

特殊情况：当子类和父类中定义了同名的 属性 / 方法 时，如果要在子类中调用父类中声明的属性/方法，

则必须显式的使用"super.属性 / 方法 "的方式，表明调用的是父类中声明的属性 / 方法 。

2、super调用构造器

我们在类的构造器中，可以显式的使用“super(形参列表)”方式，调用父类中声明的指定的构造器；
在构造器的首行，没显式的声明“this(形参列表)”或“super(形参列表)”，
则默认调用的是父类中空参的构造器：super()；
在类的多个构造器中，至少一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器；

static

可以用来修饰的结构：主要用来修饰类的内部结构如：属性、方法、代码块、内部类

1、static修饰属性：静态属性（类属性）

属性，是否使用static修饰，又分为：静态属性 vs 非静态属性(实例变量)

实例变量：我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。

静态变量：我们创建了类的多个对象，多个对象共享同一个静态变量。

静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用
静态变量的加载要早于对象的创建。
由于类只会加载一次，则静态变量在内存中也只会存在一份：存在方法区的静态域中。

2、static修饰方法：静态方法（类方法）

静态方法的说明：

随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
静态方法中，只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性

static的注意点

在静态的方法内，不能使用this关键字、super关键字
关于静态属性和静态方法的使用，可以从生命周期的角度去理解。

final

可以用来修饰：类、方法、变量

final修饰类、方法、变量的说明

final 用来修饰一个类:此类不能被其他类所继承。比如：String类、System类、StringBuffer类

final 用来修饰方法：表明此方法不可以被重写。比如：Object类中getClass();

final 用来修饰变量：此时的"变量"就称为是一个常量。

final修饰属性：可以考虑赋值的位置：显式初始化、代码块中初始化、构造器中初始化
final修饰局部变量： 尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给
常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。

static final 用来修饰属性：全局常量

面试题：final、finally 和 finalize 的区别

abstract

可以用来修饰：类、方法

1、abstract修饰类：抽象类

抽象类的定义：抽象就是从多个事物中将共性的，本质的内容抽取出来。

此类不能实例化
抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作 --->抽象的使用前提：继承性

2、abstract修饰方法：抽象方法

抽象方法只方法的声明，没方法体（与接口声明的方法类似，但没有接口 abstract关键字修饰）
包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
若子类重写了父类中的所的抽象方法后，此子类方可实例化
若子类没重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰

应用：模板方法的设计模式

在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。

但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

比如：**JavaWeb 中 dao层和 web层中 BaseDao 和 BaseServlet 抽象类的设计。

interface

1、接口使用interface来定义

Java接口的定义：是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

2、Java中，接口和类是并列的两个结构。

3、如何定义接口：定义接口中的成员

JDK7及以前：只能定义全局常量和抽象方法
全局常量：public static final的.但是书写时，可以省略不写
抽象方法：public abstract的
JDK8：除了定义全局常量和抽象方法之外，还可以定义

3、接口中不能定义构造器的！意味着接口不可以实例化。

4、Java开发中，接口通过让类去实现（implements）的方式来使用。

如果实现类覆盖了接口中的所抽象方法，则此实现类就可以实例化，

如果实现类没覆盖接口中所的抽象方法，则此实现类仍为一个抽象类。

5、Java类可以实现多个接口 --> 弥补了Java单继承性的局限性。

6、接口与接口之间可以继承，而且可以多继承。

Java8中关于接口的新规范

知识点1：接口中定义的静态方法，只能通过接口来调用。

知识点2：通过实现类的对象，可以调用接口中的默认方法。

如果实现类重写了接口中的默认方法，调用时，仍然调用的是重写以后的方法

知识点3：如果子类(或实现类)继承的父类和实现的接口中同时声明了同名同参数的默认方法，那么子类在

没重写此方法的情况下，默认调用的是父类中的同名同参数的方法。---> 类优先原则

知识点4：如果实现类实现了多个接口，而这多个接口中定义了相同的（即同名同参数的）默认方法，

那么在实现类没重写此方法的情况下，报错。---> 接口冲突

知识点5：如何在子类(或实现类)的方法中调用父类、接口中被重写的方法（使用super）

public void myMethod(){
    method();//调用自己定义的重写的方法
    super.method();//调用的是父类中声明的
    //调用接口中的默认方法
    CompareA.super.method();
    CompareB.super.method();
}

面试题：说说抽象类和接口异同？

相同点：不能实例化；都可以包含抽象方法的。

不同点：

1）把抽象类和接口(java7,java8,java9)的定义、内部结构解释说明

2）类：单继承性接口：多继承

   类与接口的关系：多实现

在开发中抽象类可以将一些统一的方法定义为一套规范，

然后子类可以通过继承抽象类来调用抽象类中的方法，实现对应功能。

比如：JavaWeb中的 BaseDao 和 BaseServlet 抽象类

package/import

1、package的使用

使用包的主要原因是确保类名的唯一性。假如两个程序员不约而同地建立了 Employee类。只要将这些类放置在不同的包中，就不会产生冲突。

为了保证包名的绝对唯一性，要用一个因特网域名（这显然是唯一的）以逆序的形式作为包名，然后对于不同的工程使用不同的子包。例如，考虑域名baidu.com，如果逆序来写，就得到了包名com.baidu然后可以追加一个工程名pan，如com.baidu.pan。如果再把Employee类放在这个包里，那么这个类的“完全限定”名就是 com.baidu.pan.Employee。

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

2、import的使用

在源文件中显式的通过import结构导入指定包下的类、接口