DEV Community: CitronBrick

Python OOP for Java Developers

CitronBrick — Sun, 15 Feb 2026 19:56:15 +0000

Let's consider the case of a simple Java class Square.

A Square, which is a Shape, is defined by its position & side length.


abstract class Shape {

    abstract int area();

    abstract int perimeter();

}

public class Square extends Shape {

    private int x;
    private int y,
    private int side;

    public Square(int x, int y, int side) {
        this.x = x;
        this.y = y;
        this.side = side;
    }

    public Square(int x1, int y1,int x2,int y2) {
        if(Math.abs(x2 - x1) != Math.abs(y2 - y1) ) {
            throw new IllegalArgumentException("Square must have equal sides");
        }
        x = x1;
        y = y1;
        side = (x2 - x1);
    }

    public int area() {
        return side * side;
    }

    public int perimeter() {
        return 4 * side;
    }

    public String toString() {
        return String.format("Square[x=%d,y=%d,side=%d", x, y, side);
    }
}

Since this article is intended for Java developers, I am not going to explain it in detail, but feel free to ask doubts in the comments.

Now, we are going convert it step by step into Python.


class Square : Shape 
    pass #empty blocks are not allowed in Python

Empty blocks are not allowed in Python. pass or ... should be used instead.

Constructor (not Constructors)

Since declaration in Python, is indistinguishable from initialization, we declare the fields in the only constructor.

def __init__(self, x, y, side):
    self.x = x
    self.y = y
    self.side = side

To create a Square instance, no new keyword is used.

The 2nd constructor having 4 parameters cannot be implemented using __init__, since Python does not support overloading neither for constructors nor methods.

You'll see how to implement it using @classmethod later.

s1 = Square(1, 3, 10)
s2 = Square(x=1, y=3, side=10)

Encapsulation

Python does not enforce strict encapsulation as does Java via public,protected,private keywords. By convention, members beginning with _ (underscore) are private in Python.

The explicit (not implicit) argument

You can notice an extra 1st argument self in the __init__.

You have probably guessed that it's analogous to this in Java.
Except that self is not a keyword & that the 1st argument explicitly refers to the current instance.

The same holds true for the instance methods. The 1st argument refers to the current instance. You cannot refer to fields or other methods in the same class without it.

def area(self):
    return self.side * self.side

def perimeter(self):
    return 4 * self.side

String representation

Similar to toString in Java, there are the __repr__ & __str__ methods, which get called when you use the str function. Unlike toString, the str function is not implicitly called during concatenation.

def __str__(self):
    return "Square [side=" + str(self.side) + "]"

def __repr__(self):
    return "Square(side="+str(self.side)+")"


sq = Square(5)
print(sq) # prints Square [side=5]
print(sq + ".") # error. cannot concatenate string & Square
print(str(sq) + ".") # prints Square [side=5].

__repr__ method	__str__ method
returns the constructor call expression	returns string representation
has less priority during `str` call	has more priority during `str` call

