One post tagged with "molokotech"

Bio

October 11, 2024 · 3 min read

Java developer @ Opendev Pro

Sobre mi

Me presento, mi nombre es Axel, cumplo el rol de arquitecto de software en una reconocida Software Factory de Argentina, comencé mis primeros pasos en el mundo del desarrollo allá por el 2014 de software con PHP y HTML,

sin embargo la curiosidad de saber me empujó a aprender otros lenguajes hasta que conocí Java, sin duda mi lenguaje predilecto. Java me permitió crear aplicaciones desktop con Swing y JavaFX muchos años atrás cuando algunos pocos todavía demandaban este tipo de soluciones, con el tiempo los requerimientos fueron avanzando y el romanticismo por ese tipo de aplicaciones fue desapareciendo hasta caer en la realidad de las aplicaciones web, este fue un camino de ida, que pasó por dos grandes etapas, la primera del mundo monolítico con aplicaciones integradas por completo en un core y la segunda hasta hoy orientadas a microservicios.

Como profesional del código no me cierro a ningún lenguaje pero siento y quiero seguir especializandome en el lenguaje Java, uno de mis objetivos es completar certificaciones directas de Oracle, las cuales cuentan con un nivel de prestigio muy alto ya que tienen una dificultad poco común.

En mi trabajo actual pasé por varios roles, desde desarrollador en su mayoría de lenguaje Java, Angular y un poco de NodeJS, pasé por puestos de líder técnico de una o más células hasta el día de hoy que cumplo el rol de arquitecto de software, realmente me gusta lo que hago y le dedico tiempo y esfuerzo, utilizando mis tiempos libres para seguir capacitándome en nuevas tecnologías para que la aplicación que creemos el día de mañana sea mejor y más performante que la de hoy.

Gracias por leer y bienvendio a mi Blog!

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Greettings {
	
	public static void main(String[] args) throws Exception {
		ScheduledExecutorService sched = Executors.newSingleThreadScheduledExecutor();
		sched.scheduleAtFixedRate(() -> System.out.println("Wellcome to my blog"), 2, 2, TimeUnit.SECONDS); 
	}

}

Autoboxing and Unboxing

July 28, 2024 · 3 min read

Axel Berlot

Java developer @ Opendev Pro

Autoboxing is the conversion from a primitive value to a Wrapper Classes. It is a background operation outside from de programmer control, that transform primitive types creating objects without explicity creating in the code.

The simplest way:
Integer i = 1;

From behind the scenes compiler run new Integer(1) although the IDE says it's deprecated when you type it, the intention is to write cleaner code.

It runs when:

Passed as a parameter to a method that expects a value of the corresponding object wrapper type.
Assigned to a variable of the corresponding object wrapper type.

package com.molokotech.models;

public class Autoboxing {
	
	// Assigned to a variable
	void number() {
		int number = 100;
		Integer num = number;	// The compiler converts from int to new Integer
	}

	// Passed as a parameter
	void iterate() {
		List<Integer> li = new ArrayList<>();
		for (int i = 1; i < 50; i)
		    li.add(i);	// The compiler converts from int to new Integer
	}

	// Simplest examples
	void autoboxing() {
		Character c = 'c';	// char to new Character
		Integer i = 1;		// int to new Integer
	}

	/* remainder (%) and unary plus (+=) operators does'nt works with:
		Integer
		Byte
		Short
	Only primitive types are allowed for this operators so from behind the scenes always invokes i.intValue() */
	public int sum(List<Byte> li) {
		int sum = 0;
		for (Byte i : li)
			if (i % 2 == 0)
				sum += i;
			return sum;
	}

}

autoboxing

Unboxing is the conversion from an Object to a primitive value.

The simplest way:
Integer number = 100; int num = number;

Passed as a parameter to a method that expects a value of the corresponding primitive type.
Assigned to a variable of the corresponding primitive type.

package com.molokotech.models;

public class Unboxing {
	
	// Assigned to a variable
	void number() {
		Integer number = 100;
		int num = number; 	// The compiler convertes from Integer to int
	}

