[学习交流] 【石家庄校区】基础班day02-数据类型转换，运算符，方法...

本帖最后由 xiekai_sjz 于 2018-9-7 14:36 编辑

day02 数据类型转换, 运算符, 方法入门
昨天我们学习了java的数据类型。java中分为基本数据类型和引用数据类型。昨天我们主要学习了基本数据类型，总共有byte, short, int , long, float, double, char, boolean这八种。我们今天来学习数据类型的转换和运算符，以及方法入门。
以下是今天的学习目标：

理解数据类型的强制转换
理解数据类型的自动转换
了解ASCII编码表
理解int类型和char类型的运算原理
理解运算符++ --的运算方式
理解+符号在字符串中的作用
理解比较运算符
理解逻辑运算符
掌握三元运算符的格式和计算结果
了解方法的概念
掌握无返回值无参数方法的定义格式
了解方法定义的注意事项

以下是今天的详细笔记：

数据类型转换自动类型转换
类型转换: 从一种数据类型转换为另一种数据类型
类型转换分为2种:
1. 自动类型转换(隐式): 数据范围从小到大进行转换, 自动完成
2. 强制类型转换(显式): 数据范围从大到小, 手动编写代码完成

[Java] 纯文本查看 复制代码

// 自动类型转换: 左边long = 右边int, 右边int自动提升为long类型然后赋值给左边
long num1 = 100;
double d = 100;
System.out.println(d);  // 100.0

强制类型转换
// 格式
范围小的类型范围小的变量名 = (范围小的类型) 原本范围大的数据;

// 示例
int num = (int) 10000L;

类型转换的注意事项
      1. 强制类型转换一般不推荐使用，因为有可能发生精度损失, 或数据溢出。
      2. byte/short/char 这三种类型都可以发生数学运算，例如加法"+".
      3. byte/short/char 这三种类型在运算的时候，都会被首先提升成为 int 类型，然后再计算。
      4. boolean 类型不能发生数据类型转换

[Java] 纯文本查看 复制代码

// 精度损失示例
int a = (int)3.14;
System.out.println(a);   // 3

// 数据溢出示例
byte b = 127;
b = (byte)(b + 1);
System.out.println(b);   // -128

byte b2 = -128;
b2 = (byte)(b2 - 1);
System.out.println(b2);  // 127

在进行数学运算时, 自动类型转换的规则:
byte, short, char -> int -> long -> float -> double

[Java] 纯文本查看 复制代码

// 查看以下代码的问题
public class Demo {
        public static void main(String[] args) {
                byte b1 = 10;
                byte b2 = 20;
                byte sum1 =（byte）( b1 + b2); // byte + byte -> int  + int = int

                byte b3 = 10;
                short s1 = 20;
                byte sum2 = b3 + s1; // byte + short -> int + int = int

                byte b4 = 10;
                int i1 = 20;
                byte sum3 = b4 + i1; // byte + int -> int + int = int

                int i2 = 10;
                long l1 = 20L;
                long sum4 = i2 + l1;  // int + long -> long + long = long

                long l2 = 10L;
                float f1 = 20F;
                float sum5 = l2 + f1; // long + float -> float + float = float

                int i3 = 10;
                double d1 = 20.0;
                double sum6 = i3 + d1;  // int + double -> double + double = double
        }
}

ASCII编码表
编码表: 数值和字符的对应关系表

ASCII : American Standard Code for Information Interchange，美国信息交换标准代码
ASCII编码表: 定义了一些控制字符, 大小写英文, 数字, 标点符号

常见字符对应数值:
'0'  48
'A'  65
'a'  97

运算符
算术运算符-四则运算和取余
算术运算符:
      +: 加法
      -: 减法
      *: 乘法
      /: 除法, 得到商
      %: 取模, 得到余数

注意:
      整数相除只能得到整数
      要想得到小数, 需要有小数参与运算(利用自动类型转换)。例如

[Java] 纯文本查看 复制代码

int a = 10 / 3;
System.out.println(a);    // 3

