2022/06/01 day02：数据类型转换、运算符、方法入门

上水若善

已于 2022-06-09 11:31:28 修改

阅读量123

点赞数

分类专栏： 01 java语言基础课程文章标签： java 开发语言

于 2022-06-01 18:40:06 首次发布

本文链接：https://blog.csdn.net/w2079930908/article/details/125088213

版权

01 java语言基础课程专栏收录该内容

15 篇文章 0 订阅

订阅专栏

这篇博客详细介绍了Java中的类型转换，包括自动类型转换和强制类型转换，强调了强制转换可能带来的问题。接着讨论了各种运算符，如算数、自增自减、赋值、比较、逻辑及三元运算符，给出了相应的使用注意事项和示例。最后，简单介绍了方法入门，包括方法定义和调用的基本概念。

摘要由CSDN通过智能技术生成

1.0 类型转换

1.1 自动类型转换（隐式）

1. 特点：代码不需要进行特殊处理，自动完成
2. 规则：数据范围从小到大。与字节数不一定相关。

例子：

public class Demo01DataType{
	public static void main(String[] args){
		System.out.println(1024);//这就是一个整数，默认就是int类型
		System.out.println(3.14);//这就是一个浮点数，默认就是double类型
		
		//long num1 = 100L;
		//一个等号发表赋值，将右侧的int常量，交给左侧的long变量进行存储
		//int --> long  符合了数据范围从小到大的要求，发生了自动类型转换
		long num1 = 100;//为什么没有报错，左边是long类型，右边是默认的int类型，左右不一样
		System.out.println(num1);
		
		//左边是double类型，右边是float类型，左右不一样；
		//float --> double 符合从小到大的规则，也发生了自动类型转换
		double num2 = 2.5F;
		System.out.println(num2);
		
		//左边是float类型，左右是long类型，左右不一样；
		//long --> float ,范围是float更大一些，符合从小到大的规则，也发生了自动类型转换
		float num3 = 30L;
		System.out.println(num3); //30.0
		
		
	}
	
}

1.2 强制类型转换（显式）

强制类型转换
1. 特点：代码需要进行特殊格式处理，不能自动完成。
2. 格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；

注意事项：
1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
2. byte/short/char这三种类型都可以发生数学运算，例如加法’+‘；
3. byte/short/char这三种类型在运算时，都会被提升为int类型。然后再计算。
4. boolean类型不能发生任何数据类型转换（严格规定）

例子：

public class Demo02DataType{
	public static void main(String[] args){
		
		//int num = 100;
		//int num = 100L;  左边是int类型，右边是long类型，不一样，
		//不是从小到大，不能发生自动类型转换
		
		//格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；
		int num = (int)100L;
		System.out.println(num);	
		//**************************************************************************
		//int num2 = 6000000000; //int 数据范围大致能表示21个亿，【数据溢出】了。
		//System.out.println(num2);//错误。
		//long强制转换为int类型。
		int num2 = (int)6000000000L;
		System.out.println(num2);//1705032704 发生了数据溢出，对于整数来说。
		
		//double --> int ,强制类型转换
		int num3 = (int)3.5;
		System.out.println(num3);// 3  【精度损失】，0.5丢了
		//*************************************************************************
		char zifu1 = 'A';//这是一个字符型变量，里面是大写字母A
		System.out.println(zifu1 +1);//66，大写字母被当做65进行处理
		//计算机的底层会用一个数字（二进制）来代表字符A，就是65；
		//一旦char类型进行数学运算，那么字符就会按照一定的规则翻译成为一个数字
		
		//**************************************************************************
		byte num4 =40;//注意！右侧的数值大小不能超过左侧的类型范围。
		byte num5 = 50;
		//byte + byte --> int + int --> int 
		//byte result = num5 + num4 ；错误；
		int result1 = num5 + num4;
		System.out.println(result1);//90
		
		short num6 = 60;
		//byte + short --> int + int --> int 
		int result2 = num4 + num6;
		//short result2 = (short)(num4 + num6 )
		//int 强制转换为short，必须保证逻辑上真实大小本来就没有超过short范围，发否就会发生数据溢出
		System.out.println(result2);
			
		
}}

