第五章数据类型转换、运算符、方法_类型转换运算符原理-优快云博客

本文链接：https://blog.youkuaiyun.com/LLLlucky_boy/article/details/118854147

本文详细介绍了Java中的数据类型转换、运算符以及方法的相关知识。包括数据类型的自动与强制转换规则、常见运算符的使用方法，以及方法定义与调用的详细步骤。适合Java初学者快速掌握基础知识。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java基础入门05

第五章（数据类型转换、运算符、方法）
总结

第五章（数据类型转换、运算符、方法）

5.1 数据类型转换

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

5.1.1 自动转换

一个 int 类型变量和一个 byte 类型变量进行加法运算，结果会是什么数据类型？

int i = 1; 
byte b = 2;

运算结果，变量的类型将是 int 类型，这就是出现了数据类型的自动类型转换现象。

自动转换：将取值范围小的类型自动提升为取值范围大的类型。

public static void main(String[] args) { 
int i = 1; 
byte b = 2; 
// byte x = b + i; // 报错 
//int类型和byte类型运算，结果是int类型 
int j = b + i; 
System.out.println(j); 
}

转换原理图解

byte 类型内存占有1个字节，在和 int 类型运算时会提升为 int 类型，自动补充3个字节，因此计算后的结果还是 int 类型。
在这里插入图片描述
同样道理，当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。

public static void main(String[] args) { 
int i = 1; 
double d = 2.5; 
//int类型和double类型运算，结果是double类型 
//int类型会提升为double类型 
double e = d+i; 
System.out.println(e); 
}

转换规则

范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为 int 。

byte、short、char-->int-->long-->float-->double

5.1.2 强制转换

将 1.5 赋值到 int 类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 1.5; // 错误

double 类型内存8个字节， int 类型内存4个字节。 1.5 是 double 类型，取值范围大于 int 。可以理解为 double 是8升的水壶， int 是4升的水壶，不能把大水壶中的水直接放进小水壶去。

想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。

强制类型转换：将 取值范围大的类型 强制转换成 取值范围小的类型 。
比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

转换格式：

数据类型 变量名 = （数据类型）被转数据值；

将 1.5 赋值到 int 类型，代码修改为：

	// double类型数据强制转成int类型，直接去掉小数点。
	 int i = (int)1.5;

同样道理，当一个 short 类型与 1 相加，我们知道会类型提升，但是还想给结果赋值给short类型变量，就需要强制转换。

