自动装箱是 JAVA 中遵循的一个过程，其中编译器将原始数据转换为对象类型。因此，例如，如果变量被声明为“int”，则编译器会将该变量从原始整数转换为对象数据类型，并以该格式使用。还有一个过程是自动装箱的逆转，称为“拆箱”。
开始您的免费软件开发课程
网络开发、编程语言、软件测试及其他
定义：将原始数据类型的任何值转换为相应包装类的对象称为自动装箱。
语法
自动装箱使用的语法如下-
primitive_DataType variableName = 'VariableValue';
JAVA编译器采用原始数据类型并将其转换为包装类的对象。那么，只有满足以下两点，编译器才能工作：
| Primitive data type | Wrapper class |
| boolean | Boolean |
| byte | Byte |
| long | Long |
| double | Double |
| short | Short |
| char | Character |
| Int | Integer |
| float | Float |
Below are the examples of autoboxing in JAVA which are helpful to understand this concept further.
Code:
import java.io.*;
class example1
{
public static void main (String[] args)
{
//here we are creating an integer "test1" having value of "100".
Integer test1 = new Integer(100);
System.out.println("Here is the value of integer test1 which is created into object of the wrapper class integer: " + test1);
//here we are autoboxing a character "test2" with a value of "a".
Character test2 = 'a';
System.out.println("Here is the value of test2 variable after autoboxing using character wrapper class: " + test2);
}
}Output:
Explanation:
The JAVA library named “java.io” was imported so that JAVA prime functionalities can be used. First, the main class name “example1” was created containing the main function. The main function is the point where the execution of the program will start. Next, an integer named “test1” was created and assigned with the value. It is slightly different from the normal way of declaring and assigning the values; as you can see, the wrapper class “Integer” was instantiated, and the value to be assigned is passed as a parameter to the wrapper class. This process is called objectifying the primitive data type using the wrapper class. No doubt that “JAVA” is called a fully object-oriented language.
In the next section of code, the Character primitive data type is assigned to a variable named “test2” with a value “a.” This is a usual way of declaring and assigning the variable with the value. This is working because the JAVA compiler is smart enough to convert the primitive data type into an object of its wrapper class automatically in the back. This functionality is called autoboxing in JAVA.
Code:
public class BoxingWidening
{
// The function below is demonstrating the boxing functionality in JAVA.
static void testFunction(char i)
{
System.out.println("Program output for boxing:: ");
System.out.println("char in short");
}
// This function is demonstrating the widening functionality in JAVA.
static void testFunction(Character i)
{
System.out.println("Program output for widening: ");
System.out.println("Character in full");
}
public static void main(String args[])
{
char ch='a';
testFunction(ch);
}
}Output:
Explanation:
In this example, the difference between “widening” and “boxing” is demonstrated. Widening is a functionality where the full class name is used, for example, Integer or character instead of int or char. Two functions are defined with the same name, “testFunction,” one with widening and the other with boxing syntax declarations and assignments. In the main function, a character named “ch” is declared and assigned with a value “a,” and a function is called with its function name. This function has two definitions on its name. Since JAVA prefers boxing, the function’s boxing definition is called, and the parameter “ch” is passed to the boxing definition. The final result is displayed using the print() function. This function shows boxing definition in the output screen rather than taking a widening definition. Certainly, autoboxing is much powerful in comparison to the widening functionality offered by the JAVA language.
Some of the advantages derived from this useful functionality by JAVA are enlisted below:
Autoboxing is one of the best strategies to abstract complex code from the developer by adding compiler intelligence. This reduces the overhead on the developer of writing small code snippets which are not logically related. This is used so extensively by developers that the instantiating of a wrapper class is not known to many developers. Autoboxing is certainly a powerful and cleaner way of declaring and assigning the values to the variables.
以上是Java 中的自动装箱的详细内容。更多信息请关注PHP中文网其他相关文章！
