IronCodeMan

Objects

Objects in programming are data structures that encapsulate both data and behavior, allowing for the creation of complex, organized entities within a program. They provide a way to represent real-world entities or abstract concepts by bundling related data and functions into a single unit. Objects enable developers to model the complexities of systems by defining attributes (data) and methods (functions) that operate on those attributes. This encapsulation promotes code organization, modularity, and reusability, as objects can be easily reused and extended in different parts of a program or across multiple programs.

C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_CAR_BRANDS 10
#define MAX_NAME_LENGTH 50

struct User {
  char First[MAX_NAME_LENGTH];
  char Last[MAX_NAME_LENGTH];
  int Age;
  int Retired;
  char CarBrands[MAX_CAR_BRANDS][MAX_NAME_LENGTH];
  int carBrandsCount;
};

void setValues(
  struct User *user,
  const char *first,
  const char *last,
  int age, int retired,
  const char *carBrands[],
  int carBrandsCount
) {
  strncpy(user->First, first, MAX_NAME_LENGTH - 1);
  strncpy(user->Last, last, MAX_NAME_LENGTH - 1);
  user->Age = age;
  user->Retired = retired;
  user->carBrandsCount = carBrandsCount;
  for (
    int i = 0; 
    i < carBrandsCount && i < MAX_CAR_BRANDS;
    i++
  ) {
    strncpy(
      user->CarBrands[i],
      carBrands[i],
      MAX_NAME_LENGTH - 1
    );
  }
}

char* fullName(struct User *user) {
  char *fullName = malloc(MAX_NAME_LENGTH * 2);
  snprintf(
    fullName,
    MAX_NAME_LENGTH * 2,
    "%s %s",
    user->First,
    user->Last
  );
  return fullName;
}

int main() {
  struct User user;
  const char *carBrands[] = {"Mazda", "Toyota"};
  setValues(&user, "Joe", "Doe", 23, 0, carBrands, 2);
  
  printf("%s\n", user.First);
  printf("%s\n", user.CarBrands[1]);
  printf("%s\n", fullName(&user));

  return 0;
}

C#

public class User {
  public string first;
  public string last;
  public int age;
  public bool retired;
  public string[] carBrands;
  
  public User (
    string First,
    string Last,
    int Age,
    bool Retired,
    string[] CarBrands
  ) {
    first = First;
    last = Last;
    retired = Retired;
    carBrands = CarBrands;
  }
  
  public string fullName() {
    return $"{first} {last}";
  }
    
  public static void Main(string[] args) {
    string[] brands = {"Mazda", "Toyota"};
    User user = new User (
      "Joe",
      "Doe",
      23,
      false,
      brands
    );
    
    Console.WriteLine(user.first);
    Console.WriteLine(user.carBrands[1]);
    Console.WriteLine(user.fullName());
  }
}

C++

#include <iostream>
#include <vector>
using namespace std;

class User {
  public:
    string First;
    string Last;
    int Age;
    bool Retired;
    vector<string> CarBrands;

    void setValues(
      string first,
      string last,
      int age,
      bool retired,
      vector<string> carbrands
    ){
      First = first;
      Last = last;
      Age = age;
      Retired = retired;
      CarBrands = carbrands;
    }

    string fullName() {
      return First + " " + Last;
    }
};

User user;
user.setValues(
  "Joe",
  "Doe",
  23,
  false,
  {"Mazda", "Toyota"}
);

string fullName = user.fullName();

cout << user.First << endl;
cout << user.CarBrands[1] << endl;
cout << fullName << endl;

Go

import "fmt"

type User struct {
  first string
  last string
  age int   retired bool
  carBrands []string
}

func (usr User) fullName() string { 
    return fmt.Sprintf("%s %s", usr.first, usr.last)
}

brands := []string{"Mazda", "Toyota"}
    
user := User {
  "Joe",
  "Doe",
  23, 
  false, 
  brands }
  
fmt.Println(user.first)
fmt.Println(user.carBrands[1])
fmt.Println(user.fullName())

Java

class User {
  public String first;
  public String last;
  public int age;
  public boolean retired;
  public String[] carBrands;
  
  public User (
    String first,
    String last,
    int age,
    boolean retired,
    String[] carBrands
  ) {
    this.first = first;
    this.last = last;
    this.retired = retired;
    this.carBrands = carBrands;
  }
  
  public String fullName() {
      return String.format("%s %s", first, last);
  }
}

String[] brands = {"Mazda", "Toyota"};
User user = new User (
  "Joe",
  "Doe",
  23,
  false,
  brands
);

System.out.println(user.first);
System.out.println(user.carBrands[1]);
System.out.println(user.fullName());

JavaScript

const user = {
  first: 'Joe',
  last: 'Doe',
  age: 23,
  retired: false,
  carBrands: ['Mazda', 'Toyota'],
  fullName: function () {
    return `${this.first} ${this.last}`
  }
}

console.log(user.first);
console.log(user.carBrands[1]);
console.log(user.fullName());

Kotlin

val user = object {
  val first = "Joe";
  val last = "Doe";
  val age = 23;
  val retired = false;
  val carBrands = arrayOf("Mazda", "Toyota");
  fun fullName (): String {
    return "${first} ${last}"
  }
} 

println(user.first);
println(user.carBrands[1]);
println(user.fullName());