Static & Class methods (they're different)

In Java, class method & static method refer to the same concept, whereas in Python they are quite different.

Consider a method that for a given area, calculates the length of a side. Such a method would be static as it does not depend on the current square instance.

public static double calcSideLength(area) {
    return Math.sqrt(area);
}

@staticmethod 
def calc_side_length(area):
    return math.sqrt(area) # math is a module not a class

A static method does not have the 1st self argument, as it's independent of the instance. Here staticmethod is a decorator i.e. a function that returns another function for function transformation.

We can implement the 2nd constructor having 4 arguments, using another decorator @classmethod.

@classmethod 
def make_square_from_points(cls, x1, x2, y1, y2):
    return cls(x1, x2, x1 - x2) # cls is the constructor

A class method receives the class constructor itself (cls) as it's 1st argument. Hence, it's useful for creating factory methods.

Let's check if the points passed to this method, really forms a square.

@classmethod
def make_square_from_points(cls, x1, y1, x2, y2):
    if x2 - x1 == y2 - y1:
        return cls(x1, x2, x1 - x2) 
    else:
        raise ValueError("The points do not form a square")

Exceptions

No prizes for guessing that we are "throwing an Exception", i.e. "raising an Error" here. We can call make_square_from_points as:

try:
    sq = Square.make_square_from_points(4, 5, 7, 11)
except ValueError as ve:
    print(ve)

Output

ValueError: (4, 5, 7, 11)

We are going to see how to create child classes in Python. Let's create our own Error MalformedSquareException by inheriting from ValueError. (I haven't forgotton the Shape class, but I'm saving it for later.)

class MalformedSquareException(ValueError):

    def __init__(self, x1, y1, x2, y2):
        self.x1 = x1
        self.x2 = x2
        self.y1 = y1
        self.y2 = y2

        # Note the difference wrt __str__
    def __repr__(self):
        return "MalformedSquareException(%d, %d, %d, %d)" % (self.x1, self.y1, self.x2, self.y2)

    def __str__(self):
        return "The points (%d, %d) and (%d, %d) are not the opposite corners of a square" %(self.x1, self.y1, self.x2, self.y2)

try:
    sq = Square.make_square_from_points(4, 7, 5, 11)
except MalformedSquareException as ve:
    print(ve)

Output

The points (4, 5) and (7, 11) are not the opposite corners of a square

Abstract classes

Coming back to our Shape abstract, it can be written in Python as follows:

import abc

# alternative:
# class Shape(abc.ABC) 
class Shape(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def area(self):
        ... # Python abstract classes require a body

    @abc.abstractmethod
    def perimeter(self):
        ...

Python abstract classes are created either by

declaring ABCMeta as a metaclass or
subclassing ABC (whose metaclass is ABCMeta)

As in Java, Python abstract classes can have constructors & non-abstract methods. In addition,

Python abstract classes can have static & class abstract methods.

Surprised ? Consider the method nb_sides in Shape. It's abstract as it depends on the implementation. However, for a given Shape class it's constant.

class Shape(metaclass= abc.ABCMeta):

    @staticmethod
    @abc.abstractmethod
    def nb_sides():
        ...

class Square(Shape):

    @staticmethod 
    def nb_sides():
        return 4

Note that @staticmethod must preceed @abc.abstractmethod.

Operator Overloading

Yes, Python supports operator overloading. We can implement methods such as __add__, __mul__, __lt__, __gt__, __eq__, __not__ etc and use their respective symbols to call them. In contrast, the only case of operator overloading in Java is using + for String contactenation.


class Square(metaclass=abc.ABCMeta):

    # sq2 = sq1 * 3 creates sq2 that's 5 times bigger than sq1
    def __mul__(self, n):
        return Square(self.x, self.y, self.side * math.sqrt(n)

    def __lt__(self, s):
        return self.side < s.side

    def __gt__(self, s):
        return self.side > s.side

    def __eq__(self, s):
        return self.side == s.side

s1 = Square(0,0, 10) 
s2 = s1 * 3 # __mul__
print(s1 < s2) # __lt__ is called   
print(s1 == s2) __eq__

The __eq__ method is Python's counterpart for equals.

__lt__, __gt__ methods are Python's counterpart for Comparable.

Multiple Inheritance

Now we've come to the meat of the matter. Python supports multiple inheritance, unlike Java which supports only single inheritance.

This naturally leads to the question: When a class has multiple ancestors, which one's members have the higher priority ?

Immediate ancestors' members have higher priority than those farther up. (As in Java)
Within ancestors of the same hierarchy, the class declarations, parent class order determines the priority (left -> higher, right -> lower)

Eg: Consider the following scenario:

I've introduced 2 new classes Rectangle & Rhombus which both inherit the abstract class Shape. And the Square now inherits both Rectangle & Rhombus.

class Rectangle(Shape):

    def __init__(self, x, y ,length, breadth):
        self.x, self.y = x,y
        self.length, self.breadth = length, breadth

    def area(self):
        return self.length * self.breadth

    def perimter(self):
        return 2 * (self.length + self.breadth)

    @staticmethod
    def nb_sides():
        return 4

class Rhombus(Shape):

    def __init__(self, x, y, side, angle):
        self.x, self.y = x,y
        self.side, self.angle = side, angle

    def area(self):
        return self.side * self.side * math.sin(self.angle * math.pi/180)

    def perimeter(self):
        return 4 * self.side

    @staticmethod
    @abc.abstractmethod
    def nb_sides():
        return 4

class Square(Rhombus, Rectangle):

        def __init__(self, side):
            super().__init__(self, side, math.pi/2)

        def area():
            return super().area()


        @staticmethod
        def nb_sides():
            return 4

There are a number of things to note here:

The super call does not call the parent constructor, though it still references the parent object. Hence the need to call __init__ again.
Since the declaration of Square contains Rhombus before Rectangle (though Rectangle is declared before Rhombus in the code), super() references Rhombus not Rectangle.
Though both Rhombus & Rectangle have implemented the static method nb_sides, Square still needs to implement it for itself. Failure to do so, will result in an error.
The explicit call of the parent constructor via __init__ needed self as an argument, while the call of the parent area() method did not need it.

To know the method resolution order (ascending) of a given object using the mro method. Eg:

sq = Square(0,0,5)
print(sq.mro())
#[<class '__main__.Shape'>, <class '__main__.Rectangle'>, <class '__main__.Rhombus'>]
# higher priority is towards the right

Enums

I've added a bonus part on enumerations.

In Java, we can have simple enums without constructor


public enum Color {
    RED, BLUE, GREEN, YELLOW
}

or with a constructor

public enum Color {
    RED(1), BLUE(2), GREEN(3), YELLOW(4);

    private int rank;

    private Color(int r) { rank = r; }

    public int getRank() { return rank; }
}

In Python, enums are not a type but rather child classes of Enum which itself is a child of EnumType. Also each enum instance must be associated value. Default values can be provided using the enum.auto() function.

import enum

class Color(enum.Enum):
    RED = 1
    BLUE = 2,
    GREEN = enum.auto(),
    YELLOW = enum.auto()

Enum values are iterable out of the box in Python, unlike Java where we need to call the values() method.

color_list = [c for c in Color]

Conclusion.

There are other advanced topics like :

how to create an interface in Python (roundabout way) &
how to change the default inheritance order But I've skipped them for now.

Here's a summary of the differences in Object Oriented Programming between Java & Python, as seen in this article.

Java	Python
Strict encapsulation	Lenient encapsulation
Overloading of constructors & methods	No overloading
implicit `this` keyword argument	method's explicit 1st argument
static members	static & class methods (different)
`toString`	`__repr__` and `__str__`
Almost no operator overloading	Operator overloading
Abstract methods cannot be static	Abstract methods can be class or static
Single inheritance	Multiple inheritance
Enum types with optional value	Enum child classes with values for each instance

The Java icon in the cover image is from Java icons created by Freepik - Flaticon.

Back to School

CitronBrick — Mon, 30 Jun 2025 04:43:57 +0000

This is a submission for Frontend Challenge - June Celebrations, CSS Art: June Celebrations.

Inspiration

In certain parts of the world, June marks the beginning of the academic year for school students.

Demo

Journey

Just some confusion on how much js & if svg can be used.
Anyways used clip-path to create the shapes & CSS animation to animate.

Cartoon Network Logo with Web Component

CitronBrick — Sun, 22 Dec 2024 20:06:28 +0000

Since I was a kid, I've loved the classic Cartoon Network Logo.

I created an Autonomous Custom HTML Element to make text like it with different colors.

It can be used as follows:

<cartoon-networkify color1="midnightblue" color2="yellow" >Peanut Butter</cartoon-networkify>

Here's the WebComponent

class CartoonNetworkify extends HTMLElement {

    // respond to color updates
    static observedAttributes = ['color1','color2'];

    constructor() {
        super();
    }

    connectedCallback() {
        let words = this.innerText.split(' ');
        this.attachShadow({mode:'open'});
        var root = this.shadowRoot;
        var table = document.createElement('table');

        // longest word length
        let maxLength = words.reduce((max,w, i)=>  w.length > max ? w.length: max, Number.MIN_VALUE);

        // default black & white
        var color1 = this.getAttribute('color1') || 'black';
        var color2 = this.getAttribute('color2') || 'white';

        words.reduce((tbody,line,i,words)=>{
            // pad for extra space
            line = line.padEnd(maxLength);
            let trow = line.split('').reduce((trow,letter,j)=>{
                // create cells
                let td = trow.insertCell();
                td.innerText = letter.toUpperCase();
                let odd  = i%2 == j%2;
                td.dataset.odd = odd;

                                td.style.backgroundColor=odd?color1:color2;
                    td.style.color = odd?color2:color1;
                return trow;
                    }, tbody.insertRow());
                    return tbody;
                }, table.createTBody());
                root.append(table);

                // add style from template
                let template = document.getElementById('cartoon-networkify-template');
                root.append(template.content.cloneNode(true));
            }

            // update attributes later
            attributeChangedCallback(name,oldValue, newValue) {             
                if(this.shadowRoot) {
                    this.shadowRoot.querySelectorAll('td').forEach((td)=> {
                        var odd = td.dataset.odd == 'true';
                        if(name=='color1') {
                            td.style[odd?'backgroundColor':'color'] = newValue  ;
                        } else if(name == 'color2') {
                            td.style[odd?'color':'backgroundColor'] = newValue  ;
                        }
                    });
                }
            }

        }

Please feel free to ask me any questions.

To know more about custom elements, visit MDN.

CreateJS - One byte explainer

CitronBrick — Sun, 29 Sep 2024 19:42:13 +0000

This is a submission for the Web Game Challenge: One Byte Explainer

Explainer

CreateJS is a canvas based JavaScript library, that allows to create, modify, animate & remove shapes, images & sprites in the canvas as JS objects. It's compatible with Adobe Flash.

Go Structs for programmers

CitronBrick — Sun, 14 Apr 2024 13:13:01 +0000

Here's an introduction to Go structs. This tutorial is aimed at readers who are familiar with at least on other programming language. I've omitted pointers as they may be too advanced for non C/C++ developers.

type Square struct {
    Side int
}

This is a square & it has one field: side. Let's add a simple method to it, to calculate its perimeter. Unlike most non .NET programming languages, fields & methods are capitalized on the basis of their being public or private. Here Side is capitalized as it's a public field.

Methods are created outside the struct body.

func (s Square) Perimeter() int {
    return 4 * s.Side
}

Devs from other languages, may be confused as to why there's an (s Square) before the method name.

In Go, the implicit variable is explicit

i.e. instead of using this (Java, C++, ECMAScript, C#), we explicitly declare a variable s of type Square. It marks the function as a method of Square & allows us to use fields & methods of the current instance.

Let's add another method area & make both their return types float64, (we'll see why later).

func (s Square) Perimeter() float64 {
    return float64(4 * s.Side)
}

func (s Square) Area() float64 {
    return float64(s.Side * s.Side)
}

Let's create another struct for circles.

type Circle struct {
    Radius int
}

func (c Circle) Diameter() int {
    return c.Radius * 2
}

func (c Circle) Perimeter() float64 {
    return c.Circumference()
}

func (c Circle) Circumference() float64 {
    return math.Pi * float64(c.Diameter())
}

func (c Circle) Area() float64 {
    return math.Pi * math.Pow(float64(c.Radius),float64(2))
}

I want to draw your attention to the last 2 methods. We cannot simply do

math.Pow(c.Radius, 2)

. The compilation would fail as math.Pow expects 2 float64 arguments. There are no other versions, since

Go does not support overloading despite being a typed language.

Also, in Circumference, since c.Radius is declared as an int, multiplying it with a float64 returns an int, & hence the cast is needed. This cast wouldn't be necessary while multiplying a float64 with an int literal (eg: f1 * 5 vs f1 * float64(i1)) .

Interfaces (this isn't polymorphism)

Suppose we want to create an array containing shapes, & find each their respective perimeter & area, as below.

arr := [4]Shape{ Circle{5} , Circle{7}, Square{15}, Triangle{8, 5, 4} }
for _,sh := range arr {
    fmt.Println(sh.Perimeter())
    fmt.Println(sh.Area())
}

We would need to create an interface Shape. Go interfaces aren't like your traditional super-classes like Java, C++ or C#. There's no struct Foo implements Bar kind of code involved.

It actually embodies the

walks like a duck, quacks like a duck, is a duck

principle, a bit similar to ECMAScript i.e.

struct implements all methods specified in an interface ⇔ struct implements the interface

We'll just add the below interface.

type Shape interface {
    Area() float64
    Perimeter() float64
}

That's it. Circle, Triangle & Square implement Shape automatically. Can you now infer why, our even our Square methods had to return float64?

That's all folks. To know more about structs especially about using pointers you can take the tour of Go.

JSON-B : An Introduction

CitronBrick — Wed, 31 Aug 2022 10:49:56 +0000

The Java API for JSON Binding (JSON-B) is a JavaEE/JakartaEE specification (JSR-353) to convert Java objects to json & vice-versa. Apache Johnzon is an implementation of the JSON-B spec.

Javadoc

JSON-B is an alternative to GSON & Jackson.

Consider the following Java class (simplified)

class Task {
    String description;
    LocalDate deadline;
    boolean over;
}

You can convert Task instances to json as follows:

Task task = new Task("Jump")
Jsonb jsonb = JsonbBuilder.create();
String taskJson = jsonb.toJson(task);

{"deadline":"2021-10-15","description":"Jump","over":false}

Let's say I want to initialize a bunch of Task objects from fakerestapi.azurewebsites.net. It provides a json web-service for activities with the following schema :

To convert this json objects of this schema to Activity instances, you can use the @JsonbProperty annotation.

class Task {
    @JsonbProperty("title")
    String description;

    @JsonbProperty("dueDate")
    LocalDate deadline;

    @JsonbDateFormat(JsonbDateFormat.DEFAULT_FORMAT)
    @JsonbProperty("completed")
    boolean over;

    @JsonbNillable
    // creator can be optionally present in json
    String creator; 
}

Properties that can be optionally present/absent in the json, must be annotated with @JsonbNillable

Suppose you have multiple sources of Activities each with their own schema you can create & use JsonbAdapters.

@JsonbTypeAdapter
class GermanTaskAdapter implements JsonbAdapter<Task, JsonObject> {

    public Task adaptFromJson(JsonObject jo) {
       var description = jo.getString("Titel");
       var deadline = LocalDate.parse(jo.getString("Stichtag"));
       var over = jo.getBoolean("vollendet");
       return new Task(description, deadline, over);
    }

    public JsonObject adaptToJson(Task task) {
       return Json.createObjectBuilder()
           .add("id", 0)
           .add("Titel", task.getTitle())
           .add("Stichtag", task.getDeadline().toString())
           .add("vollendet", task.isOver())
    }
}

You can have multiple adapters for a domain class, through which you can consume from multiple sources & provide multiple json implementations.

In the above adapter, I have used the *Java API for JSON Processing
*JSON-P API to create and use JsonObject instances.

If you are using Spring there is JsonbHttpMessageConverter since version 5.

This is my first online technical article (was unpublished for a looong time). Questions & Feedback welcome.
Thanks for reading.

Future React Components: ES2022

CitronBrick — Thu, 14 Jul 2022 17:41:00 +0000

Hi, here's an accessible checkbox, which is probably the web's 1st React Component, created using ES2022.

Here the state is a private instance variable. Private instance variables, prefixed with #, are supported in ES2022.

class Checkbox extends React.Component {

        #state = {checked: false};

        handleClick=(evt)=>{
            this.setState((state)=>
                ({checked: !state.checked})
            );
        }

        handleKeyDown=(evt)=>{
            if([' ','Enter'].includes(evt.key)) {
                this.handleClick();
            }
        }

        render() {
            return <div className="checkbox" 
                id={this.props.id} 
                role="checkbox" 
                aria-checked={this.state.checked} 
                aria-disabled={this.props.disabled} 
                onClick={this.handleClick} 
                onKeyDown={this.handleKeyDown} 
                tabIndex={!this.props.disabled? "0":null}>
                    {this.state.checked ? "✓":""}
            </div>
        }

    }

Unfortunately the latest Babel version (7.0.0-beta.3), does not support it yet (14 July 2022). We'll have to wait, before using it with JSX.

If you don't like creating components using the class keyword, here's another article that shows how to create class compomnents without it. (Internet Explorer 11 compatible)

ES5 Class based React Components

CitronBrick ・ Jun 13 ・ 2 min read

#react #ie11 #tutorial

ES5 Class based React Components

CitronBrick — Mon, 13 Jun 2022 10:36:57 +0000

Most tutorials show how to make React components with either hooks or ES6 classes, but I haven't found one that uses ES5 classes. Now you may ask "Why bother with ES5 ?", but I still have to support IE11 & its 2 predecessor at work (at the time of writing).

I'm going to show you a Number Spinner. Here's the basic skeleton of an ES5 React component.

// The constructor cum class declaration
function NumberSpinner(props) {
    // equivalent to super(props)
    React.Component.call(this,props);
}

// These 2 lines together form the equivalent of
// extends React.Component
NumberSpinner.prototype = Object.create(React.Component.prototype);
NumberSpinner.prototype.constructor = NumberSpinner;

NumberSpinner.prototype.render = function() {

};

A spinner has only 3 use cases.

The spinner's state has only 1 property num that is added to the constructor.

this.state = {num: 0};

For the user to be able to assign an initial value to the spinner, there needs to be a prop initNum. Unlike Vue, it isn't advisable in React to initialize state with props directly like this.state = {num: this.props.initNum};. Instead the static getDerviedStateFromProps should be used.

NumberSpinner.getDerivedStateFromProps = function(props, state) {
    return {num: props.initNum};
};

Increment value

NumberSpinner.prototype.increment = function() {
    this.setState(function(state, props) {
        return {num: state.num + 1};
    });
}

Decrement Value

NumberSpinner.prototype.decrement = function() {
    this.setState(function(state, props) {
        return {num: state.num - 1};
    });
};

To render the spinner, 3 elements are needed: 1 to show the current value 2 increment & decrement buttons.

NumberSpinner.prototype.render = function() {
    var ce = React.createElement;
    var current = ce('div',{key:'current'}, this.state.num);
    var increment = ce('button',{key:'increment', onClick: this.increment}, '+');
    var decrement = ce('button',{key:'decrement', onClick: this.increment}, '-');
    return ce('div',{className:'spinner'}, [current,increment,decrement]);
};

It's been months I drafted my 1st Dev article, and Internet Explorer will be gone in 2 days. So any feedback is welcome :)

Feature Phone Emulator with SMS app - DigitalOcean Hackathon

CitronBrick — Mon, 11 Jan 2021 07:57:13 +0000

What I built

Category Submission:

Random Roulette

App Link

https://fpe-sms-58nib.ondigitalocean.app/

Screenshots

Description

This is a feature phone emulator with an SMS app.
As such, the screen is not (clickable/touchable).
The Left & Right selection buttons have to be used to
select the respective actions in the screen footer.

While writing a new message, click you can switch from uppercase/lowercase/number mode using the * key.

Example: To type "Hello"

Press * once to switch to uppercase
Press 4 twice
Press * twice to switch to lowercase
Press 3 twice
Press 5 thrice.
Wait ~ 1.5 seconds
Press 5 thrice.
Press 6 thrice.

Link to Source Code

https://github.com/CitronBrick/fpe-sms

Permissive License

MIT License

Background

(What made you decide to build this particular app? What inspired you?)
I've been a feature phone user for a long time. It was fun to develop buttons that insert a different letter based on the frequency of clicks.

How I built it

Used Angular for this project, after a long time.
This is my first time using DigitalOcean. Deployed it as a
stati site.

(How did you utilize DigitalOcean’s App Platform? Did you learn something new along the way? Pick up a new skill?)

Additional Resources/Info

This video was quite useful to deploy the angular app.
https://www.youtube.com/watch?v=TW5HYRz6kPk