数据溢出【迁移图】

在这里插入图片描述

计算机中是如何表示一个字符的：
ASC||码表：记录了数字与字符的对照关系
在这里插入图片描述

数字和字符的对照关系表（编码表）
小表，ASCII码表：美国信息交换标准代码。
大表，Unicode码表：万国码。也就是数字和符号的对照关系，开头0-127和ASCII完全一样，但之后开始包含更多字符。
记住：48 - '0' , 65 - 'A' ,97 - 'a'

例子：

public class Demo03DataTypeChar{
public static void main(String[] args){
		char zifu1 = '1';
		System.out.println(zifu1 + 0);//	49
	
		char zifu2 = 'A';//其实底层保存的是65数字；
		char zifu3 = 'c';
		//左侧是int类型，右边是char类型
		//char --> int ，确实是从小到大，所以发生了自动类型转换。
		int num = zifu3;
		System.out.println(num);//99
	
		char zifu4 = '中';//正确写法
		System.out.println(zifu4 + 0);//20013  1--127asc|| 并不只是只有一张表。
	
	
}}

2.0 运算符

2.1 算数运算符

运算符：进行特定操作的符号，例如：+、-、*、/；
表达式：用运算符连起来的式子叫表达式。例如：20+5 、 a+b。

四则运算：
加：+
减：-
乘：*
除：/

取模（取余数）：%

首先计算得到表达式的结果，然后再打印输出这个结果
小学一年级的 除法公式：被除数 / 除数 = 商...余数

对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，不看余数。
只有对于整数的除法来说，取模运算符才有意义。

注意事项：
1. 一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。

例子：

public class Demo04Operator{
public static void main(String[] args){
		//两个常量之间可以进行数学运算
		System.out.println(20+30);
		//两个变量之间也可以进行数学云算
		int a = 20;
		int b = 30;
		System.out.println(a - b);// -10
		//变量和常量之间可以混合使用
		System.out.println(a * 10);// 200
		
		int x = 10;
		int y = 3;
		System.out.println(x / y);	//3
	
		int result2 = x % y;
		System.out.println(result2); //余数，取模， 1
		
		// int + double --> double + double -->double 谁数据范围大就听谁的。
		double result3 = x + 2.5;
		System.out.println(result3); //12.5
		
	}}

四则运算中的加号“+”有常见的三种用法：
1. 对于数值来说就是加法。
2. 对于字符char类型来说，在计算之前，char会被提升成为int（数字），然后计算。
char类型字符和int类型数字之间的对照关系表：ASCII、Unicode
3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作（字符串连接）。
任何数据类型和字符串进行连接的时候，结果都会变成字符串.

例子：

public class Demo05Plus{
public static void main(String[] args){
	//字符串类型的变量基本使用
	//数据类型 变量名称 = 数据值；
	String str1 = "Hello";
	System.out.println(str1);//hello
	
	System.out.println("Hello" + "World");//HelloWorld
	
	String str2 = "Java";
	//String + int --> 
	System.out.println(str2 + 20);//Java20
	
	//优先级问题
	//String + int + int
	//String + int
	//String
	System.out.println(str2 + 20 + 30);//Java50  or  Java2030（对）
	System.out.println(str2 +(20 + 30));//Java50（对）  or  Java2030	
	
}}

2.2 自增自减运算符

自增运算符：++
自减运算符：--
含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写在变量名称之前，或者写在变量名称之后，例如：++num，也可以num++；
使用方式：
1. 单独使用：不和其他任何操作混合，自己独立成为一个步骤。
2. 混合使用：和其他操作混合，例如赋值混合，或者与打印操作混合，等。
使用区别：
1. 单独使用时，前++和后++没有任何区别，也就是：++num;和num++；完全是一样的
2. 在混合使用的时候，有【重大区别】
	A. 如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。【先加后用】
	B. 如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。【先用后加】

