Casting int to long

[Jeena Jeen]

  
    int i =1;
	public void testPrimitive(byte b){ //1
		System.out.println("byte");
	}
	public void testPrimitive(float f){//2
		System.out.println("float");
	}
	public void testPrimitive(long l){//3
		System.out.println("long");
	}
	public void testPrimitive(double d){//4
		System.out.println("double");
	}
	public static void main(String[] args) {
	testPrimitive(i);
	}
  

The output of this code is "long". I am not sure why this output. I was expecting in to produce output "float". If I remove method 3 output becomes "float". Please can anyone explain what is the logic behind this?

[Devaka Cooray]

The ordering is, byte->short->int->long->float->double.

That is the basic reason of this output.

[Jeena Jeen]

ouch... it was so simple.
Thanks a lot

[armando fonseca]

Also, char -> int -> foat -> double

[Shin Kudo]

Jeena Jeen wrote:

  
    int i =1;
	public void testPrimitive(byte b){ //1
		System.out.println("byte");
	}
	public void testPrimitive(float f){//2
		System.out.println("float");
	}
	public void testPrimitive(long l){//3
		System.out.println("long");
	}
	public void testPrimitive(double d){//4
		System.out.println("double");
	}
	public static void main(String[] args) {
	testPrimitive(i);
	}

How come does this code produce output? It doesn't even compile!

[Albert Kam]

Hello all,

I modified the source to make sure that char fits into an int
(both char n int use 32 bits, although char only makes use of 16 bits for it's value)

/*
 * Created on Apr 21, 2009
 *
 */
package scjp;

/**
 * @author albert
 *
 */
public class ArgumentTypeMatching {
    // integers
    public static void testPrimitive(byte b){  
        System.out.println("byte");  
    }  
    public static void testPrimitive(short b) {  
        System.out.println("short");  
    }  
    public static void testPrimitive(int l) {  
        System.out.println("int");  
    }  
    public static void testPrimitive(long l) {  
        System.out.println("long");  
    }  
    
    // floating points
    public static void testPrimitive(float f) {
        System.out.println("float");  
    }  
    public static void testPrimitive(double d) {  
        System.out.println("double");  
    }  
    
    public static void main(String[] args) {
        char i = 'a';
        testPrimitive(i);  
    }  
}

Regards,
Albert Kam

[Jeena Jeen]

Sorry Shin I just copied the relevant part of the code. The complete code is:

    

package practiceSCJP;

public class TestPrimitiveConvertion {
	static int i =1;	
	public void testPrimitive(byte b){
		System.out.println("byte");
	}
	public void testPrimitive(float f){
		System.out.println("float");
	}
	public void testPrimitive(long l){
		System.out.println("long");
	}
	public void testPrimitive(double d){
		System.out.println("double");
	}
	public static void main(String[] args) {
		TestPrimitiveConvertion tpc = new TestPrimitiveConvertion();
		tpc.testPrimitive(i);
	}

}

[Jeena Jeen]

armando fonseca wrote:Also, char -> int -> foat -> double

Hi armando !
I think You forgot long in the list. So for char it should be:
char ->int ->long -> float -> double

[Ankit Garg]

Actually the correct way to depict implicit type cast is this

                  char
                   |
                  \/
byte -> short -> int -> long -> float -> double

You don't need to have separate chains for numeric types and char

[Ruben Soto]

That's exactly how I think about it. The picture basically condenses all possible transitions allowed for primitive widening conversion.

[armando fonseca]

Jeena Jeen wrote:

armando fonseca wrote:Also, char -> int -> foat -> double

Hi armando !
I think You forgot long in the list. So for char it should be:
char ->int ->long -> float -> double

You are right!
and true , is only one chaining!