day02【数据类型转换、运算符、方法入门】

最新推荐文章于 2023-01-18 16:33:54 发布

EagleJB

最新推荐文章于 2023-01-18 16:33:54 发布

阅读量257

点赞数 1

文章标签：干净利落的总结

本文链接：https://blog.csdn.net/weixin_43761325/article/details/88326527

版权

【数据类型转换、运算符、方法入门】

内容

数据类型转换

（数据类型，byte short int long float double char boolean

int age = 10 ;

long lg = 100 ;

类型最终要一致

）
算数运算符

（开发人员是一定要参与运算的，数学，英文

规范，语法，设计，流行框架，业务功能开发。

+ - * / % ++ –

）
比较运算符

判断是否满足条件 > >= < <= !=
逻辑运算符

&& || !
三元运算符

分支选择
if else判断语句

流程控制语句，分支选择，非常强大，很经典。

目标

理解数据类型的强制转换
理解数据类型的自动转换
了解ASCII编码表
理解int类型和char类型的运算原理
理解运算符++ --的运算方式
理解+符号在字符串中的作用
理解比较运算符
理解逻辑运算符
掌握三元运算符的格式和计算结果
理解if语句的格式和执行流程
理解if…else语句的格式和执行流程
理解if…else if语句的格式和执行流程

第一章数据类型转换

1.1 数据类型转换的原因

Java程序中要求参与计算的数据，必须要保证数据类型统一成一致，才可以参与运算，如果数据类型不一致将发生类型的转换。所以数据类型之间的转换是有必要的。

1.2 自动类型转换

1.2.1 常量赋值给变量

int i = 1; 
// 自动类型转换: 1.随便写一个整数， 如果它的范围在变量的范围之内是可以直接赋值给该类型的变量。
byte b = 12 ;
//byte b = 1299 ; // 报错
System.out.println(b);

1.2.2 自动类型转换

取值范围小的类型可以自动转换为取值范围大的类型 。也就是小范围变量到大范围变量是自动转换的。满足

byte->short->int->long->float->double，其中char类型的变量可以直接自动转换给int类型的变量。。

public static void main(String[] args) {
    // 自动类型转换: 小范围类型的变量可以自动转换给大范围类型的变量。
    byte b1 = 23 ;
    int age = b1 ;
    System.out.println(age);

    // 自动类型转换: 小范围类型的变量可以自动转换给大范围类型的变量。
    int s = 23122;
    long lg = s;
    System.out.println(s);

    // 自动类型转换: 小范围类型的变量可以自动转换给大范围类型的变量。
    long lg1 = 12231313;
    double db = lg1 ;
    System.out.println(db);
    
    // 拓展:
    // 自动类型转换: 小范围类型的变量可以自动转换给大范围类型的变量。
    // char是编号，但是字符编号的范围是有限的相对于int类型来说
    // 是小范围的，所以可以自动转换。
    char ch = '中';
    int it = ch ;
    System.out.println(it); // 就是 '中'在底层的编号
}

1.3 强制类型转换

1.3.1 引入

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

byte i = 200; // 错误

byte类型的范围是-127到128之间，200已经超过了byte类型变量可以存储的数据范围大小。想要赋值成功，只有通过强制类型转换，将int类型的200进行强制转换成byte 类型才能赋值。

强制转换：将取值范围大的类型强制转换成取值范围小的类型。也就是把大范围类型的数据或者大范围的类型变量赋值给小范围的类型变量必须要强制类型转换否则代码报错。比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

1.3.2 强制转换格式

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

将200 赋值到byte类型，代码修改为：

// double类型数据强制转成int类型，直接去掉小数点。
byte i = （byte）200;
System.out.println(i);// 数据会出现变化

同样道理，大范围类型的变量赋值给一个小范围类型的变量也需要强制类型转换。

public static void main(String[] args) {
    	// 强制类型转换: 把大范围的类型变量赋值给小范围的类型变量必须要强制类型转换
		int score = 60 ;
		byte b1 = (byte)score ;
		System.out.println(b1);
    	
        // 浮点转成整数，直接截断小数点，保留整数部分，可能造成数据损失精度。
        double db = 23.98;
        int it = (int)db ;
        System.out.println(it);// 23
}

1.3.3 注意事项与小结

浮点型转成整型，直接截断小数点，保留整数部分，可能造成数据损失精度。
大范围类型的变量强制转成小范围类型的变量，可能造成数据丢失。

// 定义s为short范围内最大值
int s = 32767;
// 运算后，强制转换可以造成数据丢失。
byte bt = (byte)s