double d = 1.0 * 10 / 3;
System.out.println(d);    // 3.3333333333335

算术运算符: 加号的多种用法
+的3种用途:
      1. 对于数值是加法
      2. 对于 char 类型，在计算之前， char 会被提升成为 int ，然后再按数值计算
      3. 对于字符串 String ，加号代表字符串连接

[Java] 纯文本查看 复制代码

System.out.println("World" + "Hello"); // WorldHello

String str = "Java";
System.out.println(str + 20);         // Java20
System.out.println(20 + str);         // 20Java
System.out.println(str + 20 + 30);    // Java2030
System.out.println(str + (20 + 30));  // Java50
System.out.println(20 + 30 + str);    // 50Java
System.out.println("str=" + str);      // str=Java

算术运算符-自增自减
++: 自增. 让变量值增加1
--: 自减. 让变量值减少1

自增自减放前放后的区别:
      单独使用: 没有区别 i++;
      混合使用:
            ++i: 先加后用
                     先将变量i值增加1, 然后使用增加后的变量值, 作为++i表达式的值
            i++: 先用后加
                     先使用变量i本身的值作为i++表达式的值, 然后变量i再增加1

[Java] 纯文本查看 复制代码

// 前++和后++的执行流程
/*
混合使用:
        ++i: 先加后用
                先将变量i值增加1, 然后使用增加后的变量值, 作为++i表达式的值
        i++: 先用后加
                先使用变量i本身的值作为i++表达式的值, 然后变量i再增加1
*/
public class Test {
    public static void main(String[] args) {
        // 第一个
        int a = 0;
        a = a++;  // 后++: 先用后加
                // 1. 先用a变量本身的值0作为a++表达式的值: a = 0;
                // 2. 然后变量a再自增1, a++=1, 只是变量a自定, 和表达式无关  a=0; 此时a为1
                // 3. a = 0; 赋值, a为0
        System.out.println(a);        // 0
        
        // 第二个
        int b = 0;
        b = ++b;  // 前++: 先加后用. 
                // 1. 先将变量b自增1为1
                // 2. 然后用自定后的值, 作为++b表达式的值, b = 1;
                // 3. 赋值, b就为1
        System.out.println(b);        // 1
        
        // 第三个
        int c = 10;
                int result1 = ++c + c++;
        // c            11   12 
        //  参加运算     11   11    
                /*
                        ++c + c++
                        1. ++c: 前++. 先将变量c的值自增1为11, 然后再用自增后的值作为++c表达式的值 11 + c++
                        2. c++: 后++. 先用变量c本身的值作为c++表达式的值 11 + 11, 然后变量c再自增1为12
                        3. int result1 = 11 + 11; 赋值 reuslt1 = 22
                */
                System.out.println(result1);  // 22
                System.out.println(c);        // 12
                
                
                // 第四个
        int d = 10;
                int result2 = d++ + ++d;
        //d             11   12
        //参加运算      10    12
                /*
                        d++ + ++d:
                        1. d++: 后++. 先用变量d本身的值作为d++表达式的值 10 + ++d, 然后变量d再自增1为11
                        2. ++d: 前++. 先将变量d的值自增1为12, 然后再用自增后的值作为++d表达式的值: 10 + 12
                        3. int result2 = 10 + 12; 赋值 reusult2
                */
                System.out.println(result2);  // 22
                System.out.println(d);        // 12
    }
}

赋值运算符
基本赋值运算符：
      =: 将右侧的数据交给左侧的变量. int a = 30;
复合赋值运算符：
      +=: 左边与右边相加, 将结果赋值给左边.  a += 3; 相当于 a = (a的类型)(a + 3);
      -=: 左边与右边相减, 将结果赋值给左边.  b -= 4; 相当于 b = (b的类型)(b - 4);
      *=: 左边与右边相乘, 将结果赋值给左边.  c *= 5; 相当于 c = (c的类型)(c * 5);
      /=: 左边与右边相除, 将结果赋值给左边.  d /= 6; 相当于 d = (d的类型)(d / 6);
      %=: 左边与右边取模, 将结果赋值给左边.  e %= 7; 相当于 e = (e的类型)(e % 7);

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