	// Passed as a parameter
	void iterate() {
		int[] li = new int[50];
		for (Integer i = 1; i < 50; i += 2)
			li[i] = i;
	}

}

unboxing

Java compiler run the background operation with for autoboxing and unboxing on the corresponding wrapper clases:

Primitive type	Wrapper class
boolean	Boolean
byte	Byte
char	Character
float	Float
int	Integer
long	Long
short	Short
double	Double

Access modifiers

July 27, 2024 · 3 min read

Axel Berlot

Java developer @ Opendev Pro

Access modifiers are implemented in java with four levels of abtraction.

Improves:

Security
Cleaner code
Scalability
Readability

They are aplicable to:

Classes → public | default
Interfaces → public | default
Constructors → public | default | protected | private
Class member attributes and methods → public | default | protected | private
Interface member attributes and methods → public | private

Level of visibility:

public → could be access from every pacakge
default → inside the same package only (no keyword)
protected → access from the same package and their sub classes
private → only inside the class

Default → refers at no reserve keyword just, it isn't the keyword of the example bellow because this refers to the type of member method

Classes and Interfaces could be public or default (no keyword).

Interfaces cannot have members with default or protected access modifiers, please remember that the default modifier it's not the keyword.

Real life example for access modifiers in an interface:

package com.molokotech.interfaces;

// Accesible from any package
public interface Loggueable {
	void log(); // implicitly public by default write public does not affect
	
	// private access modifier allowed but should have body
	private String colorConsole(String color) {
		switch(color) {
		case "yellow":
			return "WARN";
		case "red":
			return "ERROR";
		case "blue":
			return "INFO";
		default: 
			return "INFO";
		}
	};

	/* default methods cannot be private are always public or implicity public
	   every instance implementation should be access to it */ 
	default void labelColor(String color) {
		colorConsole(color);
	}
}

// Accesible with in the same package
interface AnotherLoggeable {
	
}

Member attributes and methods on the class can carry all types of modifiers.

public class AccessModifiers {
	
	public int n1;
	protected int n2;
	int n3;
	private int n4;	// accesible only somewhere inside the class

	public static void main(String[] args) {
		System.out.println("HOLA");
	}

	public AccessModifiers() {

	}
}

class Protected {
	protected Protected() {
		new Private(); // this NOT COMPILE at all! cannot access to the constructor outside the class
	}

}

class Default {
	Default() {
		new Protected();
	}
}

class Private {
	private Private() {
		new Default();
	}
}

It is important to note that some modifiers affects the overriding behavor.

Data Types

July 27, 2024 · 5 min read

Axel Berlot

Java developer @ Opendev Pro

sandbox.molokotech.com are powered by the Molokotech.

Java has an strong dependency with data types, it is important to understand how they works and how to use it.

Have you ever tougth why there are so many data types from different sizes? it's really easy to explain, just because when Java was created sitting on 1995 and years later, the devices were Java could installed were pretty small in memory, so the aproach to used only data types that reserves less memory was important.

Today no one is concerned by this because your phone today is faster and bigger about memory speaking than your computers.

Today it's not a problem if you choose to use a byte or an int because it does'nt have side effects on the devices.

Data Types in Java.

package com.molokotech.models;

public class DataTypes {
    private int num = 1;                // Integer wrapper Class
    private boolean isBigger = true;	// Boolean wrapper Class
    private char ch = 'j';              // Character wrapper Class
    private float f = 100;              // Float wrapper Class cast needed 100f/100F
    private long l = 5000;              // Long wrapper Class cast needed 5000l/5000L
    private short sh = 1234;            // Short wrapper Class
    private byte b = 0;	                // Byte wrapper Class
    
    // private vars can access to methods from the same class
    private void getDataType() {
        System.out.println("primitive type " + this.num + " in Java is the default for all non decimal numbers");
        System.out.println("primitive type " + this.isBigger + " default value is false");
        System.out.println("primitive type " + this.ch + " should be rounded by simple quotes default value 0 or u0000, character/letter");
        System.out.println("primitive type " + this.f + " it's used by default like int default value 0.0");
        System.out.println("primitive type " + this.l);
        System.out.println("primitive type " + this.sh);
        System.out.println("primitive type " + this.b + " values from -128/127");
    }
    