1.4 表达式的自动类型提升

数据类型在表达式中参与运算时将满足一定的转换规则。

1.4.1 转换规则

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

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

2.表达式的最终类型由表达式中的最高类型决定。

public static void main(String[] args){
    byte bt = 10 ;
    int age = 100 ;
    long lg = 1000;
    long rs = bt + age * lg ;
    System.out.println(rs);
	
    // 面试题。
	byte b1 = 10 ;
	short b2 = 10 ;
	//short b3 = b1 + b2 ; // 错误的 b1 b2升级成了int类型
	//short b3 = (short)(b1 + b2) ; // 可以的 int -> short
	int b3 = b1 + b2 ;
	System.out.println(b3);
	
	float ft1 = 10.0f;
	double db1 = 1 ;
    long lg1 = 10 ;
    char ch = 'a';
	// char类型的变量ch在参数运算的时候会自动转成int类型的整数97.
    double d1 = ft1*db1*lg1*ch; 	
  	System.out.println(d1);	
  }

1.4.2 面试题

下面代码存在什么问题？

public static void main(String[] args){
  byte b1=1;
  byte b2=2;
  byte b3=1 + 2; // 常量3在byte范围之类是可以自动转换的。
  byte b4=b1 + b2;// 这里报错了，b1和b2会自动提升成int类型变量运行，结果是int类型的。
  System.out.println(b3);
  System.out.println(b4);
}

1.4.3 小结

1.表达式的最终结果类型由表达式中的最高类型决定。

2.byte,short,char类型的变量在参与运算的时候会直接升级成int类型参与运算（针对于表达式）。

1.5 ASCII编码表

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

在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？十进制和二进制转换很方便，将现实生活中的字符和数字对应。就产生出了编码表的概念。

编码表 ：就是将人类的文字和一个十进制数进行对应起来组成一张表格。

人们就规定：

字符数值
‘0’ 48
‘9’ 57
‘A’ 65
‘Z’ 90
‘a’ 97
‘z’ 122
- 将所有的英文字母，数字，符号都和十进制进（就是整数编号）行了对应，因此产生了世界上第一张编码表ASCII（ American Standard Code for Information Interchange 美国标准信息交换码）。

字符	数值
‘0’	48
‘9’	57
‘A’	65
‘Z’	90
‘a’	97
‘z’	122

第二章运算符

什么是运算符: 对变量或者常量进行操作的符号。

运算符的分类: 算数运算符, 赋值运算符, 比较运算符, 逻辑运算符, 三元运算符

2.1 算数运算符

2.1.1 基本的算数运算符

算数运算符包括：
`+`	加法运算，字符串连接运算
`-`	减法运算
`*`	乘法运算
`/`	除法运算
`%`	取模运算，两个数字相除取余数
`++` 、 `--`	自增自减运算

算数运算符练习

public class Demo01Operater {
	public static void main(String[] args) {
		// 定义变量
		int a = 5;
		int b = 3;
		
		System.out.println(a + b); // 8
		System.out.println(a - b); // 2
		System.out.println(a * b); // 15
		System.out.println(a / b); // 1.66666？这里的结果是1，因为表达式的最终类型必须是int类型
		System.out.println(a % b); // 2
		
		System.out.println("---------");
		// 整数相除,结果是整数,要得到小数,必须有小数参与运算
		System.out.println(5.0 / 3); // 1.6666666666666667
		System.out.println(5 / 3.0); // 1.6666666666666667
	}
}

注意：Java中，整数相除结果是整数。

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

%取余面试题:

System.out.println(5 % 3);	// ?
System.out.println(-5 % 3); // ?
System.out.println(5 % -3); // ?
System.out.println(-5 % -3); // ?

注意:取余结果符号与左边符号相同

2.1.2 自增++与自减–

++运算，变量自己增长1。反之–运算，变量自己减少1。

独立运算：

变量在独立运算时，前++和后++没有区别。就是++ ， – 单独使用的时候在变量的前后是没有区别的。都是+1或者减1。
变量前++ ：例如 ++i 。

变量后++ ：例如 i++ 。

public static void main(String[] args){
     // -- 自增，自减运算符：++ , --
	 // 只能用在变量中的。
	 int a = 10 ;
	 a++;   // a = a + 1 ;
	 ++a;   // a = a + 1 ; 注意：++ ， -- 只能用在变量的自增自减上。
	 System.out.println(a);
	 
	 int b = 11 ;
     b--; // b = b -1 
	 --b; // b = b -1 
	 System.out.println(b);
}

