Java数据类型转换、运算符、方法

主要内容
数据类型转换

算数运算符

比较运算符

逻辑运算符

三元运算符

简单方法定义和调用

教学目标

理解数据类型的强制转换

理解数据类型的自动转换

了解ASCII编码表

理解int类型和char类型的运算原理

理解运算符++ --的运算方式

理解+符号在字符串中的作用

理解比较运算符

理解逻辑运算符

掌握三元运算符的格式和计算结果

了解方法的概念

掌握无返回值无参数方法的定义格式

了解方法定义的注意事项

第一章 数据类型转换
在java中，不同的数据需要保存在不同的空间中，而开辟空间的时候，需要通过不同的类型关键字来定义当前这个空间是什么类型的空间。

开辟的空间如果和保存的数据类型不一致，那么就很容易导致程序出现错误。

这时我们就需要使用数据类型的转换技术，完成数据的保存工作。

数据类型的转换，可以分为两种：

1）隐式类型转换（自动类型转换）自动类型提升

2）强制类型转换

1.1 隐式类型转换

隐式类型转换：在程序中，空间保存的数据类型不一致的时候，java内部会自动的帮助我们转换。

要能够自动转换，必须遵守Java中的自动转换的规则：

可以把小空间中的数据给大空间中保存。

byte 空间中的数据， 可以自动的转成 short int long float double

但是不能把double 保存在 byte 、int 、 short 、long 等空间。

案例代码

/*
+:是一个运算符，做加法运算的。
我们在做运算的时候，一般要求参与运算的数据类型必须一致。

类型转换：
隐式转换
强制转换

隐式转换
byte,short,char – int – long – float – double
*/
public class TypeCastDemo {
public static void main(String[] args) {
//定义两个int类型的变量
int a = 3;
int b = 4;
int c = a + b;
System.out.println©;

//定义一个byte类型,定义一个int类型
byte bb = 2;
int cc = 5;
System.out.println(bb + cc);

//我能不能不直接输出，用一个变量接收呢?
//用变量接收，这个变量应该有类型
//可能损失精度
//byte dd = bb + cc;
int dd = bb + cc;
System.out.println(dd);

}
}
转换规则

容量小的类型可自动转换为容量大的数据类型 。

byte、short、char–>int–>long–>float–>double
1.2 强制转换

注意：

强制类型转换：它一般都会有数据的丢失。不建议强制转换。

格式：

需要转成的数据类型 变量名 = ( 需要转成的数据类型 )( 被转的数据 );

///////////////////////强制类型转换/////////////////////////////////
double d=3.14;
//int i=d;//报错
int i=(int)d;
System.out.println(i);
​
int i4 = (int )dd + 3.14; 报错。------》int i=(int)(dd+3.14);编译成功。

1.3 ASCII编码表

public static void main(String[] args) {
//字符类型变量
char c = ‘a’;
int i = 1;
//字符类型和int类型计算
System.out.println(c+i);//输出结果是98
}
在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。

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

人们就规定：

字符 数值
0 48
9 57
A 65
Z 90
a 97
z 122
将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表ASCII（

American Standard Code for Information Interchange 美国标准信息交换码）。

小贴士：

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

算数运算符包括：

• 加法运算，字符串连接运算

• 减法运算

• 乘法运算
  / 除法运算
  % 取模或者取余数运算，两个数字相除取余数
  ++ 、 – 自增自减运算
  1）在Java中进行算术运算的时候，运算符两侧的类型一致的时候， 运算的结果必须和运算的数据类型保持一致。

举例：int d = 4321 / 1000* 1000;

	4321 是int类型数据

	1000 也是int类型数据

	他们的商 也必须是int类型 

	4321 /1000  结果是 4  不是4.321

2）当算术运算两侧的类型不一致的时候，结果向大的类型保持。

举例：double d = 4321 / 1000.0* 1000;

代码案例

package com.itheima_01;
public class Demo {
public static void main(String[] args) {
// 定义两个变量
int a = 3;
int b = 4;
​
System.out.println(a + b);
System.out.println(a - b);
System.out.println(a * b);
System.out.println(a / b);
​
System.out.println(4321 / 1000 * 1000);//4000
System.out.println(4321 / 1000.0 * 1000);//4321.0
}
}
++ 运算，变量自己增长1。反之，-- 运算，变量自己减少1，用法与++ 一致。

++或者–既可以放在变量的后面，也可以放在变量的前面。

表现形式：

++或者–在变量的右侧，举例：i++，j–；

++或者–在变量的左侧，举例：++i，–j；

独立运算：

变量在独立运算时，前++和后++没有区别 。

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

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

和其他运算符混合运算：

如果++或者–在变量的后面(右侧)，先拿变量参与操作，后变量做++或者–；

如果++或者–在变量的前面(左侧)，先变量做++或者–，后拿变量参与操作；

变量前++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

