Difference between primitive type and object in Java

Question

In Java, we have so-called primitive types and so-called objects. What’s the difference between the two?

Answer 1

Let’s understand In programming, what is an object?. So all data is objects.

There is a misconception that there are only objects in object-oriented programming. If this were true, what would you call what is not an object?

When you talk primitive, you’re using an adjective, so alone it doesn’t make sense. So when you use that term you’re referring to what, as being primitive? It’s a primitive object! We could call it a rudimentary object as opposed to the complex object, although some languages use the primitive term for objects that are also complex on some level.

In C# "everything" is object in the sense of OOP, i.e., "everything" derives from Object, there is no idea of primitive types. And Java has now begun to abandon this idea as well (there will still be primitive types, but it will only be a specialization of types by value that will also derive from Object). I want to see how they will call these new types that do not fit the definition of primitive and nor the object that initially the language defined, is what gives wrong define in the beginning.

Perhaps primitive types would be those that do not derive from Object. A wrong idea for a language that says totally OO.

So let’s differentiate what is derived from Object and what is a general object.

In Java, only classes could derive from Object, but this changes starting in version 14 (if nothing happens delay, it was to be in 10). Anyway all data are objects, some have taxinomy that indicates the name Object in its hierarchy, others do not possess it.

Taxonomy is hierarchical, everything has several levels of classification. Each individualized data is an object, no matter specific characteristics, some conform to Object. Object and object are different things, on different levels, define different characteristics, just have the same name.

It is often said that:

The two most difficult computing problems are cache invalidation and naming things

-- Phil Karlton.

When we have difficulties using the right names, in the right contexts we have difficulties understanding the problems correctly. That’s why OOP is so hard, it requires that you classify everything correctly to work well and if you do it wrong it’s hard to fix later. And the Internet, or even other sources, is full of wrong names (example). Only right view leads us the right way.

I’m not saying that my understanding is the right one, anyone can question it, but it’s what you use in your environment when you think about what you’re using.

The term object has always been used in all languages long before OOP became fashionable or even existed. We can’t ignore that term because fashion has decided to appropriate the term for you. Even worse if a language was poorly conceptualized and is now having difficulties explaining what is right and implementing the mechanism necessary for what it has idealized from the start.

The class-based type generates an object derived from Object. If a primitive type does not generate an object, it generates what then?

To give more context, the doubt originated in my answer (see comment also) on another AP question. So every object exists only when it is instantiated, and what changes in instantiation only depends on whether the type is by value (the bad primitive term) or by reference. Allocation cannot define whether it is an object or not, it always is, no matter if it is in stack or heap, whether you have a reference to it or not.

See more in What is considered primitive in a programming language?.

Answer 2

Java has two types of data that are divided by value (tipos primitivos) and by reference (tipos por referência).

The primitive types are boolean, byte, char, short, int, long, float e double. Reference types are classes that specify object types Strings, Primitive Arrays and Objects.

A primitive type variable can store exactly one value of its declared type at a time, when another value is assigned to that variable, its initial value will be replaced.

Primitive type instance variables are initialized by default, type variables byte, char, short, int, long, float e double are initialized as 0, and variables of type boolean are initialized as false. These types can specify their own starting value for a primitive type variable by assigning a value to the variable in its declaration.

Java provides two primitive types for storing floating point numbers in memory, the float and double type.

The difference between them is that the double variables can store numbers with greater magnitude and more details, i.e., it stores more digits to the right of the decimal fraction point, than the float variables. Float type variables represent simple precision floating point numbers and can represent up to 7 digits.

Double type variables represent double precision floating point numbers, where they need twice the amount of memory of the float variables providing 15 digits, being twice the accuracy of float variables. Double values are known as floating point literals. For precise floating point numbers, Java provides the Bigdecimal class (java.Math package).

Listing 2: Example of primitive type sizes

public class Datatypes {

public static void main(String[] args) {
    System.out.println("Tipos de dados em Java: \n" +
            "\nMenor Byte: " + Byte.MIN_VALUE +
            "\nMaior Byte: " + Byte.MAX_VALUE +
            "\nMenor Short Int: " + Short.MIN_VALUE +
            "\nMaior Short Int: " + Short.MAX_VALUE +
            "\nMenor Int: " + Integer.MIN_VALUE +
            "\nMaior Int: " + Integer.MAX_VALUE +
            "\nMenor Long: " + Long.MIN_VALUE +
            "\nMaior Long:" + Long.MAX_VALUE +
            "\nMenor Float: " + Float.MIN_VALUE +
            "\nMaior Float: " + Float.MAX_VALUE +
            "\nMenor Double: " + Double.MIN_VALUE +
            "\nMaior Double: " + Double.MAX_VALUE);

}

} Listing 3: Declaration of primitive types

public class Tipos_Primitivos {
    public static void main(String[] args) {
          byte tipoByte = 127;
          short tipoShort = 32767;
          char tipoChar = 'C';
          float tipoFloat = 2.6f;
          double tipoDouble = 3.59;
          int tipoInt = 2147483647;
          long tipoLong = 9223372036854775807L;
          boolean tipoBooleano = true;
          System.out.println("Valor do tipoByte = " + tipoByte);
          System.out.println("Valor do tipoShort = " + tipoShort);
          System.out.println("Valor do tipoChar = " + tipoChar); 
          System.out.println("Valor do tipoFloat = " + tipoFloat);
          System.out.println("Valor do tipoDouble = " + tipoDouble);
          System.out.println("Valor do tipoInt = " + tipoInt);
          System.out.println("Valor do tipoLong = " + tipoLong);
          System.out.println("Valor do tipoBooleano = " + tipoBooleano);
    }
}

In List 3 the type declared as char is always declared with simple quotes because the size is only 1 character. The float types will always have the character "f" at the end of the value for their identification, being the same thing with the long type only that is inserted the character "L".

Types by reference Programs use type variables by reference to store object locations in computer memory. These objects that are referenced can contain various instance variables and methods within the pointed object.

To bring in an object its instance methods, it is necessary to have reference to some object. Reference variables are initialized with the value "null" (null).

For example, ClasseConta acao = new ClasseConta(), creates a class object ClasseConta and the action variable contains a reference to that object ClasseConta, where you can invoke all your class methods and attributes. The new keyword prompts system memory to store an object and initializes the object.

Listing 4: Example accessing an object method

public class AcessaMetodo {

    public void imprime(){
        System.out.println("Bem Vindo ao Java!");
    }

    public static void main(String[] args) {
        AcessaMetodo acessa = new AcessaMetodo ();
        acessa.imprime();

    }

}

The output of this code above will be reproduced through the access action.imprime(), because is being accessed the method of the object that was initialized with the variable defined as "access".

Final considerations The variables of tipos por valor não referenciam objetos, these types of variables cannot be used to invoke methods. Remember that local variables are not initialized by default (variables within methods). Variables of the primitive type cannot be initialized as a reference to an object.

Source:https://www.devmedia.com.br/tipos-de-dados-por-valor-e-por-referencia-em-java/25293

Classes Wrappers in Java