表达式中运算：

++，–在表达式运算中，变量前++和变量后++的计算方式是不同的。

++ ， --，如果在表达式中进行运算的时候，在变量的前后是有区别的。 ++ , – 如果在变量的后面，先使用变量的值运算，然后再对变量进行自增或者自减。 ++ , – 如果在变量的前面，先对变量进行自增或者自减，然后参与运算

public static void main(String[] args) {
    int c = 10 ;
    int rs = c++ ; // 先使用变量c的值赋值给rs变量，然后对变量c+1
    System.out.println(rs); // 10
    System.out.println(c);  // 11
}

public static void main(String[] args) {
  // 面试题：（拓展）
    int i = 5;
    int k = 10 ;
    //  i  6  5
    //  k  11 10 11
    //        5   -  5  +  11 + 1 - 10  + 10
    int rs2 = i++ - --i + ++k + 1 - --k + k++ ;
    // 请问最终 rs2 ,i , k的结果是多少？
    System.out.println(i); //5
    System.out.println(k); // 11
    System.out.println(rs2); // 12
}

2.1.3 +符号在字符串中的操作

+符号在遇到字符串的时候，表示连接、拼接的含义。

“a”+"b"的结果是“ab”，连接含义

案例演示

public static void main(String[] args) {
  	// + 遇到字符串表示连接
  	System.out.println("abc" + "def");
  	System.out.println("abc" + 5);
  	System.out.println("abc" + 5 + 5);
  	System.out.println("abc" + (5 + 5));
  	System.out.println(5 + 5 + "abc"); 
    // **面试题:**
    System.out.println("5+5="+5+5);//输出?
  }

2.2 赋值运算符

赋值运算符包括：
`=`	赋值
`+=`	加后赋值
`-=`	减后赋值
`*=`	乘后赋值
`/=`	除后赋值
`%=`	取模后赋值

2.2.1 基本赋值运算符=

=是用来给左边的变量进行赋值的，通常是先计算=右边的表达式，然后把结果赋值给左边的变量。

// 定义变量
int i = 3; // 将3赋值给变量i
i = i + 2; // 将变量i和2相加,再赋值给变量i
System.out.println(i);

2.2.2 扩展的赋值运算符

扩展的赋值运算符包括了，+=，-=，*=，/= , %= 等等。都是基本运算符加上“=”的形式。扩展运算符的关键是把握住他们隐含的公式，如下所示：

i+=j;  // i = (i的数据类型)(i+j);
i-=j;  // i = (i的数据类型)(i-j);
i*=j;  // i = (i的数据类型)(i*j);
i%=j;  // i = (i的数据类型)(i%j);

从以上公式可以看出，扩展赋值运算符是简化了两个变量的运算，是把运算的结果直接交给前一个变量，而且自带了强制类型转换。

public static void main(String[] args) {
	    // 扩展后的赋值运算符: += , -= , *= , /= , %= , ...
		int i = 10 ;
		int j = 5 ;
		// i+=j;  // i = (i的数据类型)(i+j);
		// i-=j;  // i = (i的数据类型)(i-j);
	    // i*=j;  // i = (i的数据类型)(i*j);
	    i%=j;  // i = (i的数据类型)(i%j);
		System.out.println(i);
		
		// 注意点：扩展的赋值运算符自带强制类型转换
		byte b1 = 10 ;
		byte b2 = 40 ;
		// byte b3 = (byte)(b1 + b2) ;
		b1 += b2 ; // b1 = (b1的数据类型)(b1+b2);
		System.out.println(b1);
}

2.2.3 小结

扩展的赋值运算符自带了强制类型转换。

2.3 比较运算符

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

比较运算符包括：
`==`	比较符号两边数据是否相等，相等结果是true。
`<`	比较符号左边的数据是否小于右边的数据，如果小于结果是true。
`>`	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
`<=`	比较符号左边的数据是否小于或者等于右边的数据，如果小于或等于结果是true。
`>=`	比较符号左边的数据是否大于或者等于右边的数据，如果小于或等于结果是true。
`!=`	不等于符号，如果符号两边的数据不相等，结果是true。

public static void main(String[] args) {
	System.out.println(3==3); // 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
	System.out.println(5<=4); // false
	System.out.println(4>=4); // true

	// 注意
	int i = 3;
	int j = 4;
	System.out.println(i=j); // 将j赋值给i,输出i
	System.out.println(i==j); // true
}

2.3.1 小结

注意“=”与“==”的区别。

2.4 逻辑运算符

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