    // getDataType() should be called only from this class
    public static void main(String[] args) {
		new DataTypes().getDataType();
	}
}

result

Wrapper classes Float and Long shoud be casted when declared until it reference another variable, in this momment compile apply autoboxing strategy.

package com.molokotech.models;

public class Cast {
	
    private float f = 100;	// Float wrapper Class cast needed 100f/100F
    private long l = 5000;	// Long wrapper Class cast needed 5000l/5000L

    private void doCast() {
    	Float sh = 123f;	// must be casted -> Float sh = 123; not compile!!
    	Float shRef = this.f;   // Autoboxing when ref another variable not casting needed
    	
    	Long l = 123l; 		// must be casted -> Long l = 123; not compile!!
    	Long lref = this.l; 	// Autoboxing when ref another variable not casting needed
    }
	
}

There three rules:

Every number data-types non-decimal is treated as an int always unless it is explicitly cast.
Every number data-types decimal es treated as an double always unless it is explicitly cast.
Cannot do reference from a smaller data-type to a bigger data-type, because it does'nt fit, unless it is casted, in that case the value will try to fit passing maximun values.

The next image it's not absolute and is just note the different sizes between data types in a graphical way.

result

This code has some COMPILATION PROBLEMS related to bigger data-types trying to fit in smaller or incompatible data-types and other valid code you should copy into your IDE and make an analize it.

package com.molokotech.utils;

public class ReferenceMemory {
    
	void referenceMemoryPoints() {
    	int num1 = 1000;
    	Integer num2 = num1; // autoboxing compile
    	
    	byte num3 = 123;
    	Integer num4 = num3; // compiler knows that a byte is not an Integer -> not compile
    	
    	byte num5 = 123;
    	int num6 = num5; // num5 primitive treated as an int, fit as an int -> compile
    	
    	short num7 = 1234;
    	int num8 = num7; // num6 primitive treated as an int, fit as an int -> compile
    	
    	int num9 = 123;
    	byte num10 = num9; // num9 does'nt fit in a byte because is bigger unless be casted -> not compile
    	
    	int num11 = 123;
    	byte num12 = (byte) num11; // num11 does'nt fit in a byte because is bigger but is explicitly casted -> compile
    	
    	long num13 = 12000;
    	Integer num14 = num13; // compiler knows that a long is not an Integer -> not compile
    	
    	long num15 = 13000;
    	Integer num16 = (int) num13; // long is not an Integer but just casted -> compile
    	
    	long num17 = 900000000033333l;
    	int num18 = num17; // long cannot fit into an Integer -> not compile
    	
    	long num19 = 900000000033333l;
    	int num20 = (int) num19; // cannot fit but cast exced limits of the datatype -> compile
    	
    	int num21 = 2000;
    	byte num22 = (byte) num21;
    	System.out.println(num22); // cannot fit but cast exced limits of the datatype -> compile
    }
	
}

Viewing the results in the IDE

result

If we comment the compilation problems and run the program we see that prints a negative number even if we assign a positive number, this is because it reach out the max size of data-type and force it to assign with the cast, so it tries to fit anyway passing the limits.

max

One post tagged with "molokotech"

Intro

Sección de reflexiónes

Bienvenidos a mi sillón.

Microservicio

Ecosistema de microservicios

Monolito de microservicios distribuidos

Microservicios distribuidos en cadena

Bio

Sobre mi

Gracias por leer y bienvendio a mi Blog!

Autoboxing and Unboxing

Access modifiers

Data Types

Sección de reflexiónes​

Bienvenidos a mi sillón.​

Microservicio​

Ecosistema de microservicios​

Monolito de microservicios distribuidos​

Microservicios distribuidos en cadena​

Sobre mi​

Gracias por leer y bienvendio a mi Blog!​

Sección de reflexiónes

Bienvenidos a mi sillón.

Microservicio

Ecosistema de microservicios

Monolito de microservicios distribuidos

Microservicios distribuidos en cadena

Sobre mi

Gracias por leer y bienvendio a mi Blog!