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

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

    使用自动装箱和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 包装类
  •   本文标题:使用自动装箱和Java扩展的方法重载 - Break易站
    转载请保留页面地址:https://www.breakyizhan.com/java/4142.html
      微信返利机器人
      免费:淘宝,京东,拼多多优惠券
      腾讯,爱奇艺,优酷的VIP视频免费解析,免费看
      即刻扫描二维码,添加微信机器人!

    发表笔记

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