用Java实现基于消息传递的OOP对象模型

最新推荐文章于 2024-07-17 12:54:09 发布
最新推荐文章于 2024-07-17 12:54:09 发布
阅读量257 收藏
点赞数
分类专栏： Java 文章标签： OOP Java 面向对象
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zssrxt/article/details/103334687
版权

0. 前言

首先声明，本文使用Java所实现OOP对象模型仅包含类、对象、访问控制（private、protected、public三种级别）、多继承（通过优先级来解决冲突）、方法调用等功能，不包含语法，仅用于说明，不可用于工程。

1. 实现效果

LClass aClass = define("A")
        .addField("name")
        .addField(PUBLIC, "age")
        .addField(PROTECTED, "color")
        .addField(PRIVATE, "id")
        .addMethod("showId", thisPointer -> args -> {
            System.out.println(thisPointer.get("id"));
            return null;
        })
        .addMethod(PUBLIC, "setId", thisPointer -> args -> {
            thisPointer.set("id", args[0]);
            return null;
        })
        .addMethod(PROTECTED, "changeNameAndPrint", thisPointer -> args -> {
            thisPointer.set("name", args[0]);
            System.out.println("name change to " + thisPointer.get("name"));
            return null;
        })
        .addMethod(PRIVATE, "changeColor", thisPointer -> args -> {
            thisPointer.set("color", args[0]);
            return null;
        }).end();

LObject aObject = aClass.newInstance();
System.out.println("a object:" + aObject);
aObject.set("name", "ZhouShenshen");
aObject.set("color", "ZhouShenshen");
aObject.set("id", "ZhouShenshen");
aObject.invoke("changeNameAndPrint", "XiaoMing");
aObject.invoke("setId", "1234");
aObject.invoke("showId");
System.out.println("a object:" + aObject);

LClass bClass = define("B", aClass)
        .addMethod("setName", thisPointer -> args -> {
            thisPointer.set("name", args[0]);
            return null;
        })
        .addMethod("setNameAndPrint", thisPointer -> args -> {
            thisPointer.invoke("changeNameAndPrint", args[0]);
            return null;
        })
        .end();
LObject bObject = newInstance(bClass);
bObject.invoke("changeNameAndPrint", "XiaoHua");
bObject.invoke("setNameAndPrint", "XiaoHua");
bObject.invoke("setName", "DingDing");

System.out.println("b object:" + bObject);

2. 代码

2.1 类的实现

类中包含了该类的名称、超类列表、成员集和方法集，定义的过程使用建造者模式实现，代码如下：

public class LClass {
    private final String name;
    private final List<LClass> superClasses;
    private final Map<String, LField> fieldMap;
    private final Map<String, LMethod> methodMap;

    public LClass(String name, List<LClass> superClasses, Map<String, LField> fieldMap, Map<String, LMethod> methodMap) {
        this.name = name;
        this.superClasses = superClasses;
        this.fieldMap = fieldMap;
        this.methodMap = methodMap;
    }

    List<LClass> getSuperClasses() {
        return superClasses;
    }

    public Map<String, LField> getFieldMap() {
        return fieldMap;
    }

    public String getName() {
        return name;
    }

    public Map<String, LMethod> getMethodMap() {
        return methodMap;
    }

    public LObject newInstance() {
        return new LObject(this);
    }

    public static LObject newInstance(LClass lClass) {
        return lClass.newInstance();
    }

    public static Builder define(String name, LClass... superClasses) {
        return new Builder(name, superClasses == null ? Collections.emptyList() : Arrays.asList(superClasses));
    }

    public static final class Builder {
        private final String name;
        private final List<LClass> superClasses;
        private final Map<String, LField> fieldMap = new HashMap<>();
        private final Map<String, LMethod> methodMap = new HashMap<>();

        Builder(String name, List<LClass> superClasses) {
            this.name = name;
            this.superClasses = superClasses;
        }

        public Builder addField(String name) {
            return addField(LModifier.PUBLIC, name);
        }

