Programming Languages - Classes

Last Updated: 2024-01-21
  • There is no way to write a Java program without a class.
  • Rust does not have the keyword class, instead it is achieved by struct + impl.
  • Go does not have classes. However, you can define methods on types.

Constructor / Destructor


class Foo {
  Foo(const Foo& arg);             // copy constructor
  Foo(Foo&& arg);                  // move constructor
  Foo& operator=(const Foo& rhs);  // copy assignment operator
  Foo& operator=(Foo&& rhs);       // move assignment operator

  ~Foo(); // destructor



struct Foo {
  my_field: isize

impl Foo {
  // constructor, by convention
  pub fn new(field: isize) -> Foo {
    Foo { my_field: field }


fn drop(&mut self);


public class Foo {
  private final int myField;

  // constructor
  public Foo(final int field) {
    this.myField = field;


  • constructor: __init__()
  • destructor: __del__(); called when all references to the object have been deleted i.e when an object is garbage collected.



In Go, a method is just a function, but with a special receiver argument. The (v Vertex) below is the receiver, which means Abs() is not standalone, it has to be called by v.Abs().

type Vertex struct {
	X, Y float64

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)

func main() {
	v := Vertex{3, 4}

This is the equivalent function version:

func Abs(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)

You can only declare a method with a receiver whose type is defined in the same package as the method. You cannot declare a method with a receiver whose type is defined in another package

Value receivers vs pointer receivers:

// Value receiver, `Scale()` method operates on a copy of the original `Vertex` value.
func (v Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f

// Pointer receiver, the values of Vertex will be modified.
func (v *Vertex) Scale(f float64) {
	v.X = v.X * f
	v.Y = v.Y * f

When to use pointer receiver:

  1. if the value that the receiver points to will be modified. (e.g. v.X will change within Scale())
  2. if the receiver is a large struct, this avoids copying the whole value.
  3. all methods on a given type should have either value or pointer receivers, but not a mixture of both.


There's no class; struct doesn’t support methods, use the impl keyword.