MatLab

classdef User
  properties
    first;
    last;
    age {mustBeNumeric};
    retired {mustBeNumericOrLogical};
    carBrands;
  end
  methods
    function result = fullName(obj)
      result = sprintf("%s %s", obj.first, obj.last);
    end
  end
end

// command line
brands = ["Mazda", "Toyota"];
user = User ();
user.first = "Joe";
user.last = "Doe";
user.age = 23;
user.retired = false;
user.carBrands = brands;

disp(user.first);
disp(user.carBrands(1));
disp(user.fullName());

PHP

class User {
  public $first;
  public $last;
  public $age;
  public $retired;
  public $carBrands;
  
  function set_user(
    $first,
    $last,
    $age,
    $retired,
    $carBrands) {
      $this->first = $first;
      $this->last = $last;
      $this->age = $age;
      $this->retired = $retired;
      $this->carBrands = $carBrands;
  }
  function full_name() {
      return $this->first . " " . $this->last;
  }
}

$brands = array("Mazda", "Toyota");
$user = new User();
$user->set_user(
  "Joe",
  "Doe",
  23,
  false,
  $brands
);

echo $user->first . "\n";
echo $user->carBrands[1] . "\n";
echo $user->full_name();

Python

class User:
  def __init__(
    self, 
    first,
    last,
    age,
    retired,
    carBrands,
  ):
    self.first = first
    self.last = last
    self.age = age
    self.retired = retired
    self.carBrands = carBrands
  def fullName(self):
    return f"{self.first} {self.last}"

carBrands = ["Mazda", "Toyota"];
user = User(
            "Joe",
            "Doe",
            23,
            False,
            carBrands
          )

print(user.first)
print(user.carBrands[1])
print(user.fullName())

R

User <- setRefClass("User",
  fields = list(
    first = "character",
    last = "character",
    age = "numeric",
    retired = "logical",
    carBrands = "list",
    fullName = "character"
  ),
  methods = list(
    setFullname = function() {
      fullName <<- sprintf("%s %s", first, last)
    }
  )
)

brands <- list("Mazda", "Toyota");

user <- new("User", 
  first = "Joe",
  last = "Doe",
  age = 23,
  retired = FALSE,
  carBrands = brands
);
user$setFullname()

print(user$first)
print(user$carBrands[1])
print(user$fullName)

Ruby

class User
  attr_reader:first,:last,:carBrands
  def initialize(
    first,
    last,
    age,
    retired,
    carBrands
    )
    @first = first
    @last = last
    @age = age
    @retired = retired
    @carBrands = carBrands
  end
  def getVal(val)
    return val
  end
  def fullName()
    return "#{first} #{last}"
  end
end

brands = Array["Mazda", "Toyota"]
user = User.new(
  "Joe",
  "Doe",
  23,
  false,
  brands
)

puts user.first
puts user.carBrands[1]
puts user.fullName()

Rust

struct User {
  first: string,
  last: string,
  age: i16,
  retired: bool,
  carBrands: Vec<string>,
}

impl User {
    fn new(
      first: string,
      last: string,
      age: i16,
      retired: bool,
      carBrands: Vec<string>,
    ) -> User {
      User {
        first,
        last,
        age,
        retired, 
        carBrands,
      }
  }
  fn fullName(&self) -> string {
    let result = format!(
      "{} {}",
      self.first,
      self.last
    );
    return result;
  }
}

let mut brands = vec![
  "Mazda".to_string(),
  "Toyota".to_string()
];

let user = User::new(
  "Joe".to_string(),
  "Doe".to_string(),
  23,
  false,
  brands
);
println!("{}", user.first);
println!("{}", user.carBrands[1]);
println!("{}", user.fullName())

Scala

class User(
  var first: String,
  var last: String,
  var age: Int,
  var retired: Boolean,
  var carBrands: Array[String]
) {
  var fullName =  s"$first $last";
}

val brands = Array("Mazda", "Toyota");
val user = new User(
  "Joe",
  "Doe",
  23,
  false,
  brands
);

print(user.first);
print(user.carBrands(1));
print(user.fullName);

Swift

class User {
  var first:String;
  var last:String;
  var age:Int;
  var retired:Bool;
  var carBrands:Array<String>;
  
  init(
    first:String,
    last:String,
    age:Int,
    retired:Bool,
    carBrands:Array<String> 
  ) {
    self.first = first;
    self.last = last;
    self.age = age;
    self.retired = retired;
    self.carBrands = carBrands;
  }
  
  func fullName() -> String {
    return "\(first) \(last)";
  }
}

var user = User(
  first: "Joe",
  last: "Doe",
  age: 23,
  retired: false,
  carBrands: ["Mazda", "Toyota"]
)

print(user.first);
print(user.carBrands[1]);
print(user.fullName());

TypeScript

interface User {
  first:string,
  last:string,
  age:number,
  retired:boolean,
  carBrands: string[],
  fullName: () => string,
}

const user:User = {
  first: 'Joe',
  last: 'Doe',
  age: 23,
  retired: false,
  carBrands: ['Mazda', 'Toyota'],
  fullName: function () {
    return `${this.first} ${this.last}`
  }
}

console.log(user.first);
console.log(user.carBrands[1]);
console.log(user.fullName());

Basics

Data Structure

Iterables

Classes

Regex