Methods in CLIPS

Java supports methods defined on class types. Here’s an example:

public class Rectangle {
    private int width;
    private int height;

    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    // This area method is defined on the Rectangle class.
    public int area() {
        return this.width * this.height;
    }

    // Methods can be defined for the class directly.
    public int perimeter() {
        return 2 * this.width + 2 * this.height;
    }

    public static void main(String[] args) {
        Rectangle r = new Rectangle(10, 5);

        // Here we call the 2 methods defined for our class.
        System.out.println("area: " + r.area());
        System.out.println("perimeter: " + r.perimeter());

        // In Java, all non-primitive types are reference types,
        // so there's no need for explicit pointer handling.
        Rectangle rp = r;
        System.out.println("area: " + rp.area());
        System.out.println("perimeter: " + rp.perimeter());
    }
}

To run this program:

$ javac Rectangle.java
$ java Rectangle
area: 50
perimeter: 30
area: 50
perimeter: 30

In Java, methods are always defined as part of a class. There’s no distinction between pointer and value receiver types as in some other languages. All non-primitive types in Java are reference types, so method calls always operate on the same instance of the object.

Java uses the this keyword to refer to the current instance of the class within instance methods. This is similar to the receiver in some other languages.

Unlike some languages, Java doesn’t have separate concepts for structs and classes. Everything is a class, and classes can have both data (fields) and behavior (methods).

In this example, we’ve created a Rectangle class with width and height fields, and area() and perimeter() methods. The main() method demonstrates how to create an instance of the class and call its methods.

Next, we’ll look at Java’s mechanism for defining abstract types: interfaces.