public static void main(String[] args) { 
//short类型变量，内存中2个字节 
short s = 1; 
/*出现编译失败 s和1做运算的时候，1是int类型，
s会被提升为int类型 s+1后的结果是int类型，
将结果在赋值会short类型时发生错误 short内存2个字节，
int类型4个字节 必须将int强制转成short才能完成赋值 */
s = s + 1；//编译失败 
s = (short)(s+1);//编译成功 }

转换原理图解

在这里插入图片描述

5.1.3 ASCII编码表

public static void main(String[] args) { 
//字符类型变量 
char c = 'a'; 
int i = 1; 
//字符类型和int类型计算 
System.out.println(c+i);
//输出结果是98
 }

在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。

编码表：就是将人类的文字和一个十进制数进行对应起来组成一张表格。
存储字符时：需要查找编码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中
使用字符时：将对应的二进制数转换为十进制找到编表中对应的字符显示出来人们就规定：

将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII（
American Standard Code for Information Interchange 美国标准信息交换码）。

小贴士：
在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。

5.2 运算符

5.2.1 算数运算符

运算符和表达式
- 运算符：对常量或者变量进行操作的符号
- 表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
不同运算符连接的表达式体现的是不同类型的表达式。
举例说明：
- +：是运算符，并且是算术运算符。
- a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。
  
  Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。

public static void main(String[] args) { 
int i = 1234; 
System.out.println(i/1000*1000);//计算结果是1000
 }

+符号在字符串中的操作：
- +符号在遇到字符串的时候，表示连接、拼接的含义
- 3"+“5”,3+“5"或者"3”+5的结果都是是“35”，连接含义

public static void main(String[] args){
 System.out.println("5+5="+5+5);//输出5+5=55 
 }

5.2.2 赋值运算符

在这里插入图片描述

赋值运算符，就是将符号右边的值，赋给左边的变量。

public static void main(String[] args){ 
	int i = 5; 
	i+=5;
//计算方式 i=i+5 变量i先加5，再赋值变量i 
	System.out.println(i); //输出结果是10 
}

+=符号的扩展
下面的程序有问题吗？

public static void main(String[] args){ 
	short s = 1; 
	s+=1; 
	System.out.println(s); 
}

分析： s += 1 逻辑上看作是 s = s + 1 计算结果被提升为int类型，再向short类型赋值时发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型。但是， s=s+1进行两次运算， += 是一个运算符，只运算一次，并带有强制转换的特点，也就是说 s += 1 就是 s = (short)(s + 1) ，因此程序没有问题编译通过，运行结果是2.

5.2.3 自增自减运算符

在这里插入图片描述

++ 运算，变量自己增长1。反之， – 运算，变量自己减少1，用法与 ++ 一致。
- 独立操作:
  - 变量在独立操作时前++ 和后++ 没有区别
  - 变量前++ ：例如 ++i 。
  - 变量后++ ：例如 i++ 。
- 混合操作
  - 和其他操作放在一起，前++ 和后++ 就产生了不同。
  - 变量前++ ：先给自己加1 , 然后再参与其他操作。例如 : 下面代码中变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。
  - 变量后++ ：先参与其他操作 , 然后再给自己加1。例如 : 下面代码中变量a先把自己的值赋值给变量b，此时变量b的值就是1，然后变量a自己再加1。a的结果2，b的结果是1。

变量前++：

public static void main(String[] args) { 
int a = 1; 
int b = ++a; 
System.out.println(a);//计算结果是2 
System.out.println(b);//计算结果是2 
}

变量后++：

public static void main(String[] args) { 
int a = 1; int b = a++; 
System.out.println(a);//计算结果是2 
System.out.println(b);//计算结果是1 
}

5.2.4 关系运算符

关系运算符有6种关系，分别为小于、小于等于、大于、等于、大于等于、不等于。
在这里插入图片描述

关系运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。

public static void main(String[] args) { 
System.out.println(1==1);//true 
System.out.println(1<2);//true 
System.out.println(3>4);//false 
System.out.println(3<=4);//true 
System.out.println(3>=4);//false 
System.out.println(3!=4);//true 
}

5.2.5 逻辑运算符

逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是true 或 false。
在这里插入图片描述

public static void main(String[] args) { 
//定义变量 
 	int i = 10;
 	int j = 20; 
 	int k = 30;
 //& “与”，并且的关系，只要表达式中有一个值为false，结果即为false
 	System.out.println((i > j) & (i > k)); //false & false,输出false 
 	System.out.println((i < j) & (i > k)); //true & false,输出false 
 	System.out.println((i > j) & (i < k)); //false & true,输出false 
 	System.out.println((i < j) & (i < k)); //true & true,输出true
 	System.out.println("........");
 	//| “或”，或者的关系，只要表达式中有一个值为true，结果即为true 
 	System.out.println((i > j) | (i > k)); //false | false,输出false 
 	System.out.println((i < j) | (i > k)); //true | false,输出true 
 	System.out.println((i > j) | (i < k)); //false | true,输出true 
 	System.out.println((i < j) | (i < k)); //true | true,输出true 
 	System.out.println("........"); //^ “异或”，相同为false，不同为true 
 	System.out.println((i > j) ^ (i > k)); //false ^ false,输出false 
 	System.out.println((i < j) ^ (i > k)); //true ^ false,输出true 
 	System.out.println((i > j) ^ (i < k)); //false ^ true,输出true 
 	System.out.println((i < j) ^ (i < k)); //true ^ true,输出false 
 	System.out.println("........"); 
 	//! “非”，取反 
 	System.out.println((i > j)); //false 
 	System.out.println(!(i > j)); //!false，,输出true 
 	}

短路逻辑运算符
在这里插入图片描述

逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false

public static void main(String[] args) { 
	int x = 3; 
	int y = 4; 
	System.out.println((x++ > 4) & (y++ > 5)); // 两个表达式都会运算 
	System.out.println(x); // 4 
	System.out.println(y); // 5 
	System.out.println((x++ > 4) && (y++ > 5)); // 左边结果为false，右边不参与运算 
	System.out.println(x); // 4 
	System.out.println(y); // 4 }

5.2.6 三元运算符

三元运算符格式:

 数据类型 变量名 = 布尔类型表达式？结果1：结果2

三元运算符计算方式：
- 布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量
- 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

为了便于阅读 , 可以给三元运算符添加括号

public static void main(String[] args) { 
	int a = 200； 
	int b = 100； 
	int max = (a>b ? a : b);//max赋值为 a，b中较大的值 		
	System.out.println(max);//200 
	int min = (a<b ? a : b);//min赋值为 a，b中较小的值 
	System.out.println(min);//100 
	}

三元运算符案例
- 需求1：动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

public class OperatorTest01 { 
public static void main(String[] args) 
{ //1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。 
	int weight1 = 180; 
	int weight2 = 200; 
	//2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。 
	boolean b = (weight1 == weight2 ? true : false); 
	//3：输出结果 
	System.out.println("b:" + b); b:false 
	} 
	}

需求2：一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，请用程序实现获取这三个和尚的最高身高。

public class OperatorTest02 { 
public static void main(String[] args) { 
	//1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。 
	int height1 = 150; 
	int height2 = 210; 
	int height3 = 165; 
	//2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。 
	int tempHeight = height1 > height2 ? height1 : height2; 
	//3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。 
	int maxHeight = tempHeight > height3 ? tempHeight : height3; 
	//4：输出结果 
	System.out.println("maxHeight:" + maxHeight); 
	} 
	}

5.3 方法

5.3.1 方法入门

5.3.1.1 概述

假如我们使用循环在一段程序中实现在控制台上打印3次helloworld、再打印5次helloworld , 我们会在main方法中编写两段for循环语句 , 若要再来3个打印多次呢 ? 这个时候我们会发现这样编写代码非常的繁琐且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。

方法：就是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

5.3.1.2 无参数无返回值的方法定义

方法完整的定义格式

修饰符 返回值类型 方法名 （参数列表）｛ 
	代码... 
	return 结果; 
｝

定义格式解释：
- 修饰符：目前固定写法 public static ,后面章节再详细讲解。
- 返回值类型：目前固定写法 void ，其他返回值类型在后面讲解。
- 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。
- 参数列表：目前无参数，带有参数的方法在后面讲解。
- return：方法结束。因为返回值类型是void，方法大括号内的return可以不写。
无参数无返回值的方法定义格式就简化为:

修饰符 void 方法名 （）｛
 		代码... 
 ｝

举例

public static void methon()
{
	System.out.println("这是一个方法");
}

注意：方法必须先定义，后调用，否则程序将报错，而且方法不调用不执行

5.3.1.3 无参数无返回值的方法的调用

方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。

调用格式：

方法名();

举例
```
  method();
```

5.3.1.4 无参数无返回值的方法的调用图解

public static void main(String[] args) { 
//调用定义的方法
method method(); 
}
//定义方法，被main方法调用 
public static void method() 
{
 System.out.println("这是一个方法"); 
 }

在这里插入图片描述

总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。

5.3.1.5 无参数无返回值的方法练习

需求1：定义一个方法，打印输出该方法内部的数据(方法内部定义的变量)是否是偶数
思路：
- ①定义一个方法，用于打印该方法内部的数字是否是偶数，例isEvenNumber()
- ②方法中定义一个变量，用于保存一个数字
- ③使用if语句判断数字是否是偶数，并打印结果
- ④在main()方法中调用定义好的方法
代码：

public class MethodDemo { 
public static void main(String[] args) { 
//调用方法 
isEvenNumber(); 
}
//需求：定义一个方法，在方法中定义一个变量，判断该数据是否是偶数 
public static void isEvenNumber() {
 //定义变量 
 int number = 10;
 //number = 9; 
 //判断该数据是否是偶数 
 if(number%2 == 0) 
 { System.out.println(true); 
 } else 
 { System.out.println(false); 
 } 
 } 
 }

需求2：定义一个方法，打印该方法内部的两个数据(方法内部定义的变量)的最大值
思路：
- ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
- ②方法中定义两个变量，用于保存两个数字
- ③使用分支语句分两种情况对两个数字的大小关系进行处理
- ④在main()方法中调用定义好的方法
代码

public class MethodTest { 
public static void main(String[] args) { 
//在main()方法中调用定义好的方法 
getMax(); 
}
//定义一个方法，用于打印两个数字中的较大数，例如getMax() 
public static void getMax() 
{ 
//方法中定义两个变量，用于保存两个数字 
int a = 10; 
int b = 20; 
//使用分支语句分两种情况对两个数字的大小关系进行处理 
if(a > b) {
 System.out.println(a); 
 } else { 
 System.out.println(b); 
 } 
 } 
 }

5.3.2 方法详解

5.3.2.1 定义方法的格式详解


修饰符 返回值类型 方法名(参数列表){ 
//代码省略... 
return 结果; 
}

修饰符：目前固定写法 public static ,后面章节再详细讲解。
返回值类型：表示方法运行的结果的数据类型，方法执行后将结果返回到调用者
参数列表：方法在运算过程中的未知数据，调用者调用方法时传递
return：将方法执行后的结果带给调用者，方法执行到 return ，整体方法运行结束
小贴士：return 结果; 这里的"结果"在开发中，我们正确的叫法成为方法的返回值

5.3.2.2 定义方法的三个明确

明确方法名称：给方法起个名字，方便调用，只要符合标识符规则就可以，尽量做到见名知意
明确返回值类型：例如方法计算的是整数的求和，结果也必然是个整数，返回值类型定义为int类型。
明确参数列表：例如计算两个整数的和,具体计算哪两个整数的和并不清楚，但可以确定是整数，参数列表可以定义两个int类型的变量，由调用者调用方法时传递

5.3.2.3 带参数的方法定义

定义格式：
参数：数据类型变量名
参数范例：int a

public static void 方法名 (参数1) 
{ 
方法体; 
}
public static void 方法名 (参数1, 参数2, 参数3...) 
{
 方法体; 
 }

范例

public static void printSum(int a,int b)
{ 
int sum = a + b; 
System.out.println(sum); 
}

注意
- 方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
- 方法定义时，多个参数之间使用逗号( ，)分隔

5.3.2.4 带参数的方法调用

调用格式：

方法名(参数);
方法名(参数1，参数2);

范例

printSum(5,6);

5.3.2.5 带参数的方法调用流程图解

public static void main(String[] args) { 
	//调用定义的方法method 
	printSum(5,6); 
	}
//定义方法，被main方法调用 
public static void printSum(int a,int b){ 
	int sum = a + b; 
	System.out.println(sum); 
	}

在这里插入图片描述

5.3.2.6 带参数的方法练习

需求1：定义一个方法，该方法接收一个参数，方法内部打印是输出该数据是否是偶数

思路：
- ①定义一个方法，用于打印该方法内部的数字是否是偶数，例isEvenNumber()
- ②为方法定义一个变量作为方法参数，用于接收一个数字
- ③方法内部使用if语句判断数字是否是偶数，并打印结果
- ④在main()方法中调用定义好的方法,传递方法需要的参数(常量/变量)

代码：

public class MethodDemo { 
public static void main(String[] args) 
{ 
//常量值的调用 
isEvenNumber(10); 
//变量的调用
 int number = 10; 
 isEvenNumber(number); 
 }
 //需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数 
 public static void isEvenNumber(int number) 
 { 
 if(number%2 == 0) 
 { System.out.println(true); 
 } else 
 { System.out.println(false);
 }
 }
 }

需求2：定义一个方法用于打印两个数中的较大数，数据来自于方法参数
思路：
- ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
- ②为方法定义两个参数，用于接收两个数字
- ③使用分支语句分两种情况对两个数字的大小关系进行处理
- ④在main()方法中调用定义好的方法（使用常量）
- ⑤在main()方法中调用定义好的方法（使用变量）
代码：

public class MethodTest { 
public static void main(String[] args) 
{ //在main()方法中调用定义好的方法（使用常量） 
getMax(10,20);
 //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的 //getMax(30);//错误 
 //getMax(10.0,20.0);//错误 
 //在main()方法中调用定义好的方法（使用变量）
  int a = 10; 
  int b = 20; 
  getMax(a, b); 
  }
  //定义一个方法，用于打印两个数字中的较大数，例如getMax() 
  //为方法定义两个参数，用于接收两个数字 
  public static void getMax(int a, int b) { 
  //使用分支语句分两种情况对两个数字的大小关系进行处理 
  if(a > b) { 
  System.out.println(a);
   } else { 
   System.out.println(b); 
   } 
   } 
   }

5.3.2.7 带返回值的方法定义

定义格式：

public static 数据类型 方法名 (参数){
	return 数据;
}

范例

public static int getSum(int a,int b){ 
	int sum = a + b; 
	return sum; 
	}

注意
方法定义时return后面的返回值与方法定义上的数据类型要匹配(目前暂时认为数据类型一致)，否则程序将报错

5.3.2.8

调用格式

方法名 ( 参数 ) ; 
数据类型 变量名 = 方法名 ( 参数 ) ;

范例

getSum(5,6); 
int result = getSum(5,6);

注意
方法的返回值通常会使用变量接收，否则该返回值将无意义

5.3.2.9 带返回值的方法调用流程图解

在这里插入图片描述

5.3.2.10 带返回值的方法练习

需求1：定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值
思路：
- ①定义一个方法，用于获取一个数字是否是偶数
- ②使用分支语句对数字是否是偶数进行处理
- ③根据题设分别设置两种情况下对应的返回结果
- ④在main()方法中调用定义好的方法并使用变量保存
- ⑤在main()方法中调用定义好的方法并直接打印结果
代码：

public class MethodDemo { 
public static void main(String[] args) 
{ //1:方法名(参数); 
//isEvenNumber(10);//返回值为true,但没有接收 
//2:数据类型 变量名 = 方法名(参数); 
boolean flag = isEvenNumber(10); 
//返回值为true,相当于 
boolean flag = true; System.out.println(flag); 
}
//需求：定义一个方法，该方法接收一个参数，判断该数据是否是偶数，并返回真假值 
public static boolean isEvenNumber(int number) 
{ 
if(number%2 == 0) 
{ 
return true;
 } else
  { 
  return false; 
  } 
  } 
  }

需求2：设计一个方法可以获取两个数的较大值，数据来自于参数
思路：
- ①定义一个方法，用于获取两个数字中的较大数
- ②可以使用分支语句对两个数字的大小关系进行处理
- ③根据题设可以分别设置两种情况下对应的返回结果
- ④在main()方法中调用定义好的方法并使用变量保存
- ⑤在main()方法中调用定义好的方法并直接打印结果
代码：

public class MethodTest { 
public static void main(String[] args) 
{ 
//在main()方法中调用定义好的方法并使用变量保存 
int result = getMax(10,20);
 System.out.println(result); 
 //在main()方法中调用定义好的方法并直接打印结果 
 System.out.println(getMax(10,20)); 
 }
//定义一个方法，用于获取两个数字中的较大数 
public static int getMax(int a, int b) 
{ 
//使用分支语句分两种情况对两个数字的大小关系进行处理 
//根据题设分别设置两种情况下对应的返回结果
 if(a > b) {
  return a; 
  } else 
  { 
  return b; 
  }
   }
   }

5.3.2.11 定义方法的注意事项

方法不能嵌套定义

public class MethodDemo { 
public static void main(String[] args) { 
}
public static void methodOne() 
{ // 这里会引发编译错误!!! 
public static void methodTwo() { 
} 
} 
}

返回值类型，必须要和 return 语句返回的类型相同，否则编译失败。

// 返回值类型要求是
int public static int getSum() 
{ 
return 5;// 正确，
int类型 return 1.2;// 错误，类型不匹配 
return true;// 错误，类型不匹配
}

同一个逻辑中 , 不能在 return 语句后面写代码， return 意味着方法结束，所有后面的代码永远不会执行，属于无效代码。

public static int getSum(int a,int b) { 
return a + b; 
System.out.println("Hello");// 错误，return已经结束，这里不会执行，无效代码 
}

void表示无返回值，可以省略return，也可以单独的书写 return; ，后面不加数据

public class MethodDemo { 
public static void main(String[] args) { 
}
public static void methodTwo() { 
//return 100; 编译错误，因为没有具体返回值类型 
return;
 //System.out.println(100); return语句后面不能跟数据或代码 
 } 
 }

5.3.3 方法重载

5.3.3.1 概念

方法重载：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型，参数名称无关。
- 多个方法在同一个类中
- 多个方法具有相同的方法名
- 多个方法的参数不相同，类型不同或者数量不同
注意
- 参数列表：个数不同，数据类型不同，顺序不同。
- 重载方法调用：JVM通过方法的参数列表，调用不同的方法。

5.3.2.2 方法重载练习

需求1：使用方法重载的思想，设计比较两个两个数据是否相等的方法，兼容全整数类型byte,short,int,long
思路：
- ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
- ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
- ③定义所有的重载方法，两个byte类型与两个short类型参数
- ④完成方法的调用，测试运行结果
代码：

public class Method_Demo6 { 
public static void main(String[] args) { 
	//定义不同数据类型的变量 
	byte a = 10; 
	byte b = 20;
	short c = 10; 
	short d = 20; 
	int e = 10; 
	int f = 10; 
	long g = 10; 
	long h = 20; 
	// 调用 
	System.out.println(compare(a, b)); 
	System.out.println(compare(c, d)); 
	System.out.println(compare(e, f));
	System.out.println(compare(g, h)); 
	}
	// 两个byte类型的 
	public static boolean compare(byte a, byte b) 
	{ 
	System.out.println("byte"); return a == b; 
	}
	// 两个short类型的 
	public static boolean compare(short a, short b)
	 { 
	 System.out.println("short"); return a == b; 
	 }
	 // 两个int类型的 
	 public static boolean compare(int a, int b) 
	 { 
	 System.out.println("int"); return a == b; 
	 }
	 // 两个long类型的 \
	 public static boolean compare(long a, long b) 
	 { 
	 System.out.println("long"); return a == b; 
	 } 
	 }

需求2 ：判断哪些方法是重载关系。

public static void open(){} true 
public static void open(int a){} true 
static void open(int a,int b){} true
public static void open(double a,int b){} true 
public static void open(int a,double b){} true 
public void open(int i,double d){} false, 方法重载 与 参数名无关
public static void OPEN(){} false, 方法名不一致 
public static void open(int i,int j){} false, 方法重载 与 参数名无关

5.3.4 方法的练习

5.3.4.1 练习一

需求1：设计一个方法，接收一个int类型的变量,初始化值为1234,求这个数的个位,十位,百位,千位分别是多少?。
运行效果:

1234的个位是4,十位是3,百位是2,千位是1

代码：

public class Test { public static void main(String[] args) 
{ 
printValue(1234); 
}
/*** 接收一个四位数, 打印个位,十位,百位,千位数值 */
 public static void printValue(int num)
 { 
 System.out.println(num+"个位 = " + num%10); 
 System.out.println(num+"十位 = " + num/10%10); 
 System.out.println(num+"百位 = " + num/100%10); 
 System.out.println(num+"千位 = " + num/1000%10); 
 } 
 }