逻辑运算符包括

2.4.5 &&，||，！，^

逻辑运算符是用来连接两个条件的，判两个断两个条件是否满足某种逻辑,最终的结果也是布尔类型。
1.&& ：短路与
必须前后两个条件的结果都是true的时候，最终的结果才是true.
只要有一个条件是false,最终的结果一定是false.

2.|| ：短路或
只要有一个条件是true,最终的结果一定是true.
必须前后两个条件的结果都是false的时候，最终的结果才是false

3.！：非
取反
!true false
!false true

^ : 异或
必须两个条件是相反的，结果才是true,如果两个条件相同结果一定是false

案例演示

// 需求：我需要招聘 年龄超过26岁，工作经验超过3年的人。
int age = 30 ;
int workTimer = 6 ; 
System.out.println(age >= 26 && workTimer >=3);

// 短路与  &&
System.out.println(false && false); // false
System.out.println(false && true); // false
System.out.println(true && false); // false
System.out.println(true && true); // true

System.out.println("--------------------------------------------");
// 短路或 ||
System.out.println(false || false); // false
System.out.println(false || true); // true
System.out.println(true || false); // true
System.out.println(true || true); // true

System.out.println("--------------------------------------------");
// 非：取反  !
System.out.println(!false); // true
System.out.println(!true); // false

System.out.println("--------------------------------------------");
// 异或
// 必须两个条件是相反的，结果才是true,如果两个条件相同结果一定是false
// 场景：同性恋不能结婚，必须异性才可以结婚（慎提，万一有同性恋的同学呢？嘿嘿）
System.out.println(false ^ false); // false
System.out.println(false ^ true); // true
System.out.println(true ^ false); // true
System.out.println(true ^ true); // false

2.4.5 && 与 &,|| 与 |的区别

&& ：短路与
必须前后两个条件的结果都是true的时候，最终的结果才是true。
只要有一个条件是false,最终的结果一定是false。

|| ：短路或
只要有一个条件是true,最终的结果一定是true。
必须前后两个条件的结果都是false的时候，最终的结果才是false。

&  : 与 
与短路与的结果是完全一样的。
短路与&&如果发现第一个条件已经是false,根本不会执行第二个条件,短路与比较聪明。
与是很傻的，无论第一个条件是true还是false,它依然会去执行第二个条件。

|  ：或
与短路或的结果是完全一样的。
短路或||如果发现第一个条件已经是true,根本不会执行第二个条件,短路或比较聪明。
或是很傻的，无论第一个条件是true还是false,它依然会去执行第二个条件。

案例代码

public static void main(String[] args) {
    // &与短路与“&&”的判断结果是一样的。
	// 短路与"&&"如果发现第一个条件已经是false,根本不会执行第二个条件,短路与比较聪明。
    // 与"&"是很傻的，无论第一个条件是true还是false,它依然会去执行第二个条件。
    System.out.println(false & false); // false
    System.out.println(false & true); // false
    System.out.println(true & false); // false
    System.out.println(true & true); // true
    System.out.println("--------------------------------------------");
    // | 与 短路或“||”的判断结果是一样的。
    // 短路或"||"如果发现第一个条件已经是true,根本不会执行第二个条件,短路或比较聪明。
    // 或"|"是很傻的，无论第一个条件是true还是false,它依然会去执行第二个条件。
    System.out.println(false | false); // false
    System.out.println(false | true); // true
    System.out.println(true | false); // true
    System.out.println(true | true); // true
    System.out.println("--------------------------------------------");
}

2.4.6 小结

1、设计到多个条件判断的时候应该选择逻辑运算符。

2、开发中短路与和短路或用的较多。

2.5 三元（目）运算符

2.5.1 格式

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

2.5.2 三元运算符计算方式

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

public static void main(String[] args){
	     int age = 19 ;
          // 在这里讲解一下字符串的类型是String。
         String str = age >= 18 ? "成年人" : "未成年人"；
		 System.out.println(str);
	}

2.5.3 三元运算符练习

获取两个数的较大值

public static void main(String[] args) {
    int a = 30;
    int b = 20;
    int c = a > b ? a : b;
    System.out.println(c);
}

2.6 案例

随便给你一个三位数，计算出它的各位，十位，和百位并输出显示。

public static void main(String[] args) {
    // 随便给你一个三位数，计算出它的各位，十位，和百位并输出显示。
    int num = 123;
    // 个位数直接对10取余就可以得到
    int ge = num % 10;
    System.out.println("个位：" + ge);
    // 十位数直接处以10，此时结果数据的个位就是十位数，然后对10求余即可。
    int shi = (num / 10) % 10;
    System.out.println("十位：" + shi);
    // 百位数直接对100求余即可。
    int bai = num / 100;
    System.out.println("百位：" + bai);
}