        public Builder addField(LModifier modifier, String name) {
            fieldMap.put(name, new LField(name, modifier));
            return this;
        }

        public Builder addMethod(String name, Function<LThisPointer, LMethod.MethodImplementor> method) {
            return addMethod(LModifier.PUBLIC, name, method);
        }

        public Builder addMethod(LModifier modifier, String name, Function<LThisPointer, LMethod.MethodImplementor> method) {
            methodMap.put(name, new LMethod(modifier, name, method));
            return this;
        }

        public LClass end() {
            return new LClass(name, superClasses, fieldMap, methodMap);
        }
    }
}

2.2 对象的实现

对象中包含该对象所属的类、直接超类的对象列表、成员域集合和This指针，提供方法调用和成员域读写的接口，并做访问控制

public class LObject {
    private final LClass objClass;
    private final List<LObject> parentObjects;
    private final Map<String, LField> fieldMap;
    private final LThisPointer thisPointer;

    public LObject(LClass objClass) {
        this.objClass = objClass;
        parentObjects = new ArrayList<>(objClass.getSuperClasses().size());
        for (LClass directSuperClass : objClass.getSuperClasses()) {
            parentObjects.add(directSuperClass.newInstance());
        }
        fieldMap = new HashMap<>();
        try {
            for (Map.Entry<String, LField> entry : objClass.getFieldMap().entrySet()) {
                fieldMap.put(entry.getKey(), entry.getValue().clone());
            }
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
        thisPointer = new LThisPointer(this);
    }

    public LClass getObjClass() {
        return objClass;
    }

    List<LObject> getParentObjects() {
        return parentObjects;
    }

    Map<String, LField> getFieldMap() {
        return fieldMap;
    }

    public Object invoke(String name, Object... args) {
        Queue<LObject> objectQueue = new LinkedList<>();
        objectQueue.add(this);

        LMethod method = null;
        while (!objectQueue.isEmpty()) {
            LObject object = objectQueue.remove();
            method = object.objClass.getMethodMap().get(name);
            if (method != null) {
                break;
            } else {
                objectQueue.addAll(object.parentObjects);
            }
        }

        if (method == null) {
            throw new RuntimeException(new NoSuchMethodException(name));//note
        } else {
            if (method.getModifier() != LModifier.PUBLIC) {
                throw new RuntimeException(new IllegalAccessException(method.getModifier().toString()));
            } else {
                return method.invoke(thisPointer, args);
            }
        }
    }

    public Object get(String fieldName) {
        try {
            return findField(fieldName).getValue();
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public void set(String fieldName, Object value) {
        try {
            findField(fieldName).setValue(value);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    private LField findField(String name) throws NoSuchFieldException, IllegalAccessException {
        Queue<LObject> objectQueue = new LinkedList<>();
        objectQueue.add(this);

        LField field = null;
        while (!objectQueue.isEmpty()) {
            LObject object = objectQueue.remove();
            field = object.fieldMap.get(name);
            if (field != null) {
                break;
            } else {
                objectQueue.addAll(object.parentObjects);
            }
        }

        if (field == null) {
            throw new NoSuchFieldException(name);
        } else {
            if (field.getModifier() != LModifier.PUBLIC) {
                throw new IllegalAccessException(field.getModifier().toString());
            } else {
                return field;
            }
        }
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder().append(objClass.getName()).append('[');

        for (LObject object : parentObjects) {
            builder.append(object.objClass.getName()).append("=>").append(object).append(',');
        }

        for (Map.Entry<String, LField> fieldEntry : this.fieldMap.entrySet()) {
            builder.append(fieldEntry.getKey()).append("->").append(fieldEntry.getValue().getValue()).append(',');
        }
        return builder.append(']').toString();
    }
}

2.3 this 指针的实现

This 指针提供的接口与对象类似，持有实际对象，但是对对象成员域和方法的访问控制不同，实现如下：

public class LThisPointer {
    private final LObject target;

    public LThisPointer(LObject target) {
        this.target = target;
    }

    public Object invoke(String name, Object... args) {
        LMethod method = target.getObjClass().getMethodMap().get(name);
        if (method != null) {
            return method.invoke(this, args);
        } else {
            Queue<LObject> objectQueue = new LinkedList<>(target.getParentObjects());
            while (!objectQueue.isEmpty()) {
                LObject object = objectQueue.remove();
                method = object.getObjClass().getMethodMap().get(name);
                if (method != null) {
                    break;
                } else {
                    objectQueue.addAll(object.getParentObjects());
                }
            }

            if (method == null) {
                throw new RuntimeException(new NoSuchMethodException(name));//note
            } else {
                if (method.getModifier() == LModifier.PRIVATE) {
                    throw new RuntimeException(new IllegalAccessException(method.getModifier().toString()));
                } else {
                    return method.invoke(this, args);
                }
            }
        }
    }

    public Object get(String fieldName) {
        try {
            return findField(fieldName).getValue();
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public void set(String fieldName, Object value) {
        try {
            findField(fieldName).setValue(value);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    private LField findField(String name) throws NoSuchFieldException, IllegalAccessException {
        LField field = target.getFieldMap().get(name);
        if (field != null) {
            return field;
        } else {
            Queue<LObject> objectQueue = new LinkedList<>(target.getParentObjects());
            while (!objectQueue.isEmpty()) {
                LObject object = objectQueue.remove();
                field = object.getFieldMap().get(name);
                if (field != null) {
                    break;
                } else {
                    objectQueue.addAll(object.getParentObjects());
                }
            }

            if (field == null) {
                throw new NoSuchFieldException(name);
            } else {
                if (field.getModifier() == LModifier.PRIVATE) {
                    throw new IllegalAccessException(field.getModifier().toString());
                } else {
                    return field;
                }
            }
        }
    }
}

2.4 方法的实现

方法的定义通过柯里化的形式，将this指针与方法的实际参数分开传递给方法体，因此方法中仅包含修饰符、名称、以及方法实现，代码如下：

public class LMethod {
    private final LModifier modifier;
    private final String name;
    private final Function<LThisPointer, MethodImplementor> method;

    public LMethod(LModifier modifier, String name, Function<LThisPointer, MethodImplementor> method) {
        this.modifier = modifier;
        this.name = name;
        this.method = method;
    }

    public interface MethodImplementor {
        Object run(Object... args);
    }

    public LModifier getModifier() {
        return modifier;
    }

    public String getName() {
        return name;
    }

    public Object invoke(LThisPointer pointer, Object... args) {
        return method.apply(pointer).run(args);
    }
}

2.5 成员域的实现

成员域（Field）的实现更为简单，劲爆汗修饰符、名称和值。因为对象创建时需要克隆内容，所以添加了克隆的接口，代码如下：

public class LField implements Cloneable{
    private final String name;
    private Object value;
    private final LModifier modifier;

    public LField(String name, LModifier modifier) {
        this.name = name;
        this.modifier = modifier;
        value = null;
    }

    public String getName() {
        return name;
    }

    public LModifier getModifier() {
        return modifier;
    }

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    @Override
    protected LField clone() throws CloneNotSupportedException {
        return (LField) super.clone();
    }
}

2.6 访问修饰符

public enum LModifier {
    PUBLIC, PROTECTED, PRIVATE
}
乐征skyline
关注
专栏目录
CCF计算机软件能力认证试题练习：201903-4 消息传递接口
WINGREZ‘S BLOG
03-19 6749
消息传递接口 来源：CCF 标签： 参考资料： 相似题目： 背景 消息传递接口（MPI）是一个并行计算的应用程序接口，常用于超级计算机、计算机集群等环境下的程序设计。 题目 老师给了 T 份 MPI 的样例代码，每份代码都实现了 n 个进程通信。这些进程标号从 0 到 n − 1，每个进程会顺序执行. 自己的收发指令，如：“S x”，“R x”。“S x”表示向x 号进程发送数据，“R ...
基于Java的面向对象Web应用程序设计：简化代码结构、提高开发效率
AI天才研究院
07-26 1063
面向对象编程（Object-Oriented Programming，OOP）是一种面向对象技术的重要分支。在web应用开发中，利用OOP可以实现模块化、可扩展性强、可维护性高、灵活性好等优点。同时，OOP也具备跨平台、跨语言特性，能够方便地实现多终端设备的部署。本文将重点介绍如何使用Java框架Spring Boot进行面向对象Web应用程序的设计，通过解决实际问题，帮助读者提升对面向对象编程、Java Web开发技术、Spring Boot框架等相关知识的理解和掌握。
消息传递接口
panwanning的博客
08-07 500
思路 这个题目当时在考试中其实思路是正确的，即队列+递归处理，当时是站在图的角度考虑。但由于在考试中边界部分出了问题，这题只得了0分。然后写了个纯模拟不优化，超时(60分)，因为这时候复杂度是O(8*n^2) 主要问题 判断死锁的逻辑： 1. 当前需要匹配的进程队列已空（存在a到b的弧，没有b到a的弧），必然不可匹配 2. 存在环，即递归到达同一进程的次数超过进程总数 递归逻辑 队头目标节点队...
JAVA核心知识-何为面向对象（OOP）？
BAOZEBING的博客
05-04 252
面向对象程序设计（英语：Object-oriented programming，缩写：OOP）是种具有对象概念的程序编程典范，同时也是一种程序开发的抽象方针。它可能包含数据、属性、代码与方法。对象则指的是类的实例。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性，对象里的程序可以访问及经常修改对象相关连的数据。在面向对象程序编程里，计算机程序会被设计成彼此相关的...
对消息、消息传递和多态的理解
huangxf_2008的专栏
05-06 1432
        以前学习面向对象的时候，对这消息的概念一直很不解，对多态也是一知半解。最近在看书的过程中，逐渐明白了这两个概念。现将对两者的理解整理如下： 消息和消息传递           对象之间进行通信的一种构造叫做消息。当一个消息发送给某个对象时，包含要求接收对象去执行某些活动的信息，接受到信息的对象经过解释，然后予以响应。这种通信机制叫做消息传递。发送消息的对象不
Java面向对象OOP
qq_45805148的博客
07-12 165
- 面向对象（OOP）的基本概念 对象：现实世界中的一个实体，两个特征（状态和行为）； 类：具有相似特征和行为的对象的集合，属于某个类的一个具体的对象为这个类的一个实例，类和实例的关系是抽象和具体的关系。 消息：一个对象发送消息包含三方面内容（接受消息的对象、接受对象才用的方法、方法所需要的参数）。 - 面向对象（OOP)的三大特征 封装性： （1）把对象的状态（属性）和行为（方法）结合成一个独立的系统单位，并尽可能地隐藏对象的内部细节。 （2）封装使一个对象形成两个部分：接口部分和实现部分。对用户来
Delphi之OOP对象模型.pdf
12-19
Delphi 之 OOP 对象模型 Delphi 对于面向对象编程的支持丰富而且强大。除了传统的类和对象，Delphi 还提供了接口，异常处理，多线程编程等特性。 类和对象 类和对象可以将类想象为一种特殊的记录。与记录相似的是...
oop-with-java.notes:Java面向对象编程简介
05-17
Java面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它基于“对象”的概念，将数据和操作数据的方法封装在一起。在Java中，一切皆为对象，这使得代码更加模块化，易于维护和扩展。本笔记将深入...
javaOOP---1.2.docx
10-16
Java面向对象编程（OOP）是Java编程的核心概念，它将现实世界中的实体抽象为类，然后通过实例化这些类来创建对象，以此来模拟现实世界的模型。以下是关于Java OOP的一些关键知识点： 3.1 类： 类是Java OOP的基本...
JAVA面向对象(OOP)
m0_67564501的博客
03-26 1001
类和对象 生活中都是由许多许多的对象组成的,所有我们基于对象抽出类,那么软件中真是存在的一个个的个体,就是一个个的对象.类是对象的模型,基于类的模型创建出对象,所以对象是类的具体实例化.一个类可以创建所要的任意个对象. 类：用于封装对象的属性和行为. 类中可以包含: 对象的属性/特征(实例变量,静态变量) 静态变量和静态块 对象的行为/动作(方法) 方法(method) 方法：封装的是具体的业务逻辑功能实现 方法的重载(overload,overloading); 存在同一类当中,方法名
akka-actor_2.12 jar包
11-22
akka-actor_2.12 jar包
Java并发编程实战~Actor 模型
小强快跑~~
11-28 1492
Hello Actor 模型 Actor 模型本质上是一种计算模型，基本的计算单元称为 Actor，换言之，在 Actor 模型中，所有的计算都是在 Actor 中执行的。在面向对象编程里面，一切都是对象；在 Actor 模型里，一切都是 Actor，并且 Actor 之间是完全隔离的，不会共享任何变量。 当看到“不共享任何变量”的时候，相信你一定会眼前一亮，并发问题的根源就在于共享变量，而 Actor 模型中 Actor 之间不共享变量，那用 Actor 模型解决并发问题，一定是相当顺手。的确是这样，
java actor_Java并发之actor模型
weixin_36431907的博客
02-12 1655
Java并发之actor模型Actor模型是一个概念模型，用于处理并发计算。它定义了一系列系统组件应该如何动作和交互的通用规则。线程-对象模型的问题锁和效率OOP的核心特性是封装，封装规定对象的内部数据不能直接从外部访问,它只能通过调用一组方法来修改。当我们分析OOP运行时行为时，我们有时会绘制一个消息序列图，显示方法调用的交互。例如：很显然,对应单线程来说，程序就像串行一样执行，下面考虑多线程情...
Java中的Actor模型
最新发布
weixin_46372265的博客
07-17 389
Actor模型最早由Carl Hewitt在1973年提出，是一种数学模型，用于并发计算。在Actor模型中，最基本的执行单元是“actor”。每个actor都拥有自己的状态，并通过消息传递与其他actor进行通信【6†source】【7†source】。Actor模型提供了一种高效、可靠的并发编程方式，通过消息传递避免了传统多线程编程中的种种问题。在Java中，使用Akka框架可以方便地实现Actor模型，构建高性能的分布式系统。希望这篇文章能帮助你更好地理解和掌握Java中的Actor模型。
java详细学习路线及路线图
热门推荐
钟长森的博客
03-29 25万+
java详细路线： 原文出自点击打开链接 本文将告诉你学习Java需要达到的30个目标，学习过程中可能遇到的问题，及学习路线。希望能够对你的学习有所帮助。对比一下自己，你已经掌握了这30条中的多少条了呢？ 路线 Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE。 这三块相互补充，应用范围不同。 J2SE就是Java2的标准版，主要用于...
actor java,哪个Actor模型库/框架Java？
weixin_31690531的博客
02-22 123
There are so many different Actor model implementations for Java (and the JVM languages).A lot of Actor libraries and frameworks have been implemented to permit Actor-style programming in Java (which ...
Java的Actor框架--kilim
pdw2009的专栏
05-13 4047
Java的Actor框架--kilim
我的算法学习之路
weixin_33749242的博客
05-05 4147
我的算法学习之路 关于 严格来说，本文题目应该是我的数据结构和算法学习之路，但这个写法实在太绕口——况且CS中的算法往往暗指数据结构和算法（例如算法导论指的实际上是数据结构和算法导论），所以我认为本文题目是合理的。 原文链接：http://zh.lucida.me/blog/on-learning-algorithms/ 原文作者：Lucida 这篇文章讲了什么？ 我这些年学习数据结构和算法的总...
北大青鸟Java课件：理解面向对象编程与对象模型
通过对象间的消息传递，不同对象可以互相协作，实现了软件系统的设计和实现。 在第四部分，对象的概念被深入阐述，包括它的定义、在编程中的实用性和如何模拟现实世界中的实体。课程还介绍了如何创建和导入包，这是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值