注意事项：
只有变量才能使用自增，自减运算符，常量不可发生改变，所以不能用。

public class Demo06Operator{
public static void main(String[] args){
   int num1 = 10;
   System.out.println(num1);// 10
   ++num1;//单独使用，前++
   System.out.println(num1); // 11
   num1++;//单独使用，后++；
   System.out.println(num1); // 12
   System.out.println("==================================");
   
   //与打印操作混合的时候
   int num2 = 20;
   System.out.println(++num2);// 先++，立刻马上编程21，然后打印21
   System.out.println(num2++); //后++，先打印21，再++，num2里面的值是22。
   
   System.out.println("==================================");
   int num3 = 30;
   //和赋值操作混合；
   int result1 = --num3;//混合使用，前--，变量立刻马上变成29，然后将29交给result1变量。
   System.out.println(num3);//29
   System.out.println(result1);//29
   
   int num4 = 40;
   int result2 = num4--;//混合使用，后--，变量先赋值40，再减1，num4的值变为39；
   System.out.println(result2);//40
   System.out.println(num4);//39
   
   
   int x = 10;
   int y = 20;
   int result3 = ++x + y--; //开发中并不会这样一看都不简洁明了。易读性高的代码才是优秀代码。
   System.out.println(result3);//31，  ++x立刻加为11，y--后再减还是20，x+y=31;y减1后是19；
   System.out.println(x);//11  该+一定会+
   System.out.println(y);//19  该-一定会-
   
   //++30; 错误的，常量不能自增或自减。
}}

2.3 赋值运算符

赋值运算符：
基本赋值运算符：
	就是一个等号“=”，代表将右侧的数据交给左侧的变量。


复合赋值运算符：
	+=      a += 1;    相当于 a = a + 1;
	-=		b -= 4;    相当于 b = b - 4;
	*=      c *= 5;    相当于 c = c * 5;
	/=		d /= 6;    相当于 d = d / 6
	%=		e %= 7;	   相当于 e = e % 7;

注意事项：
1. 只有变量才能使用赋值运算符，常量不能进行赋值。
2. 复合赋值运算符其中隐含了一个强制类型转换。【注意】

例子：

public class Demo07Operator{
public static void main(String[] args){
		int a = 10;
		a += 5;//按照公式翻译 a = a + 5 a本来是10，现在重新赋值为15.
		System.out.println(a);//15
	
		int x = 10;
		x %= 3;
		System.out.println(x);//1， x = x % 3   x被重新赋值为1。
		
		
		byte num = 30;
		//num = num +5;   
		//num = byte + int
		//num = int + int
		//num = int
		//num = (byte)int   编译器的功劳
		num += 5;
		System.out.println(num);//35
	
}}

2.4 比较运算符

比较运算符：
大于：			>
小于:			<
大于等于:		>=
小于等于:		<=
相等:			==	【两个等号连写才是相等，一个等号代表的是赋值】
不相等:			!=

注意事项：
1. 比较运算符的结果一定是一个Boolean值，成立是true，不成立就是false。
2. 如果进行多次判断，不能连着写。
数学当中的写法，例如：1<x<3;
程序中【不允许】这种写法。

例子：

public class Demo08Operator{
public static void main(String[] args){
	System.out.println(10>5);	//ture
	
	int num1 = 10;
	int num2 = 12;
	System.out.println(num1 < num2); //ture
	System.out.println(num2 >= 100); //false
	System.out.println(num2 <= 100); //ture
	System.out.println(num2 <= 12); //ture
	System.out.println("============================="); //ture
	
	System.out.println(10 == 10); //ture
	System.out.println(10 != 15); //ture
	System.out.println(10 != 10); //false
	
	int x = 3;
	//System.out.println(1 < x < 10); //错误写法，编译报错，不能连着写。
	
}}

2.5 逻辑运算符

逻辑运算符：
与（并且）：&&		全都是true，才是true，否者就是false。
或（或者）：||		只要一个是true，就是true，全都是false，才是false。
非（去反）：！		本来是true，变成false；本来是false，变成true。

