[Java Introduction Notes] Java Language Basics (2): Constants, Variables and Data Types

Constants and variables

What are constants and variables?

Constants and variables are a memory space used by the program to store data while the program is running.

Constant:

The value of the constant cannot be changed while the program is running. Constants are declared in Java The final keyword must be used. Constants can also be divided into two meanings:

The first meaning is a value. This value itself can be called a constant. Here are a few examples:

Integer constant: 123

Real constant: 3.14

Character constants: 'a'

Logical constants: true, false

String constants: "helloworld"

This is just a matter of saying. For example, for the number 7, we can say "a constant of type int 7"

The second meaning represents an immutable variable. This type is also called a constant. From a grammatical perspective, it means adding final and using the final keyword to modify a variable. Then as long as the value is assigned, it cannot be changed. It cannot be assigned again

//Declare a constant i of int type final int i = 1; //Declare a constant s of String object type, the "Hello" string is also a constant final String s = "Hello";

It should be noted that a constant must be assigned a value when it is declared.

Variable:

is a memory space used to store data when the program is running. It is the most basic storage unit in the program. We can access variables using variable names.

Classification of Java variables:

According to declaration position:

Local variables

Member variables

The parameters of the method are local variables.

public class Test{  int i1 = 1; //Member variables public class static main(String[] args){ //args are the parameters of the method, so they are also local variables int i2 = 2; //Local variables} }

By data type:

Basic data type variables

Reference data type variables

public class Test{ int i = 1; //Basic data type variables String s = new String(); //Reference data type}

Steps to use variables:

Step 1: Declare a variable - open up space in memory according to type Step 2: Assign value - store data in space Step 3: Use variables - get memory The data in

We must declare and assign values ​​before using variables. Declaration and assignment can be separated or combined into one step;

If a member variable is not explicitly assigned a value when it is declared, it will be assigned a value. default value.

public class Test{ int i3; //If it is a member variable, the system will assign a value of 0 by default to it
public static void main(String[] args){ int i1; //Declare i1 = 1; //Assign value int i2 = 2; //Assign a value to it when declaring it. The value 2 is also called a "direct quantity" System.out.PRintln(i1); //Use to output the value of the variable to the Java console} }

Basic data types

Java is a strongly typed language. The so-called strong type means that each variable expression must have a certain data type at compile time. Java data types are divided into two major categories: basic types and reference types.

Reference data types are: class, interface, array. The basic data types in 基java are divided into four types of eight types, which are:

Basic data types

Numerous type

character type Char

occupation space: 2 Byte

Boolean type boolean

Occupied space: 1 bit

Integer type

Floating point type

Byte byte

short integer short

integer int

long integer long

single precision long

double double

1 byte

2 bytes

4 bytes

8 bytes

4 bytes

8 bytes

- 128～127

-32768～ 32767

-2147483648

～2147483647

-9223372036854774808

～9223372036854774807

-3.403E38

～3.403E38

-1.798E308

～1.798

Integer type

Java integer constants default to int type. To declare long type constants, you need to add L at the end.

Three expressions of Java language integer constants

Decimal integers: such as 12, -15, 0

Octal integers: requirements Starting with 0, such as 012

Hexadecimal number: It is required to start with 0x or 0X, such as 0x12

Note: Because hexadecimal value can be assigned in Java, it is similar to decimal 10 and hexadecimal A There is no difference in memory.

After Java 7, you can also use binary method to assign integer values ​​in Java.

byte b1 = 127; //Correct byte b2 = 128; //Error, out of range short = b1; //Correct, assign the value of another variable to this variable, and it does not exceed the range int i1 = 12;/ /Correct int i2 = 012; //Correct int i3 = 0x12; //Correct System.out.println(i2); //Output 10, because i2 is assigned in octal System.out.println(i3) ; //Output 18, because i3 is assigned in hexadecimal long lo = 2147483648L; //Long type declaration needs to be added

Floating point type

There are two types of Java floating point type constants Expression form:

Decimal number form: for example 3.14 314.0 .314

Scientific notation form: such as 3.14e2 3.14E2 3.14E-2

Java floating point type constant defaults to double. If you want to declare a constant as float, you need to Add F at the end because of accuracy issues, so don’t use floating point types for equality comparisons

float f1 = 123; float f2 = 123.4F; double d1 = 1234.5; double d = 3.141_592_65_36 //Correct, in order to make comparisons after java7 Long data is more readable, you can use underscores between numbers

Character type

Character type is a single character enclosed in single quotes

Java characters are encoded in Unicode, and each character occupies two bytes, so it can be expressed in hexadecimal encoding, such as char c = 'u0061';

allows the use of the escape character '' to convert the following characters into other meanings, such as char c = 'n'; newline

Commonly used escape characters in Java

char c1 = 'you'; //Correct char c2 = 'Hello'; //Incorrect char c3 = 'u9999'; //Correct System.out.println (c3); //Output '香'

The Boolean type

is used to store the "true" and "false" types, with only two values: true and false.

boolean b = true;

Data type conversion

Precision sorting: (low to high)

Byte

from low to high The system will automatically convert when high-precision is converted; when high-precision is converted to low-precision, there will be a loss of precision and must be forced to convert; during operation, different types will be automatically converted to high-precision types.

byte b = 127; short s = b; //It will be automatically converted to shortb = (byte)s; //It will not be automatically converted, it needs to be forced to convert

double constant is converted to float constant and cannot be converted when overflow occurs

public class Test {

public static void main(String[] args) throws Exception { double d = 122222222222222222222222222222222222222222222222.3; float f = ( float) d; //The value of d has exceeded the range of float, so the conversion will "overflow" , but no error will be reported during compilation

System.out.println(f); //Because overflow occurs, "Infinity" is output }

}


The system will automatically convert the value to int type during operation, and the operation Casting is required when assigning the result to the original type.

byte b1 = 1;byte b2 = (byte) (b1 + 2); //Numeric operations will be automatically converted to int, so after calculating the result, you need to force conversion when assigning the value to the byte type variable b2

If the constant value exceeds the default type, you must add the first letter of the numerical type that is larger than the default type at the end, such as long num=30000000000L; because the integer type defaults to int, but 30000000000 cannot be placed in int, so it must be added at the end Add lowercase l or uppercase L to convert to long type.

(data type name) Variable or value to be converted and Variable or value to be converted + conversion character These two conversion methods are essentially different. The former means that it is its original type in the computer, and then the It is forced to the current type, which means that it was already converted to this type in the computer from the beginning.

long lo = (long)2;long lo2 = 2L; //These two declarations or conversions are essentially different

The above is [Java entry notes] Java language basics (2): constants, variables and data types Content, please pay attention to the PHP Chinese website (www.php.cn) for more related content!