mobile wallpaper 1mobile wallpaper 2mobile wallpaper 3mobile wallpaper 4
2161 字
6 分钟
面向对象编程大观
2026-09-18

程序入口#

语言是否必须固定入口
C++必须有全局 main()
Java必须有类中的 public static void main(...) 才能作为普通程序入口
Python不必须有 main(),脚本可以直接从上到下执行
  • cpp的程序入口必须是独立的全局main()函数,负责启动对象和调用程序逻辑
  • java只有方法的概念,没有裸露的/脱离类存在的函数,因此需要主函数作为程序入口
  • python并不强调入口概念

Java主入口

public class demo {
public static void main(String[] args){
System.out.println();
}
}

c++主入口

int main(){
std::cout<<"";
return 0;
}

Python主入口

def main():
print()
if __name__ == "__main__":
main()

面向对象#

对象:把相关 数据 和 方法 组织成为一个整体看待 面向对象: 利用对象进行软件开发

类#

用来限定/描述实例对象

类的普通对象创建#

语言普通对象创建
Java通常 new Student()
C++Student s; 或 new Student()
PythonStudent(),内部调用 __new__

其中java中的 new的的工作流程如下: Java new ↓ 创建对象所需空间 ↓ 对象初始化 ↓ 执行构造方法 ↓ 得到对象引用

例如:

Student s = new Student();

可以拆成:

Student s → 声明引用变量
new → 创建对象
Student() → 构造方法完成初始化
= → 让 s 引用该对象

对象自身引用#

一般情况下,类的方法里面可能会定义与属性变量名相同的变量名,那么此时就会和类属性冲突,一般会符合就近原则,即方法中默认认为同名的变量的意义是局部定义的意义,通过关键字,以便区分同名的属性和局部变量。Java c++ 都是用this,并且不需要在代码中写出来,而python的self需要在方法的参数表里面写出来,本质都是在类的方法内部明确指向当前对象的成员,解决局部变量、参数和成员变量同名时的歧义。

public class Student {
private int age;
public void setAge(int age){
this.age=age;
}
}

封装#

封装:隐藏对象内部的实现细节,只向外暴露必要、统一、受控的访问接口。

也可以说

封装=隐藏实现+暴露接口+控制访问\boxed{封装 = 隐藏实现 + 暴露接口 + 控制访问}

封装可以带来两个好处:降低耦合和便于修改内部实现。只要对外接口不变,内部实现可以随便调整。

封装层次(针对java)#

方法
↓
类 / 接口
↓
包
↓
模块 / 系统

是一种由小到大的封装层次,其中:

  • 方法:封装一段具体功能或行为的实现细节。
  • 类:封装对象的状态(属性)和行为(方法)。
  • 接口:主要封装的是一组行为规范/能力约定,强调“能做什么”,而不是“怎么做”。
  • 包(package):把相关的类和接口组织在一起,同时配合 public、包访问权限等形成更大的可见性边界。

Java#

修饰符#

控制修饰符/访问权限修饰符#

通过 控制修饰符 来控制类、方法、成员变量等的可见性和访问范围

修饰符同一个类同一个包不同包的子类不同包的普通类
public✅✅✅✅
protected✅✅✅❌
不写(default)✅✅❌❌
private✅❌❌❌

private 外界只是不能显式调用对应的方法,变量等,通过其他给定的方法等可以间接使用或者修改private修饰的方法和变量

非访问修饰符#

修饰符作用
static声明静态成员,属于类
final限制重新赋值、重写或继承
abstract声明抽象类或抽象方法
synchronized控制多线程同步
volatile保证变量的可见性等并发语义
transient序列化时排除相应字段

封装#

构造方法/构造器/构造函数#

特点#

  1. 方法名与类名相同,大小写也要一致
  2. 没有返回值类型,连void都没有
  3. 没有具体返回值
  • 如果没有定义构造方法,编译器会给出一个默认的无参数调用方法
  • 如果自己写了任意构造方法,系统将不再提供默认构造方法

继承#

Java#

Java中的继承,描述的是事物间的所属关系,通过继承,可以使多种事物之间形成一种关系体系。

利用继承关系将多个类的相同内容抽取到单独的一个类中,抽取出的类被称为父类,而基于父类构建出来的新类被称为子类。通过继承,子类会自动拥有父类的所有非私有属性和方法。

继承使用关键字extends来实现,语法格式如下:

class 父类{
……
}
class 子类 extends 父类{
……
}

注:#

  • 在Java中,类只支持单继承,不支持多继承。也就是说,一个类只能有一个直接父类。
  • 子类可以继承父类的公共成员(public)和受保护的成员(protected),但不能继承私有成员(private)。
  • Java支持多层继承,即类的父类可以继承其他类。例如,C类继承B类,而B类可以继承A类。
class A{}
class B extends A{}       //B类继承A类,B类是A类的子类
class C extends B{}       //C类继承B类,C类是B类的子类class A{}
  • 在Java中,子类和父类是一种相对的概念,一个类既可以是某个类的父类,也可以是另一个类的子类。

多态#

Java#

  • 编译时多态/静态多态
    1. 方法重载:方法名相同,参数列表不同
      • 参数个数/类型/排列数序不同
  • 运行时多态/动态多态 2. 方法重写

内部类#

