使用自动装箱和Java扩展的方法重载

作者: Arvin Chen 分类: Java 来源: Break易站(www.breakyizhan.com)

使用自动装箱和Java扩展的方法重载

在Java中有两种类型的变量:基本类型和引用类型。将原始类型转换为其对应的包装对象称为自动装箱,并将包装对象与其相应的基本类型称为拆箱。

方法重载与Autoboxing

在方法重载中,你可能会遇到一种情况,即将引用类型或基本类型作为形式参数。编译器首先搜索具有相同数据类型参数的方法。如果使用包装类Object作为实际参数,并且编译器未找到具有相同引用类型(即类或接口类型)的参数的方法,则它会开始搜索具有相应参数的方法原始数据类型。

// Java program to illustrate 
// Autoboxing
// while resolving data type as:
// a)reference b)primitive 
import java.io.*;

public class Conversion 
{
	
	// 1.overloaded method with primitive formal argument
	public void method(int i)
	{
		
		System.out.println("Primitive type int formal argument :" + i);
	}
	
	// overloaded method with reference formal argument
	public void method(Integer i)
	{
		
		System.out.println("Reference type Integer formal argument :" + i);
	}
	
	// 2. overloaded method primitive formal argument
	// and to be invoked for wrapper Object as overloaded method
	// with wrapper object of same(Long) type as an argument is not 
	// available.
	public void method(long i)
	{
		
		System.out.println("Primitive type long formal argument :" + i);
	}
}

class GFG 
{
	
	public static void main (String[] args) 
	{
		Conversion c = new Conversion();
		
		// invoking the method with different signature.
		c.method(10);
		c.method(new Integer(15));
		c.method(new Long(100));
		
		// Using short will give, argument mismatch;
		// possible lossy conversion from int to short
		// c.method(new Short(15));
		
	}
}

输出:

Primitive type int formal argument :10
Reference type Integer formal argument :15
Primitive type long formal argument :100

方法重载与拓宽

如果编译器无法找到与自动装箱相对应的任何方法,那么它将开始搜索扩展原始数据类型的方法参数。
在下面的示例中,我们使用与实际参数的数据类型具有相同数据类型的primitive(int)形式参数调用重载方法。我们使用Long包装对象的参数调用另一个方法。编译器开始搜索具有相同引用类型(Long包装类)的方法。由于没有Long包装类的参数的方法。因此,它搜索的方法可以接受大于长基元数据类型的参数作为参数。在这种情况下,它找到一个具有浮点基元数据类型的方法并调用它。

// Java program to illustrate method 
// overloading 
// in case of widening
import java.io.*;

public class Conversion 
{
	// overloaded method
	public void method(int i)
	{
		System.out.println("Primitive type int formal argument :" + i);
	}
	
	// overloaded method primitive formal argument
	// and to be invoked for wrapper Object as 

	public void method(float i)
	{
		
		System.out.println("Primitive type float formal argument :" + i);
	}
}

class GFG 
{
	
	public static void main (String[] args)
	{
	
		Conversion c = new Conversion();
		
		// invoking the method with signature
		// has widened data type
		c.method(10);
		c.method(new Long(100));
	}
}

输出:

Primitive type int formal argument :10
Primitive type float formal argument :100.0

 

原始类型的扩展比和var-args优先。但是扩展和原始类型的装箱不能一起工作。

// Java program  to illustrate method 
// overloading for widening
// and autoboxing together
import java.io.*;

public class Conversion 
{
	// overloaded method with refernce type formal argument
	public void method(Integer a)
	{
		
		System.out.println("Primitive type byte formal argument :" + a);
	}
	
}

class GFG 
{
	
	public static void main (String[] args) 
	{
	
		Conversion c = new Conversion();
		
		// invoking the method 
		byte val = 5;
		c.method(val);
	}
}

输出:

25: error: incompatible types: byte cannot be converted to Integer
	    c.method(val);
	             ^
 Some messages have been simplified; recompile with -Xdiags:verbose to get full output
1 error

但是,如果传递给Object类型的引用,则可以接受加宽的装箱。请参阅以下示例。

// Java program to illustrate
// autoboxing followed by 
// widening in refernce type
// variables
import java.io.*;

public class Conversion 
{
	
	// overloaded method with refernce type
	// formal argument
	public void method(Object b)
	{
		
		// Object b is typecasted to Byte and then printed 
		Byte bt = (Byte) b;
		System.out.println("refernce type formal argument :" + bt);
	}
	
}

class GFG 
{
	
	public static void main (String[] args) 
	{
	
		Conversion c = new Conversion();
	
		byte val = 5;
		
		// b is first widened to Byte 
		// and then Byte is passed to Object. 
		c.method(val);
	}
}

输出:

Primitive type byte formal argument :5

用Var-args参数重载方法

原始类型的扩展优先于var-args。
例:

// Java program to illustrate
// method overloading for var-args
// and widening concept together
import java.io.*;

public class Conversion
{
	// overloaded method primitive(byte) var-args formal argument
	public void method(byte... a)
	{
		System.out.println("Primitive type byte formal argument :" + a);
	}
	
	// overloaded method primitive(int) formal arguments
	public void method(long a, long b)
	{
	    System.out.println("Widening type long formal argument :" + a);
	}
}

class GFG 
{
	
	public static void main (String[] args)
	{
		Conversion c = new Conversion();
		
		// invokes the method having widening 
		// primitive type parameters.
		byte val = 5;
		c.method(val,val);
	}
}

输出:

Widening type long formal argument :5
  •   本文标题:使用自动装箱和Java扩展的方法重载 - Break易站
    转载请保留页面地址:https://www.breakyizhan.com/java/4142.html

    发表笔记

    电子邮件地址不会被公开。 必填项已用*标注

    更多阅读