编辑“︁Modula-3”︁（章节）

===面向对象===
Modula-3下的[[面向对象编程]]，经常采用部份不透明类型，它通过如下惯用法来声明：{{code|2="objectpascal"|1=Type T <: Public; Public = OBJECT ... END}}，这里的不透明类型<code>T</code>，支持在随后定义的对象类型中的字段和方法，而不会披露<code>T</code>的确切结构，也不披露<code>T</code>可能支持的其他方法。

下面的例子，定义一个接口<code>Person</code>，具有按习惯约定命名的两个类型，导出类型<code>T</code>，和公开对象类型<code>Public</code>，这里声明了<code>T</code>是<code>Public</code>的不透明[[子类型]]，<code>Public</code>具有两个方法<code>getAge()</code>和<code>init()</code>；随后是<code>Person</code>接口的完全实现：
<syntaxhighlight lang="objectpascal">
INTERFACE Person;
    TYPE T <: Public;
        Public = OBJECT 
        METHODS
            getAge(): INTEGER;
            init(name: TEXT; age: INTEGER): T;
        END;
END Person.
</syntaxhighlight>
<syntaxhighlight lang="modula2">
MODULE Person;
    REVEAL T = Public BRANDED OBJECT 
        name: TEXT;
        age: INTEGER;
    OVERRIDES
        getAge := Age;
        init := Init;
    END;
    PROCEDURE Age(self: T): INTEGER =
    BEGIN
        RETURN self.age;
    END Age;
    PROCEDURE Init(self: T; name: TEXT; age: INTEGER): T =
    BEGIN
        self.name := name;
        self.age := age;
        RETURN self;
    END Init;
BEGIN
END Person.
</syntaxhighlight>

要建立一个新的<code>Person.T</code>对象，要使用内建操作<code>NEW()</code>，并调用方法<code>init()</code>： 
<syntaxhighlight lang="modula2">
VAR jim := NEW(Person.T).init("Jim", 25);
</syntaxhighlight>

下面是整数堆栈的例子：
<syntaxhighlight lang="objectpascal">
INTERFACE IntegerStack;
    TYPE
        T <: Public OBJECT;
        Public = OBJECT
        METHODS
            init(): T;
            push(x: INTEGER);
            pop(): INTEGER;
        END;
END IntegerStack.
</syntaxhighlight>
<syntaxhighlight lang="modula2">
MODULE IntegerStack;
    REVEAL T = Public BRANDED OBJECT
        n: INTEGER;
        a: REF ARRAY OF INTEGER;
    OVERRIDES
        init := Init;
	    push := Push;
	    pop := Pop;
    END;
    PROCEDURE Init(self: T): T =
    BEGIN
        self.n := 0;
        self.a := NIL;
        RETURN self
    END Init;
    PROCEDURE Push(self: T; x: INTEGER) =
    BEGIN
        IF self.a = NIL THEN 
            self.a := NEW(REF ARRAY OF INTEGER, 5)
        ELSIF self.n > LAST(self.a^) THEN
            WITH temp = NEW(REF ARRAY OF INTEGER, 2 * NUMBER(self.a^)) DO
                FOR i := 0 TO LAST(self.a^) DO
                    temp[i] := self.a[i] 
                END;
                self.a := temp
            END
        END;
        self.a[self.n] := x;
        INC(self.n)
    END Push;
    PROCEDURE Pop(self: T): INTEGER =
    BEGIN
        DEC(self.n);
        RETURN self.a[self.n]  
    END Pop;
BEGIN
END IntegerStack.
</syntaxhighlight>
创建新堆栈在这里的部份不透明类型实现下为：{{code|2="modula2"|1=VAR myStack := NEW(IntegerStack.T).init()}}，在上述的不透明类型实现下为：{{code|2="modula2"|1=VAR myStack := IntStack.Create()}}。而压入一个数在这里的部份不透明类型实现下为：{{code|2="modula2"|1=myStack.push(8)}}，在上述的不透明类型实现下为：{{code|2="modula2"|1=IntStack.Push(myStack, 8)}}。