Studying Java-Part 4-Literal

1.First of all

This time about "literal". Also, I will talk about the type combined with the literal.

Some of you may remember that literals were mentioned in the article Study Java-Part 2-Variables.

2. What is a literal?

Let me explain about literals.

Literals are the values described in the source code. And that literal is a constant, and you have to rewrite the source code directly to change it.

For example, it refers to "1", "'A'", and "3.14159265" in the following source code.

Main.java

public class Main {
	public static void main(String[] args) {

		int number = 1;
		char ch = 'A';
		double pi = 3.14159265;

	}
}

3. A literal that matches the mold

Next, I will introduce literals that match the type. Also, you can add the source code of the assignment to the type that matches it.

Byte and short are basically the same as int type, so only int is used.

Main.java

public class Main {
	public static void main(String[] args) {

		//Integer int
		int integerValue;
		//Ordinary integer
		integerValue = 100;

		//Integer long
		long longValue;
		//For long, add l or L
		longValue = 1000l;

		//Floating point number float
		float floatValue;
		//For float, add f or F
		floatValue = 655.36f;

		//Floating point double
		double doubleValue;
		//For double, add d or D
		doubleValue = 512.256d;

		//Character char
		char characterValue;
		//Character''(Single quote)Surround with
		characterValue = 'A';

		//Boolean boolean
		boolean booleanValue;
		//Only true or false can be assigned
		booleanValue = true;

		//String String
		String stringValue;
		//The string is""(Double quotation)Surround with
		stringValue = "Hello!!";
	}
}

The right side at the time of substitution is a literal. Actually, there are other ways to write it, but I think it's enough to remember this for the time being.

4. n-ary literals

In general, there are four ways to write integer literals: binary, octal, decimal, and hexadecimal.

Decimal numbers are the way we usually write. Express using numbers from 0 to 9.

The problem is other than decimal numbers.

4.1. Binary literals

Binary numbers are represented only by the numbers 0 and 1. Java distinguishes between binary literal values by prefixing them with "0b". A binary number is something like "0b11001".

Here is a brief list of decimal and binary numbers.

4.2. 8-base literals

Eighth numbers are represented using numbers from 0 to 7. Java can be distinguished from an octal number by prefixing it with "0" when writing it as a literal value. If you use something like "0115", it is an octal number.

Here is a brief list of decimal and octal numbers.

4.2. Hexagonal literals

Next is the hexadecimal number. Hexagonal numbers are represented using numbers and letters from 0 to f. Keep in mind that hexadecimal numbers are often used when touching a computer.

When writing as a literal value, prefix it with "0x".

Here is a brief list of decimal and hexadecimal numbers.

5. Conclusion

Literals pop up on the source here and there. It is recommended to assign literals to variables (or constants) as much as possible before using them. Because it is related to the readability of the source.

~~ By the way, I call it "raw value on the source". You can't use it even though you have words properly lol ~~

Also, n-ary numbers are mathematical. It should be difficult for beginners. ~~ I hate octal numbers ~~

About this ...

Next, I will talk about "constants".

Next time → "Study Java-Part 5-Constant"