public static void main(String[] args) {
int a = 1;
int b = ++a;
System.out.println(a);//计算结果是2
System.out.println(b);//计算结果是2
}
变量后++ ：变量a先把自己的值1，赋值给变量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);//计算结果是1
}

• 符号在字符串中的操作：

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

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

public static void main(String[] args){
// 定义变量
int a = 10;
int b = 20;
// 字符串参与加法操作
System.out.println(“hello” + a);//hello10
// “hello”+10,然后再和b进行拼接
System.out.println(“hello” + a + b);//hello1020
//30hello
System.out.println(a + b + “hello”);
}
2.2 赋值运算符

赋值运算符包括：
= 等于号
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
%= 取模等
赋值运算符，就是将符号右边的值，赋给左边的变量。

+=:a+=20;相当于a = (a的数据类型)(a + 20);

public static void main(String[] args){
// 把10赋值给int类型的变量a
int a = 10;
​
// += 把左边和右边的数据进行运算，最后赋值给左边。左边的只能是变量
a += 10;// 相当于a = a + 10
System.out.println(“a:” + a);
System.out.println("----------------------");
​
byte s = 10;
// s += 20; // 相当于 s = s + 20;
s = (byte) (s + 20);
System.out.println(“s:” + s);
}
2.3 比较运算符

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

比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<= 比较符号左边的数据是否小于或者等于右边的数据，如果小于或者等于结果是true。满足一个即可。
= 比较符号左边的数据是否大于或者等于右边的数据，如果大于或者等于结果是true。满足一个即可。
！= 不等于符号 ，如果符号两边的数据不相等，结果是true。
比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值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
}
2.4 逻辑运算符

逻辑运算符包括：
&& 短路双与 1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边不再运算，效率比单与高3.一假即假
& 短路单与 1. 两边都是true，结果是true 2. 一边是false，结果是false 短路特点：符号左边是false，右边依然会运算，效率比双与低3.一假即假
|| 短路双或 1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点：符号左边是true，右边不再运算，效率比单或高3.一真即真
| 短路单或 1. 两边都是false，结果是false 2. 一边是true，结果是true 短路特点：符号左边是true，右边依然会运算，效率比双或低3.一真即真
！ 取反 1. ! true 结果是false 2. ! false结果是true
逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值true或者false

public static void main(String[] args) {
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && true);//false，右边不计算

System.out.println(false || false);//falase
System.out.println(false || true);//true
System.out.println(true || false);//true，右边不计算

System.out.println(!false);//true

}
2.5 三元运算符

三元运算符格式：

数据类型 变量名 = 布尔类型表达式？结果1：结果2
三元运算符计算方式：

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

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

三元运算符要求必须有一个结果，在结果1或者结果2中。开发中一般用来比较数值大小。

public static void main(String[] args) {
int i = (1==2 ? 100 : 200);
System.out.println(i);//200
int j = (3<=4 ? 500 : 600);
System.out.println(j);//500
}
第三章 方法入门
3.1 概述

方法：也可以称为函数。它表示的是一段可以独立运行的代码，具有独立功能。就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当在程序中需要使用的时候可以通过函数（方法）的名字去调用。把这段代码称为一个函数（方法）。

它的书写位置：它必须在类的大括号中，不能写在main方法里面，要和main方法在关系上属于并列关系，我们自己定义的函数（方法）和main方法没有先后次序。

例：main方法(main函数) 功能：可以让java程序运行

public static void main(String[] args) {
System.out.println(“Hello World”);
}
3.2 方法的作用

需求：对两个int类型的数据求和值：

public class Demo {
public static void main(String[] args) {
// 定义变量
int a = 10;
int b = 20;
// 求和值
int sum = a + b;
// 输出和值
System.out.println(“sum=” + sum);
// 定义变量
int a1 = 1;
int b1 = 2;
// 求和值
int sum1 = a1 + b1;
// 输出和值
System.out.println(“sum1=” + sum1);
}
}
以上程序中，存在相同的功能代码，这种重复书写的功能代码，会造成程序的阅读性很差、程序中代码的复用性更差.

复用性好：指的就是功能代码只要书写一次，就可以重复的使用(调用)。

怎么解决程序中代码复用性差的问题？

1） 把以上程序中相似的功能代码，提取出来，重新封装到一个新的功能中：-------》方法

（使用方法把以上程序中相似的功能代码，提取出来封装）

2）在使用该功能打印数组的时候直接调用该方法即可。

方法的作用：可以提高程序中代码的复用性

3.3 方法的定义

定义格式：

方法修饰符 方法返回值类型 方法名 （参数列表）｛
方法体代码；//具体完成相应功能的代码。
return 返回值; //返回值的类型必须是之前定义方法时所声明的方法的返回值类型
｝
定义格式解释：

修饰符： 用来修饰方法的一些符号(关键字)，目前针对方法的修饰符，我们先照抄main方法。属于固定写法 public static 。