在Java中有一种特殊的类,它被定义在其他类的内部,这样的类称为内部类,内部类所在的类称为外部类。根据定义位置、访问权限和定义方式的不同,Java中的内部类主要分为成员内部类、局部内部类、匿名内部类和静态内部类。

成员内部类#

  • 成员内部类概念:定义在一个类的成员位置的类。
  • 访问权限:成员内部类可以访问外部类的所有成员变量和方法,包括 private 成员。并可以有自己的成员变量和方法
  • 创建内部类对象:先创建外部类的对象,然后再通过外部类的对象创建内部类对象。
  • 定义位置:定义在外部类中,与成员变量、成员方法同级。
  • 对象依赖:成员内部类对象依赖于一个外部类对象。
  • 外部调用:只要满足访问权限,可以在外部创建和使用成员内部类对象。
外部类名.成员内部类名 变量名 = 外部类对象.new 成员内部类名();

例子#

class DeviceController{
private String controllerName;
public DeviceController(String controllerName){
this.controllerName = controllerName;
}
public void connectToDevice(){
System.out.println("connected successfully...");
}
class Device{
private String deviceName;
public Device(String deviceName){
this.deviceName = deviceName;
}
public void powerOn(){
System.out.println(controllerName +
" controlled " + deviceName + " to open!");
}
public void powerOff(){
System.out.println(controllerName +
" controlled " + deviceName + " to off!");
}
}
}
public class Example16 {
public static void main(String[] args){
DeviceController controller = new DeviceController("Device Controller");
controller.connectToDevice();
DeviceController.Device device = controller.new Device("Dv.1");
device.powerOn();
device.powerOff();
}
}

局部内部类#

  • 局部内部类概念:是定义在方法中的类,它和局部变量一样,只在方法中有效。
  • 访问权限:局部内部类可以访问外部类的所有成员变量和方法,而局部内部类中变量和方法只能在局部内部类所在的方法中被访问。
  • 创建局部内部类对象:局部内部类只能在方法内部或作用域内部被实例化,创建局部内部类的语法格式与普通类相同。
  • 局部内部类的参数表的参数(局部参数)不能被二次修改,或者说保持final的性质

例子#

class Calculator{
public void performCalculation(int num1,int num2, char operation){
class OperationCalculator{
public int add(){
return num1+num2;
}
public int sub(){
return num1-num2;
}
}
OperationCalculator calculator = new OperationCalculator();
if(operation=='+'){
System.out.println("result: "+ calculator.add());
}
else if(operation=='-'){
System.out.println("result: " + calculator.sub());
}
else{
System.out.println("Error! ");
}
}
}
public class Example17 {
public static void main(String[] args){
Calculator calculator = new Calculator();
calculator.performCalculation(5,3,'+');
calculator.performCalculation(5,3,'-');
calculator.performCalculation(5,3,'*');
}
}

匿名内部类#

  • 匿名内部类概念:没有名字的内部类,它通常用于一次性地定义一个类并创建其对象。匿名内部类不需要显式地定义一个类,而是在创建对象的同时定义这个类。匿名内部类通常作为方法的参数、返回值或变量的值使用。
  • 创建匿名内部类的语法格式:
new 继承的父类名或实现的接口名(){
    // 匿名内部类的成员变量、方法等
};
  • 通过上述语法格式创建了一个匿名内部类,并同时创建了该类的对象。这个匿名内部类继承了指定父类或实现了指定接口。
interface Swim{
void swimming();
}
public class Example18 {
// public static void main(String[] args){
// String name = "Tom";
// new Swim(){
// @Override
// public void swimming(){
// System.out.println(name + " has learned to swim freestyle..");
// }
// }.swimming();
// new Swim(){
// @Override
// public void swimming(){
// System.out.println(name + " has learned to swim breaststroke..");
// }
// }.swimming();
// }
public static void learnSwim(Swim swim){
swim.swimming();
}
public static void main(String[] args){
String name = "xiao m";
learnSwim(new Swim(){
@Override
public void swimming(){
System.out.println(name + " has learned to swim freestyle..");
}
});
learnSwim(new Swim(){
@Override
public void swimming(){
System.out.println(name + " has learned to swim breaststroke..");
}
});
}
}

静态内部类#

  • 静态内部类概念:特殊的成员内部类,它使用static关键字修饰,与类的静态成员类似,都属于外部类本身,而不属于外部类的实例。
  • 访问权限:静态内部类只能访问外部类的静态成员,通过外部类访问静态内部类的成员时,可以跳过外部类直接访问。
  • 创建静态内部类对象的格式:
外部类名.静态内部类名 变量名 = new 外部类名.静态内部类名();
class ManageSystem{
static String systemLog = "Enter the Management System";
static class DataSave{
void printDataLog(){
System.out.println(systemLog);
System.out.println("Export data log");
}
}
}
public class Example20 {
public static void main(String[] args){
ManageSystem.DataSave dataSave = new ManageSystem.DataSave();
dataSave.printDataLog();
}
}
分享

如果这篇文章对你有帮助,欢迎分享给更多人!

面向对象编程大观
https://blog.hydrodyio.xyz/posts/面向对象编程大观/
作者
Hydroiody
发布于
2026-09-18
许可协议
CC BY-NC-SA 4.0

部分信息可能已经过时

目录