与“&&”，或“||”，具有短路效果，如果根据左边已经可以判断最终结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项：
1. 逻辑运算符只能用于boolean值。
2. 与、或需要左右各有一个boolean值，但是取反只要有唯一的一个boolean值即可。
3. 与、或两种运算符，如果有多个条件，可以连续写。
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C

tips：
	对于1 < x < 3的情况，应该拆成两部分，然后使用与运算符连接起来:
		1 < x && x < 3

例子：

public class Demo09Logic{
public static void main(String[] args){
   	System.out.println(true && false);//false
   	System.out.println(true && true);//true
   	System.out.println(10 > 5 && 3 > 2);//true
   	System.out.println("=======================");
   	System.out.println(true || false); //true
   	System.out.println(false || false);//false
   	System.out.println(false || 3 > 3);//false
   	System.out.println("=======================");
   	System.out.println(false);//false
   	System.out.println(!false);//true 
   	System.out.println("=======================");
   	int a = 10;
   	System.out.println(3 > 4 && ++a < 100);//false && ...  --> false 
   	System.out.println(a);// 10 ，a内的值仍然是10，因为++a并没有执行。
   	
   	int b = 20;
   	System.out.println(3 < 4 || ++b < 100);//true 
   	System.out.println(b);//20, b内值仍然是20，++b并没有执行。
}}

2.6 三元运算符

一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反！、自增++、自减++。
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=。 
三元运算符：需要三个数据才可以进行操作的运算符。
格式：数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B
流程：首先判断条件是否成立：
	  如果成立为true，那么将表达式A的值赋值给左侧的变量；
	  如果不成立为false，那么将表达式B的值赋给左侧的变量；
	  二者选其一。

注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2. 三元运算符的结果必须被使用。

例子：

public class Demo10Operator{
public static void main(String[] args){
   	int a = 10;
   	int b = 20;
   	
   	//数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B
   	//判断 a>b
   	int max = a > b ? a : b; //定义了最大值得变量。
   	System.out.println(max)//20
   	
   	//int result = 3 > 4 ? 2.5 : 10;错误写法  2.5是double类型的没有强转，就不符合数据类型
   	System.out.println(3 > 4 ? 2.5 : 1);//正确写法 这样就能打印，没有数据类型的限制。
   	//3 > 4 ? 2.5 : 1;  错误写法，结果压根就没用，所以不行。
}}

3.0 方法入门

我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。

定义一个方法的格式(固定格式：

public static void 方法名称(){
方法体;
}

方法名称的命名规则和变量一样，使用小驼峰。
方法体：也就是大括号当中可以包含任意语句。

注意事项：
1. 方法定义的顺序无所谓。
2. 方法的定义不能产生嵌套包含关系。
3.方法定义好了之后，并不会执行；如要执行，一定要进行方法的【调用】

如何调用，格式：
方法名称();

例子：

public class Demo11Method{
	public static void main(String[] args){
		
		//先把握整体，在把握局部。
		farmer();//调用农民的方法
		seller();//调用小商贩的方法
		cook();//调用厨子的方法
		me();//调用我自己的方法
		
		
	}
		//我
		public static void me(){
			System.out.println("吃");
			
		}
		//厨子
		public static void cook(){
			System.out.println("洗菜");
			System.out.println("切菜");
			System.out.println("炒菜");
			System.out.println("装盘");			
			
		}
		//小商贩
		public static void seller(){
			System.out.println("运输到农贸市场");
			System.out.println("抬高价格");
			System.out.println("吆喝");
			System.out.println("卖给厨子");			
			
		}
		//农民伯伯
		public static void farmer(){
			System.out.println("播种");
			System.out.println("浇水");
			System.out.println("施肥");
			System.out.println("除虫");
			System.out.println("收割");
			System.out.println("卖给小商贩");			
		}
}

                                                                                 ——此文档为学习笔记！

上水若善

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录