第三章流程控制

3.1 概述

软件是为了模拟现实世界的，流程控制语句是模拟现实世界的各种行为活动。在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能。

现实世界中的活动有: 顺序活动（按部就班一步一步的完成某件事情），选择活动（达到什么条件我才去做这个时间），重复活动（反复的去干一件事情，比如我们反复的去背一首诗，直到背熟为止）。

所以Java的流程控制语句也有三种，依次是：顺序结构、分支结构、循环结构(重复执行一段代码)。

3.2 顺序结构

顺序执行，根据编写的顺序，从上到下运行

public static void main(String[] args){
    //顺序执行，根据编写的顺序，从上到下运行
    System.out.println("程序开始");
    System.out.println("我爱你！");
    System.out.println("在一起！");
    System.out.println("结婚吧！");
    System.out.println("程序结束");
}

3.2 分支结构

分支结构就是满足某个条件，才执行对应的代码。分支结构包含了if语句和switch分支,实际上if相比switch要强大很多，当然switch也有它独特的优势，我们先学习if语句。

3.2.1 if分支结构格式1–if

if语句第一种格式： if

if(关系表达式)｛
  	语句体;
｝

执行流程
- 首先判断关系表达式看其结果是true还是false
- 如果是true就执行语句体
- 如果是false就不执行语句体

public static void main(String[] args) {
    System.out.println("开始");
    int age = 19 ;
    if(age >= 18){
        System.out.println("您是成年人");
    }
    System.out.println("结束");
｝

3.2.2 if分支结构格式2–if…else

if语句第二种格式： if...else

if(关系表达式) { 
  	语句体1;
} else {
  	语句体2;
}

执行流程
- 首先判断关系表达式看其结果是true还是false
- 如果是true就执行语句体1
- 如果是false就执行语句体2

public static void main(String[] args){
    System.out.println("开始")；
    // 定义变量
    int age = 1;
    if(age >= 18){
        // +充当连接符。
        System.out.println(age+"是成年人");
    }else{
        System.out.println(age+"这个年龄应该不是成年人！");
    }
    System.out.println("结束");
}

3.2.3 if分支结构格式3–if…else if…else

if语句第三种格式： if...else if ...else

if (关系表达式1) {
  	执行语句1;
} else if (关系表达式2) {
  	执行语句2;
}
...
} else if (关系表达式n) {
 	执行语句n;
} else {
  	执行语句n+1;
}

执行流程
- 首先判断关系表达式1看其结果是true还是false
- 如果是true就执行语句体1
- 如果是false就继续判断关系表达式2看其结果是true还是false
- 如果是true就执行语句体2
- 如果是false就继续判断关系表达式…看其结果是true还是false
- …
- 如果没有任何关系表达式为true，就执行语句体n+1。

public static void main(String[] args) {
   System.out.println("开始");
    int age = 1220 ;
    if( 0 < age && age < 10 ){
        System.out.println("儿童");
    }else if(10 <= age && age < 18){
        System.out.println("青少年");
    }else if(18 <= age && age < 30){
        System.out.println("青年人");
    }else if(30 <= age && age < 40){
        System.out.println("壮年人");
    }else if(40 <= age && age < 50){
        System.out.println("中年人");
    }else if(50 <= age && age < 80){
        System.out.println("中老年人");
    }else if(80 <= age && age <= 200){
        System.out.println("长寿老人");
    }else{
        System.out.println("不是人");
    }
   System.out.println("结束");
}

3.3 if语句注意事项

1.不要在if()后面加; if();{}

如果if语句体的代码"只有一行"是可以省略大括号的。如果语句体代码有多行是不要省略大括号。

if语句只能控制后面的第一行语句。

// 格式：if(条件表达式) 语句体; 
public class IfDemo02{
	public static void main(String[] args){
		int a = 10;
		int b = 1;
		if(a == b) System.out.println("相等");
	}
}

EagleJB

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
day02【数据类型转换、运算符、方法入门】

【数据类型转换、运算符、方法入门】内容数据类型转换（数据类型，byte short int long float double char boolean int age = 10 ; long lg = 100 ; 类型最终要一致）算数运算符（开发人员是一定要参与运算的，数学，英文规范，语法，设计，流行框架，业务功能开发。 ...
复制链接

扫一扫