[Java] 纯文本查看 复制代码

// 以下代码是否正确?
byte b = 1;
b = b + 1;   // 编译报错 byte + int  -> int + int = int

byte bb = 1;

bb += 1;   // bb = (byte)(bb + 1);  byte + int -> int + int = int

比较运算符
比较运算符：也叫做关系运算符
      >: 大于
      <: 小于
      >=: 大于等于
      <=: 小于等于
      ==: 相等
      !=: 不相等


注意事项：
      1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
      2. 如果进行多次判断，不能连着写。
            数学当中的写法，例如：1 < x < 3, 程序当中不允许这种写法。
            1 < x 并且 x < 3
逻辑运算符
逻辑运算符:
      &&: 与. 并且. 两边都为true才是true, 只要有一个false则为false
            短路与. 如果左边能提前得出结果, 则不会执行右边的判断
      ||: 或. 或者. 两边只要有一个true则为true, 两边都为false则为false
            短路或. 如果左边能提前得出结果, 则不会执行右边的判断
      !: 非(取反).

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

[Java] 纯文本查看 复制代码

/*
&&, || 短路效果: 如果左边能提前确定结果, 则右边不用执行

短路的区别:
        &, &&: 结果一样, 只是&&具有短路效果, &没有
        |, ||: 结果一样, 只是||具有短路效果, |没有
*/
public class Test {
        public static void main(String[] args) {
                // 双与 &&  具有短路效果
                int a = 10;             
                System.out.println(false && ++a < 100); // false && ... = false
                System.out.println(a);                  // 10
                
                // 单与 &   没有短路效果
                int b = 10;
                System.out.println(false & ++b < 100);  // false & true = false
                System.out.println(b);                  // 11
                
                
                // 双或 ||  具有短路效果   true || ...
                int c = 10;
                System.out.println(true || ++c < 100);  // true || ... true
                System.out.println(c);                  // 10
                
                // 单或 |   没有短路效果
                int d = 10;
                System.out.println(true | ++d < 100);   // true | true = true
                System.out.println(d);                  // 11
        }
}

数学公式的写法:
// 对于1 < x < 3的情况，应该拆成两个部分，然后使用与运算符连接起来
boolean b = 1 < x && x < 3;

字符范围的判断:

[Java] 纯文本查看 复制代码

// 由于char也可以用数值表示, 所以我们可以利用这一特点对某个字符是否属于小写英文, 大写英文, 数字来进行判断
// 判断符合小写英文字母
char ch = 'A';
boolean isLowerLetter = ch >= 'a' && ch <= 'z';

// 判断符合大写英文字母?
char ch = 'A';
boolean isLowerLetter = ch >= 'A' && ch <= 'Z';

// 判断符合数字?
char ch = '4';
boolean isLowerLetter = ch >= '0' && ch <= '9';

三元运算符
一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。

三元运算符格式：
      数据类型变量名称 = 条件判断? 表达式A : 表达式B;

流程：
      首先判断条件是否成立：
      如果成立为true，那么执行表达式A, 并将表达式A的结果赋值给左侧的变量；
      如果不成立为false，那么执行表达式B, 并将表达式B的结果赋值给左侧的变量；

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

[Java] 纯文本查看 复制代码

int a = 10;
int b = 20;
int max = a > b ? a : b; 
System.out.println(max);       // 20

String result = a == b? "相等" : "不相等";
System.out.println(result);    // 不相等

方法入门
方法概念
方法: 实现某种功能的代码块
方法的作用:
将实现某种功能的代码聚合到一起, 便于重复使用, 提高代码的复用性, 提高可维护性
方法的定义
定义方法的格式：(格式可以参考main()方法)

[Java] 纯文本查看 复制代码

public static void 方法名称() {
        方法体    // 也就是大括号当中可以包含任意条语句
}

