Default Value: 0<\/li>\n<\/ul>\nclass ByteProgram{\r\n public static void main(String arg[]) {\r\n byte number = 100;\r\n System.out.println("Number variable has: " + number);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\nNumber variable has: 100
\n*\/<\/p>\n<\/span>short<\/span><\/h3>\nshort data types in Java Programming is basically similar to an integer data type but with a smaller range and smaller size occupied in the memory. It is just a 16-bit signed two\u2019s complement integer data type. This data type allows a variable to store an integer value that ranges from -32768 to 32767 (inclusive). This data type can be used in situations where there is a need for storing an integer value that is typically somewhere between a few thousand.<\/p>\n
\n- Memory: 2 bytes (16-bits)<\/li>\n
- Range: -32768 to 32767<\/li>\n
- Default Value: 0<\/li>\n<\/ul>\n
class ShortProgram{\r\n public static void main(String arg[]) {\r\n short number = 31876;\r\n System.out.println("Number variable has: " + number);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\nNumber variable has: 31876
\n*\/<\/p>\n<\/span>int<\/span><\/h3>\nint data types in Java Programming is a 32-bit signed two\u2019s complement integer data type. This data type allows a variable to store an integer value that ranges from -2147483648 to 2147483647 (inclusive). This data type can be used in situations where there is a need for storing an integer value that is larger or somewhere between a few million.<\/p>\n
\n- Memory: 4 bytes (32-bits)<\/li>\n
- Range: -2147483648 to 2147483647<\/li>\n
- Default Value: 0<\/li>\n<\/ul>\n
class IntProgram{\r\n public static void main(String arg[]) {\r\n int number = 2147483643;\r\n System.out.println("Number variable has: " + number);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\nNumber variable has: 2147483643
\n*\/<\/p>\n<\/span>long<\/span><\/h3>\nlong data types in Java Programming is basically also an integer data type but with a larger range and larger memory occupied in the memory. It is a 64-bit signed two\u2019s complement integer data type. This data type allows a variable to store an integer value that ranges from 9223372036854776000 to 9223372036854775999 (inclusive). This data type can be used in situations where there is a need for storing an integer value that is very large.<\/p>\n
\n- Memory: 8 bytes (64-bit)<\/li>\n
- Range: 9223372036854776000 to 9223372036854775999<\/li>\n
- Default Value: 0<\/li>\n<\/ul>\n
class LongProgram{\r\n public static void main(String arg[]) {\r\n long number = 235634567634644565L;\r\n System.out.println("Number variable has: " + number);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\nNumber variable has: 235634567634644565
\n*\/<\/p>\n<\/span>float<\/span><\/h3>\nIn technical terms, the float is considered as a 32-bit single-precision IEEE 754 floating-point data type in Java programming. This data type allows a variable to store a numerical value that has decimal numbers after the decimal point. This data type allows the storing of a floating-point number that ranges from -3.4 E38 to 3.4 E38. Make sure that there exist only a few digits after the decimal point (around 4 or 5).<\/p>\n
\n- Memory: 4 bytes (32-bits)<\/li>\n
- Range: -3.4 E38 to 3.4 E38<\/li>\n
- Default Value: 0<\/li>\n<\/ul>\n
class FloatProgram{\r\n public static void main(String arg[]) {\r\n float number = 45764.176f;\r\n System.out.println("Number variable has: " + number);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\nNumber variable has: 45764.176
\n*\/<\/p>\n<\/span>double<\/span><\/h3>\ndouble data types in Java Programming is a 64-bit single-precision IEEE 754 floating-point data type. This data type allows a variable to store a numerical value that has decimal numbers after the decimal point. This data type allows storing of a floating-point number that ranges from -1.79 E308 to 1.79 E308. Make sure that there exist only a few digits after the decimal point (around 14 or 15).<\/p>\n
\n- Memory: 8 bytes (64-bit)<\/li>\n
- Range: -1.79 E308 to 1.79 E308<\/li>\n
- Default Value: 0<\/li>\n<\/ul>\n
class DoubleProgram{\r\n public static void main(String arg[]) {\r\n double number = 646437.8357654345;\r\n System.out.println("Number variable has: " + number);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\nNumber variable has: 646437.8357654345
\n*\/<\/p>\n<\/span>char<\/span><\/h3>\nchar data types in Java Programming is a 16-bit Unicode character data type. This data type allows a variable to store a single Unicode character. The Unicode character can be anything between \u2018\\u0000\u2019 and \u2018\\uffff\u2019 (inclusive).<\/p>\n
\n- Memory: 2 bytes (16-bits)<\/li>\n
- Range: \u2018\\u0000\u2019 to \u2018\\uffff\u2019<\/li>\n
- Default Value: None<\/li>\n<\/ul>\n
class CharProgram{\r\n public static void main(String arg[]) {\r\n char ch = '&';\r\n System.out.println("Ch variable has: " + ch);\r\n }\r\n}<\/pre>\n\/* Output
\nCh variable has: &
\n*\/<\/p>\n
<\/span>boolean<\/span><\/h3>\nboolean data types in Java Programming is a data type that is used to store flag values. This data type doesn\u2019t have a fixed memory allocation size but it is assumed to a 1-bit. It allows storing a single character in a variable either true or false at a time.<\/p>\n
\n- Memory: 1-bit (Assumed)<\/li>\n
- Range: Only \u2018true\u2019 and \u2018false\u2019<\/li>\n
- Default Value: false<\/li>\n<\/ul>\n
class BooleanProgram{\r\n public static void main(String arg[]) {\r\n boolean flag = true;\r\n System.out.println("Flag variable has: " + flag);\r\n }\r\n}<\/pre>\n\/* Output
\nFlag variable has: true
\n*\/<\/p>\n
<\/span>Non-primitive Data Type<\/span><\/h2>\nData Types in Java Programming is second data type of non-primitive data type. Non-Primitive data types are those types that are actually not defined in the Java programming language but a programmer needs to explicitly define these data types to the Java compiler. They can also be used directly in a program to store values (just like primitive data types). For now, we will just scratch the surface of these data types, but we will them in-depth in our future tutorials.<\/p>\n
<\/span>String<\/span><\/h3>\nThe string data types in Java Programming is a non-primitive data type that stores a bunch of characters in a sequence. Strings can be used to form words or sentences as needed by the programmer\/developer. A string can just be a character, word, line, or just a blank space. If we say a word say “pencil”, then “pencil” is a valid string. A string can be composed of alphabets, numbers, and special characters. A string is represented with “” symbols.
\nSome examples of a string are:<\/p>\n
\n- “Jupiter”<\/li>\n
- “hello123”<\/li>\n
- “money$”<\/li>\n<\/ul>\n
class StringProgram{\r\n public static void main(String arg[]) {\r\n String letter = "a";\r\n String word = "Mountain";\r\n String line = "This is awesome";\r\n String_mixed = "Mountain 33.35 with a symbol @";\r\n System.out.println("Print a letter: " + letter);\r\n System.out.println("Print a word: " + word);\r\n System.out.println("Print a line: " + line);\r\n System.out.println("Print a mixed line: " + mixed);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\nPrint a letter: a
\nPrint a word: Mountain
\nPrint a line: This is awesome
\nPrint a mixed line: We have 192 paper bags of $0.24 each
\n*\/<\/p>\n<\/span>Array<\/span><\/h3>\nAn array data types in Java Programming is also a non-primitive data type that holds a single type of data. The elements of an array will always have the same data type and it will not be changed for just one element. The elements of an array are structured in a sequential order where each element of the array can be accessed using its index value (starting from zero). There is no fixed size for an array as we see in primitive data types.<\/p>\n
class ArrayProgram{\r\n public static void main(String arg[]) {\r\n String[] simpleItems = {"Bricks", "Cake", "Noise", "Humor"};\r\n System.out.println("1st element of simpleItems array: " + simpleItems [0]);\r\n System.out.println("2nd element of simpleItems array: " + simpleItems [1]);\r\n System.out.println("3rd element of simpleItems array: " + simpleItems [2]);\r\n System.out.println("4th element of simpleItems array: " + simpleItems [3]);\r\n System.out.println();\r\n\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\n1st element of simpleItems array: Bricks
\n2nd element of simpleItems array: Cake
\n3rd element of simpleItems array: Noise
\n4th element of simpleItems array: Humor
\n*\/<\/p>\nIn the above program, the array \u201csimpleItems \u201d is of type \u201cString\u201d which means it can only store String type value in it. The elements initialized to \u201csimpleItems\u201d array are “Bricks”, “Cake”, “Noise” and \u201cHumor\u201d. These elements can be accessed using their index values starting from zero.<\/p>\n
\n- At index 0, the element in the array is “Bricks”.<\/li>\n
- At index 1, the element in the array is “Cake”.<\/li>\n
- At index 2, the element in the array is “Noise”.<\/li>\n
- At index 3, the element in the array is “Humor”.<\/li>\n<\/ul>\n
<\/span>Class<\/span><\/h3>\nIn Java, everything is based on classes and objects. These classes are like \u201cblueprints\u201d which come to existence when their objects are created. Basically, a class can have variables and methods which are related to that class. Let\u2019s try to understand a class with a simple example.<\/p>\n
class Plastic {\r\n public int cost = 200;\r\n public String strength = "weak";\r\n}\r\nclass ClassProgram {\r\n public static void main(String[] args) {\r\n Plastic p = new Plastic();\r\n System.out.println(p.cost);\r\n System.out.println(p.strength);\r\n }\r\n}<\/pre>\n\/* Output<\/strong>
\n200
\nweak
\n*\/<\/p>\nIn the above program, we have two classes namely “Plastic” and “ClassProgram”. The “ClassProgram” class is just used to contain the “main” method.<\/p>\n
Here, the “Plastic” class has two variables that are related to that class. They are “cost” and “strength”. Both these variables are trying to tell the cost of the plastic material as well as the strength of that plastic material.<\/p>\n
In the main method, we are creating an object of the Plastic class and storing the reference of the object in a variable name “p”. This “p” variable can be used to access the variables and functions of an object (in this case “cost” and “strength”). The main method also has two more statements that show how we are printing the values of the variables of the “p” object.<\/p>\n
<\/span>Interface<\/span><\/h3>\nAn interface data types in Java Programming is basically like a contract that guarantees that there is a function in the class that is specified in the interface.
\nConsider an interface that has a method declaration for the method \u201chello\u201d. If this interface is implemented in a class, then it is mandatory that this class should also implement the method \u201chello\u201d. If we just implement the interface to a class and not implement its functions, then the compiler throws an error and the program won\u2019t compile.<\/p>\n
Example 1:<\/strong><\/p>\npublic interface IHello {\r\n public void sayHello();\r\n}\r\nclass InterfaceProgram implements IHello{\r\n public static void main(String[] args) {\r\n }\r\n}<\/pre>\n\/\/ This program throws an error because we implemented the IHello interface but didn’t implement its method sayhello()<\/p>\n
Example 2:<\/strong><\/p>\ninterface IHello {\r\n public void sayHello();\r\n}\r\nclass InterfaceProgram implements IHello{\r\n public void sayHello() {\r\n System.out.println("Hello");\r\n }\r\n public static void main(String[] args) {\r\n }\r\n}<\/pre>\n\/\/ This program will not throw any error and compile successfully<\/p>\n","protected":false},"excerpt":{"rendered":"
In this tutorial, we will be learning about Data types in Java programming, and the various data types available in the Java programming language. We will mainly focus on various data types, their memory allocation size, and their range. Data Types in Java Programming Data types in Java programming are one of the basic building […]<\/p>\n","protected":false},"author":1,"featured_media":219,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6],"tags":[],"class_list":{"0":"post-218","1":"post","2":"type-post","3":"status-publish","4":"format-standard","5":"has-post-thumbnail","7":"category-java-programming"},"_links":{"self":[{"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/posts\/218","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/comments?post=218"}],"version-history":[{"count":0,"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/posts\/218\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/media\/219"}],"wp:attachment":[{"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/media?parent=218"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/categories?post=218"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/usemynotes.com\/wp-json\/wp\/v2\/tags?post=218"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}