返回值类型： 当我们在程序封装了一段独立的代码之后，如果这段代码运行完，需要把一个具体的结果返回给调用者，这时当前这个方法的返回值类型就需要和返回的那个数据保持一致。如果这个方法调用完之后，不需要给调用者返回任何数据，这时方法的返回值类型必须写void。

注意：如果需要返回，则用return关键字。

方法名：它就是前面学习的标识符。我们给独立代码命名需要遵守标识符的规则。就是封装的功能名字。(开发人员自己起名称)用来调用方法。

参数列表： 当定义一个功能(函数、方法)的时候，需要接受调用者传递进来的数据时，就需要在定义方法的时候，书写对应的参数。

参数：参加运算的数据。

 参数的类型：就是前面学习的变量的类型。

 参数名：其实就是变量名。

如果不需要接受参数，这时小括号中的参数可以省略，但是小括号不能省略。

方法体：就是在方法的大括号中书写代码，这里的代码和以前学习时在main方法中写的代码没有区别，以前在main方法中可以写的任何代码，都可以在自己定义的方法体中书写。

return：方法结束。因为返回值类型是void，方法大括号内的return可以不写。

举例：

public static void methodName() {
System.out.println(“这是一个方法”);
}
3.4 方法的调用

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

案例：使用自定义方法分别对上述2个int类型的数据进行求和。

public class Demo {
public static void main(String[] args) {
// 定义变量
int a = 10;
int b = 20;
// 调用自定义方法求和值
getSum(a,b);
// 定义变量
int a1 = 1;
int b1 = 2;
// 调用自定义方法求和值
getSum(a1,b1);
}
//自定义方法让main方法调用并求两个int类型的数据和值
public static void getSum(int a, int b) {
// 求和值
int sum=a+b;
//输出和值
System.out.println(“sum=”+sum);
}
}
3.5 调用练习

练习一：将三元运算符代码抽取到自定义的方法中，并调用。

public static void main(String[] args) {
//调用定义的方法operator
operator();
}
//定义方法，方法中定义三元运算符
public static void operator() {
int i = 0;
i = (1==2 ? 100:200);
System.out.println(i);
int j = 0 ;
j = (3<=4 ? 500:600);
System.out.println(j);
}
练习二：定义功能计算2个int类型数据的和值。要求带返回值。

分析：

定义功能，就是书写一个方法。

书写一个方法，就要考虑方法的定义格式。

格式：

方法修饰符 返回值类型 方法名 （参数）

{	

}

class Demo2
{
public static void main(String[] args)
{
//调用自定义的函数,得到计算好的和
int x=add(3,7);
System.out.println(“x=”+x);
}
​
//自定义函数计算两个int类型数据的和
public static int add(int a,int b)
{
//函数体
//计算接收两个int类型的和
int sum=a+b;
//用return关键字将计算的和返回给调用者
return sum;
}
}
3.6方法的执行过程

注意：

1）当jvm在执行任意一个函数时，遇到return关键字，这时不管该函数的代码是否执行完成，当前这个函数都会结束；

2）在函数执行中遇到return需要返回，具体的返回位置就是在调用这个函数的地方。

3.7 注意事项

方法定义注意事项：

方法的返回值问题：

一般在我们定义方法的时候，肯定是先有需求，然后需要根据这个需求进行分析，在分析的过程中，如果需要把方法运行之后的结果告诉调用者，这时方法必须有返回值，并且在方法体中必须书写return语句，把具体的值返回。

如果方法运行完之后，不需要把结果告诉调用者，这时方法不需要返回任何数据，那么在方法体中可以不写return数据。

问题：当一个方法没有返回值的时候，可以书写return语句吗？

可以。一个方法没有返回值，返回值类型一定是void ，但在方法中可以书写return语句，这时的return后面直接写分号，不要写任何数据。

例如： return ; (分号)

这样的return，只是为快速的结束函数。

public static void demo() {
{
// 结束方法
return;
}
// 输出
// System.out.println(“执行不到”);
}
参数问题：

定义功能的时候，需要接收参数，这时在功能上一定要定义变量，然后接收具体的参数，这时参数的类型必须和传递的数据一定要保持一致。如果不需要接收数据，就可以省略参数。

第四章 JShell脚本工具(了解)
JShell脚本工具是JDK9的新特性

脚本：可以理解是剧本的意思，脚本语言就是脚本或者文档里面写什么就执行什么，按照脚本来执行。不用编译和运行。

什么时候会用到JShell工具呢，当我们编写的代码非常少的时候，而又不愿意编写类，main方法，也不愿意去编译和运行，这个时候可以使用JShell工具。

启动JShell工具，在DOS命令行直接输入JShell命令。

接下来可以编写Java代码，无需写类和方法，直接写方法中的代码即可，同时无需编译和运行，直接回车即可

小贴士:

JShell工具，只适合片段代码的测试，开发更多内容，建议编写在方法中。