public class Test {
    
    
    public static void main(String[] args) {
        eat();
    }
    
    public static void eat() {
        // ...
    }
    
}

注意事项：
      1. 方法定义的先后顺序无所谓
      2. 方法的定义不能产生嵌套包含关系
      3. 方法定义好了之后，不会执行的。如果要想执行，一定要调用方法
方法的调用
调用方法格式：
      方法名();

// 示例
public static void main(String[] args) {
      // 在main方法中调用其他方法
方法名称();
}

[Java] 纯文本查看 复制代码

/*
需求: 
定义4个方法: 农民farmer(), 商贩seller(), 厨师cook(), 我me(). 
方法内分别实现各自功能. 
在main()方法中调用以上方法
*/
public class Test {
        public static void main(String[] args) {
                // 调用方法
                farmer();
                seller();
                cook();
                me();
        }
        
        // 农民
        public static void farmer() {
                System.out.println("种地");
                System.out.println("除草");
                System.out.println("收割");
        }
        
        // 商贩
        public static void seller() {
                System.out.println("低买");
                System.out.println("高卖");
        }
        
        // 厨师
        public static void cook() {
                System.out.println("切菜");
                System.out.println("上桌");
        }
        
        // 我
        public static void me() {
                System.out.println("吃");
                System.out.println("付钱");
        }
}

JDK9的JShell使用
JShell的使用:
      进入: cmd窗口内输入jshell
      退出: jshell中输入/exit

JShell适用于测试一些简单的代码片段
编译器的两点优化
1. byte/short/char
      如果没有超过左侧的范围，编译器补上强转。byte b = 10;
      如果右侧超过了左侧范围，那么直接编译器报错。
2. 编译器的常量优化
      在给变量进行赋值时
            如果右侧的表达式当中全都是常量，那么编译器javac将会直接将若干个常量表达式计算得到结果
            如果表达式当中有变量参与，那么就不能进行这种优化了。

// 等号右边全都是常量，没有任何变量参与运算
short result = 5 + 8;
// 编译之后，得到的.class字节码文件当中相当于【直接就是】：
byte result = 12; // 右侧的常量结果数值，没有超过左侧范围，所以正确。
扩展
取模%操作的用途

判断是否是奇数偶数
判断是否能被某个数整除
获取一个数的个位, 十位, 百位...
产生轮流的数值

[Java] 纯文本查看 复制代码

//判断是否是奇数偶数
x % 2 == 0  true是偶数, false是奇数
x % 2 == 1  true是奇数, false是偶数

4 % 2 = 0
3 % 2 = 1
2 % 2 = 0
1 % 2 = 1
0 % 2 = 0


// 判断是否能被某个数整除
x % 这个数 == 0 true则能被这个数整除
10 % 5 = 0
11 % 5 = 1


// 获取一个数的个位, 十位, 百位...
int i = 12345;
int ge = i % 10;           // 12345% 10 = 5
int shi = i / 10 % 10;     // 1234 % 10 = 4
int bai = i / 100 % 10;    // 123  % 10 = 3
int qian = i / 1000 % 10;  // 12   % 10 = 2
int wan = i / 10000 % 10;  // 1    % 10 = 1


// 产生轮流的数值, 如产生3个不同的值轮流, 就用连续的数字%3
0 % 3 = 0;
1 % 3 = 1;
2 % 3 = 2;
3 % 3 = 0;
4 % 3 = 1;
5 % 3 = 2;
6 % 3 = 0;

冯光 · 冯光

挺全的，老师讲的也非常好！！！

d122161279 · d122161279

再次强势入驻二楼!

王重 · 王重

我已收藏

cuipu · cuipu

冒个泡，再冒个泡

xiekai_sjz · xiekai_sjz

d122161279 发表于 2018-8-23 21:06
再次强势入驻二楼!

很棒

帐号		自动登录	找回密码
密码			加入黑马

[学习交流] 【石家庄校区】基础班day02-数据类型转换，运算符，方法...

5 个回复

浏览过的版块