two文档

Codefacebook

已于 2024-07-28 18:27:32 修改

阅读量393

点赞数 4

文章标签： java 开发语言

于 2024-07-28 18:27:14 首次发布

本文链接：https://blog.csdn.net/2406_85562971/article/details/140754229

版权

【运算符、键盘录入、类型转换】

今日内容介绍

运算符【重点】
键盘录入【重点】
数据类型转换【难点非重点: 理解】

学习目标

能够获取键盘录入的数据完成各种数学运算
能够知道类型转换的格式和顺序
能够说出常见的运算符有哪几种
能够知道除法和取余的区别
能够完成字符和字符串的加法
能够知道&&和&的区别
能够使用三元运算符完成获取两个数中较大值
能够使用键盘录入数据并完成两个数据求和

第一章运算符【重点中的重点】

1.1 算术运算符加减乘除

1.运算符：对常量或者变量进行操作/运算的符号 
2.表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
3.数学运算符: 
    (1)+: 加法运算
    (2)-: 减法运算
    (3)*: 乘法运算 
    (4)/: 除法运算 
        被除数 ÷ 除数 = 商(/: 获取除法运算中的商) ... 余数(%: 获取除法运算中的余数)

package com.itheima03_suanshu;

/*
    算术运算符
        1.运算符：对常量或者变量进行操作/运算的符号
        2.表达式：用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。
        3.数学运算符:
            (1)+: 加法运算
            (2)-: 减法运算
            (3)*: 乘法运算
            (4)/: 除法运算
                被除数 ÷ 除数 = 商(/:获取的是除法运算中的商) ... 余数
 */
public class Demo03Operator {
    public static void main(String[] args) {
        //定义2个int变量,并初始化
        //int a = 30;
        //int b = 20;
        int a = 30, b = 20;
        System.out.println(a + b);//30+20:50
        System.out.println(a - b);//30-20:10
        System.out.println(a * b);//30*20:600
        System.out.println(a / b);//30/20: 1        
    }
}

1.1.1 算术运算符%

%运算符(取余数运算符)
%的作用:
    1.判断数字的奇偶性
        偶数(可以被2整除): 数字%2 的 结果是0
        奇数(不可以被2整除): 数字%2 的 结果不是0 ==> 结果是1
    2.判断一个数字能否被另外一个数字整除
        结果为0: 说明可以被整除
        结果不为0: 说明不可以被整除

package com.itheima03_suanshu;

/*
    %(取余数)运算符
        被除数 ÷ 除数 = 商(/:获取的是除法运算中的商) ... 余数(%:获取的是除法运算中的余数)
        总结:
            /和%都是做数学中的除法运算,只不过/获取到的是除法运算中的商,%获取到的是除法运算中的余数

        作用:
            1.判断数字的奇偶性:
                偶数: 可以被2整除,余数是0
                奇数: 不可以被2整除,余数是1

            2.判断一个数字能否被另一个数字整除
                结果是0: 可以被整除
                结果不是0: 不可以被整除

        思考:
            int变量num中存储四位数字1234,利用/和%计算个位十位百位千位?
            个位: 4
            十位: 3
            百位: 2
            千位: 1
 */
public class Demo04Operator {
    public static void main(String[] args) {
        System.out.println(16 % 2);//0: 说明16是偶数
        System.out.println(21 % 2);//1: 说明21是奇数

        System.out.println(100 % 25);//0: 说明100可以被25整除
        System.out.println(111 % 25);//11: 说明111不可以被25整除

    }
}

/*
    int变量num中存储四位数字1234,利用/和%计算个位十位百位千位?
        个位: 4
        十位: 3
        百位: 2
        千位: 1
    总结:
        个位: num%10
        十位: num/10%10
        百位: num/100%10
        千位: num/1000%10 如果确定是四位数字,可以省略%10
 */
public class Demo03Lianxi {
    public static void main(String[] args) {
        //定义int变量num,并初始化
        int num = 1234;
        //计算个位
        int ge = num % 10;//把表达式num % 10的计算结果保存到int变量ge中
        //计算十位
        int shi = num / 10 % 10;
        //计算百位
        int bai = num / 100 % 10;
        //计算千位
        int qian = num / 1000 % 10;
        //此处 + 号 代表 字符串的连接
        System.out.println("个位: " + ge);
        System.out.println("十位: " + shi);
        System.out.println("百位: " + bai);
        System.out.println("千位: " + qian);
    }
}

1.1.2 算术运算符+的特殊用法

+的作用
1.完成数学中的加法运算
2.完成字符串的连接(拼接): 如果+的左右两边出现字符串

package com.itheima03_suanshu;

/*
    +的作用
        1.完成数学中的加法运算: +左右两边都是数字或者字符
        2.完成字符串的连接(拼接): 如果+的左右两边出现字符串
 */
public class Demo05Operator {
    public static void main(String[] args) {
        System.out.println(5 + 5);//10
        System.out.println(5 + "HelloWorld");//5HelloWorld
        System.out.println("HelloWorld" + 5);//HelloWorld5
        System.out.println("Hello" + "World");//HelloWorld

        /*
            表达式"5+5=" + 5 + 5: 从左向右执行
            先计算表达式"5+5=" + 5:  +号左侧是字符串"5+5=",右侧是数字5,此处+号代表字符串的连接
            表达式"5+5=" + 5的结果: "5+5=5"
            再计算表达式"5+5=5" + 5: +号左侧是字符串"5+5=5",右侧是数字5,此处+号代表字符串的连接
            最终结果:
                "5+5=55"
         */
        System.out.println("5+5=" + 5 + 5);//5+5=55

        /*
            表达式"5+5=" + (5 + 5): 从左向右执行
            但是优先计算()中的内容,先计算表达式(5 + 5): 结果是10
            再计算表达式"5+5=" + 10: +号左侧是字符串"5+5=",右侧是数字10,此处+号代表字符串的连接
            最终结果:
                "5+5=10"
         */
        System.out.println("5+5=" + (5 + 5));//5+5=10
    }
}

1.2 赋值运算符

+= 	加后赋值   a+=b，将a+b的值给a 	a = a + b
-= 	减后赋值   a-=b，将a-b的值给a 	a = a - b
*= 	乘后赋值   a*=b，将a×b的值给a 	a = a * b
/= 	除后赋值   a/=b，将a÷b的商给a    a = a / b
%= 	取余后赋值  a%=b，将a÷b的余数给a  a = a % b
注意:
	1.=: 表示的是赋值运算
	2.==: 表示的是判断是否相同

//赋值运算符
public class Demo04FuZhi {
    public static void main(String[] args) {
        //定义2个int变量并初始化
        int a = 30, b = 20;

        a += b;//a = a + b
        System.out.println(a);//50
        System.out.println(b);//20
        System.out.println("----------");

        //定义2个int变量未初始化
        int c, d;
        c = 100;
        d = 25;

        c /= d;//c = c / d
        System.out.println(c);//4
        System.out.println(d);//25
        System.out.println("----------");

        int e = 100, f = 25;
        e %= f;//e = e % f
        System.out.println(e);//0
        System.out.println(f);//25
    }
}

1.3 自增自减运算符

/*
    自增(++)自减(--)运算符
        1.作用: 就是让变量的值增加1(++)或者减少1(--)
        2.使用格式:
            (1)可以写在变量的前面: ++a,--a
            (2)可以写在变量的后面: a++,a--
        3.使用注意事项:
            (1)单独使用:++或者--自己独占一行,没有其它多余的操作
                此时:
                前++和后++效果一样,都是让变量的值增加1
                前--和后--效果一样,都是让变量的值减少1
            (2)混合使用: ++或者-- 和其它操作(赋值/打印)一起进行运算
                将产生重大区别:
                ++/--写在前面【先++/--,再使用】: 
				先把变量值增加1(++)或者减少1(--),然后把变量增加1(++)或者减少1(--)的结果进行其它运算
				++/--写在后面【先使用,再++/--】:
				先使用变量增加1(++)或者减少1(--)之前的数据,然后变量的值再增加1(++)或者减少1(--)
        4.注意:
            虽然++和--可以写出非常非常复杂的表达式,那些是研究生们研究的问题
            我们最常用的就是:
                a++: 变量a的值增加1
                a--: 变量a的值减少1
 */

public class Demo05ZiZeng {
    public static void main(String[] args) {
        int a = 1;
        //单独使用
        a++;//等价于: a = a + 1
        System.out.println(a);//2
        int b = 1;
        //单独使用
        ++b;//等价于: b = b + 1
        System.out.println(b);//2
        int c = 2;
        //单独使用
        c--;//等价于: c = c - 1
        System.out.println(c);//1
        int d = 2;
        //单独使用
        --d;//等价于: d = d - 1
        System.out.println(d);//1
    }
}

public class Demo06ZiZeng {
    public static void main(String[] args) {
        int a = 1;
        /*
            因为++在变量a的前面,先把变量a的值增加1,变量a的值变成2,
            然后再使用变量a增加1之后的结果2赋值给变量b,所以变量b的值是2
         */
        int b = ++a;
        System.out.println(a);//2
        System.out.println(b);//2
        int c = 1;
        /*
            因为++在c变量c的后面,先使用变量c增加1之前的值1,赋值给变量d,
            所以d的值是1,然后c的值增加1,c变成2
         */
        int d = c++;
        System.out.println(c);//2
        System.out.println(d);//1
    }
}

1.4 关系运算符

1.作用:
	用来比较两个数据之间的大小关系,结果是boolean类型的数据	        
2.特点:	
	关系表达式不管写的多么复杂,或者多么简单,最终结果要么是true(成立),要么是false(不成立)    
3.分类:	
	== 	a==b，	判断a和b的值是否相等，成立为true，不成立为false
    > 	a>b，	判断a是否大于b，成立为true，不成立为false
	>= 	a>=b，	判断a是否大于或者等于b，成立为true，不成立为false
	< 	a<b，	判断a是否小于b，成立为true，不成立为false
	<= 	a<=b，	判断a是否小于或者等于b，成立为true，不成立为false
	！= 	a!=b，	判断a和b的值是否不相等，成立为true，不成立为false	
4.注意:
	1.=: 表示的是赋值运算
	2.==: 表示的是判断是否相同

//关系表达式
public class Demo06GuanXi {
    public static void main(String[] args) {
        int a = 10, b = 20;
        System.out.println(a > b);//10 > 20: false
        System.out.println(a >= b);//10 >= 20: false
        System.out.println(a < b);//10 < 20: true
        System.out.println(a <= b);//10 <= 20: true
        System.out.println(a != b);//10 != 20: true
        System.out.println(a == b);//10 == 20: false
        //把变量b的值赋值给变量a,然后再打印a的值
        System.out.println(a = b);//20
    }
}

1.5 逻辑运算符

举例: 咱们班哥们在黑马学习java,顺利毕业,高薪就业,找到了对象,谈了好长时间,需要谈婚论嫁
到你对象家和准岳母谈判:
	准岳母:
		小伙子呀,你呢? 必须得有房(条件1:true/false),
		而且呢,你呀,还得有车(条件2:true/false),然后你们的婚事才能决定下来(结果: true/false)       
   	总结:
		像上面的两个/多个条件必须都得成立,结果才成立
		只要有一个条件不成立,结果就不成立,此时这多个条件使用逻辑与&来连接	
	准岳母:
		小伙子呀,你呢? 要么有房(条件1:true/false),要么有车(条件2:true/false),
		然后你们的婚事才能决定下来(结果: true/false),使用逻辑或运算符|连接多个条件            
   	总结:
		像上面的两个/多个条件只要有一个条件成立,结果就成立
		如果所有条件都不成立,那么结果就不成立,此时这多个条件使用逻辑或|来连接    
1.作用: 
	用来连接多个布尔表达式的,结果也是布尔类型
2.分类:
	(1)逻辑与(&:shift+7)【有false，则false】:
		表示并且的意思,同时成立的意思
		多个条件都为true,结果才为true
		多个条件只要有一个为false,结果就是false
    (2)逻辑或(|:shift+\)【有true，则true】:
		表示或者的意思
		多个条件只要有一个为true,结果就是true
		多个条件都是false,结果就是false
	(3)逻辑异或(^:shift+6):			目前暂时不用
		相同为false,不同为true
	(4)逻辑非(!:shift+1):
		!true: 就是false
		!false: 就是true

//逻辑运算符
public class Demo07LuoJi {
    public static void main(String[] args) {
        int a = 10, b = 20, c = 30;
        System.out.println((a > b) & (a > c));//false & false --> false
        System.out.println((a < b) & (a < c));//true  & true  --> true
        System.out.println((a > b) & (a < c));//false & true  --> false
        System.out.println((a < b) & (a > c));//true  & false --> false
        System.out.println("-------------------");
        System.out.println((a > b) | (a > c));//false | false --> false
        System.out.println((a < b) | (a < c));//true  | true  --> true
        System.out.println((a > b) | (a < c));//false | true  --> true
        System.out.println((a < b) | (a > c));//true  | false --> true

        System.out.println("-------------------");
        System.out.println((a > b) ^ (a > c));//false ^ false --> false
        System.out.println((a < b) ^ (a < c));//true  ^ true  --> false
        System.out.println((a > b) ^ (a < c));//false ^ true  --> true
        System.out.println((a < b) ^ (a > c));//true  ^ false --> true
        System.out.println("-------------------");

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

        System.out.println(a != b);//true
        System.out.println(!(a == b));//!false --> true
    }
}

1.5.1 逻辑运算符的短路效果

/*
    逻辑运算符的短路效果
        1.基本使用
            (1)短路逻辑与(&&): 左侧为false,右侧不进行计算
            (2)短路逻辑或(||): 左侧为true,右侧不进行计算

        2.使用区别):
            (1)&&和&: 最终的结果是相同的,但是&&具有短路的效果,效率高
            (2)||和|: 最终的结果是相同的,但是||具有短路的效果,效率高

        3.注意:
            以后实际学习/开发过程中,需要连接多个条件时,强烈建议使用&& 或者 ||
 */

public class Demo08DuanLu {
    public static void main(String[] args) {
        int a = 1;
        /*
            表达式(3 < 2) && (++a) > 1: 从左向右计算
            先计算表达式3<2的结果:false
            对于&&而言,左侧为false,已经决定了最终的结果为false,&&的右侧不再计算,
            所以a的值没有变化,还是1
         */
        System.out.println((3 < 2) && ((++a) > 1));//false
        System.out.println(a);//1

        int b = 1;
        /*
            表达式(3 < 2) & (++b) > 1: 从左向右计算
            先计算表达式3<2的结果:false
            对于&而言,虽然左侧为false,已经决定了最终的结果为false,
            但是仍然要计算&的右侧的表达式,导致b的值增加1,b变成2
         */
        System.out.println((3 < 2) & ((++b) > 1));//false
        System.out.println(b);//2
        System.out.println("--------------");

        int c = 1;
        /*
            表达式(3 > 2) || (++c) > 2: 从左向右计算
            先计算表达式3 > 2的结果:true
            对于||而言,左侧为true,已经决定了最终的结果为true,||的右侧不再计算,
            所以c的值没有变化,还是1
         */
        System.out.println((3 > 2) || ((++c) > 2));//true
        System.out.println(c);//1

        int d = 1;
        /*
            表达式(3 > 2) | (++d) > 2: 从左向右计算
            先计算表达式3>2的结果:true
            对于|而言,虽然左侧为true,已经决定了最终的结果为true,
            但是仍然要计算|的右侧的表达式,导致d的值增加1,d变成2
         */
        System.out.println((3 > 2) | ((++d) > 2));//true
        System.out.println(d);//2
    }
}

1.6 三元运算符格式

1.格式:
	数据类型 变量名称 = 布尔表达式1 ？ 表达式2 ： 表达式3；
	注意：
    	？号前面的式子的结果必须是布尔类型
    	
2.执行流程:	
	（1）计算布尔表达式1的结果，看是true，还是false
	（2）如果布尔表达式1的结果是true，取表达式2的结果赋值给左侧的变量
	（3）如果布尔表达式1的结果是false，取表达式3的结果赋值给左侧的变量

执行流程图解:

1.6.1 三元运算符的练习之两个和尚

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

实现步骤:
	1.定义两个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
	2.用三元运算符获取两个和尚的较高身高值，并用临时身高变量保存起来。
	3.输出结果

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

第二章数据输入（应用）

2.1 键盘录入的基本使用

数据输出: 把程序的运行结果输出到控制台,从而显示到屏幕上
数据输入: 获取键盘录入的数据到程序中,从而在程序中对数据进行相关的运算

问题1:
	键盘录入很常用,如果每个程序员自己实现将非常麻烦,所以JDK的开发人员帮助我们实现了获取键盘录入数据的功能,把该功能定义到一个叫做Scanner的类中,同时把这个Scanner类放入java.util包中
	
问题2:
	如何使用jdk中的某个包中的某个类呢?
    java中数据类型分为基本类型(四类八种)和引用类型,对于引用类型的使用有固定的三个步骤
    然后键盘录入java.util.Scanner类也是一个引用类型,使用也有固定的三个步骤
    
键盘录入Scanner类的使用:
	1.导包(找到我们要使用的东西) import 引入
        格式: import 包名.类名;
		Scanner类的导包: import java.util.Scanner;
	2.创建对象
		格式: 类名 对象名 = new 类名(参数列表...);
		解释:
			(1)类名: class关键字后面指定的名字
			(2)对象名: 就是我们前面用的变量名,是一个标识符(符合命名规则)
            (3)=: 赋值的过程
            (4)new: 开辟内存空间创建对象的过程
            (5)参数列表: 根据需求指定
        创建Scanner类的对象:
			Scanner sc = new Scanner(System.in);
			注意: ()中的System.in目前是固定写法,就业班详细学习
	3.使用对象:
		sc.nextInt(): 获取键盘录入的整数数字(int范围)
        sc.nextDouble(): 获取键盘录入的小数数字(double范围)

2.2 键盘录入的理解

import java.util.Scanner;//导包
public class Demo09Scanner {
    public static void main(String[] args) {
        //(1)导包: import java.util.Scanner
        //(2)创建键盘录入Scanner类的对象sc
        Scanner sc = new Scanner(System.in);
        //(3)使用使用Scanner类的对象sc获取键盘录入的两个整数数字
        System.out.println("请输入第一个整数数字: ");
        //获取到键盘录入的int数字,赋值给变量a
        int a = 1000;
        //(4)把整数数字输出到控制台
        System.out.println("您输入的第一个整数数字: " + a);
        System.out.println("请输入第二个整数数字: ");
        //获取到键盘录入的int数字,赋值给变量b
        int b = sc.nextInt();
        //(4)把整数数字输出到控制台
        System.out.println("您输入的第二个整数数字: " + b);
    }
}

2.3 键盘录入的练习

/*
    键盘录入练习
    需求:
        获取键盘录入的两个整数(int类型)数字,在控制台输出求和的结果。
    实现步骤:
        1.导包(找到我们要所以的键盘录入功能): import java.util.Scanner
        2.创建键盘录入Scanner类的对象sc: Scanner sc = new Scanner(System.in);
        3.获取键盘录入的两个int数字,分别保存到两个int变量a和b中
        4.计算变量a和b的和,保存到int变量sum中
        5.打印sum的值
    注意事项:
        不用自己手动导包,自己写import java.util.Scanner;
        (1)正确的写出Scanner类的前几个字母,根据提示,选择Scanner类,会自动导包        建议使用
        (2)正确的写出Scanner类的名字,如果没有提示: 快捷键alt + /
 */

import java.util.Scanner;//导包
public class Demo10ScannerSum {
    public static void main(String[] args) {
        //1.导包(找到我们要所以的键盘录入功能): import java.util.Scanner
        //2.创建键盘录入Scanner类的对象sc: Scanner sc = new Scanner(System.in);
        Scanner sc = new Scanner(System.in);

        //3.获取键盘录入的两个int数字,分别保存到两个int变量a和b中
        System.out.println("请输入第一个整数数字: ");
        int a = sc.nextInt();

        System.out.println("请输入第二个整数数字: ");
        int b = sc.nextInt();

        //4.计算变量a和b的和,保存到int变量sum中
        int sum = a + b;

        //5.打印sum的值
        System.out.println(a + " 和 " + b + " 这两个数字的和: " + sum);
    }
}

第三章数据类型转换【理解】

3.1 自动类型转换【从小到大自动】

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
举例:
	int + int:	类型一直,可以直接计算
	int + long: 类型不一致,不可以直接计算
		解决方案一:
			int + long --> long + long : 转换后类型一直,可以直接计算
			把int类型转换成long类型,从小到大,叫做自动类型转换(自动完成)
        解决方案二:
			int + long --> int + int: 转换后类型一直,可以直接计算
			把long类型转换成int类型,从大到小,叫做强制类型转换(不会自动完成,必须手动处理)   
                
1.自动类型转换概念:	
	取值范围小的数据/变量,可以直接赋值给取值范围大的变量(小萝卜可以直接放入大坑中)
2.特点: 
	(1)是自动完成的,不需要代码的特殊处理
	(2)byte/short/char类型,至少会自动类型转换为int类型
	(3)转换规则: byte、short、char-->int-->long-->float-->double
	总结:
		整个表达式中的所有类型,都会自动转换成表达式中最大的类型,结果也是最大的类型		
举例:00000000
	有一个byte类型(1个字节)的数字5:			00000101	
	byte类型自动类型转换成short类型(2个字节):	
    	在左侧补充一个字节的0,因为补充的是0,对于原有数据大小没有影响
        00000000 00000101            
	byte类型自动类型转换成int类型(4个字节): 
		在左侧补充三个字节的0,因为补充的是0,对于原有数据大小没有影响
		00000000 00000000 00000000 00000101        
	byte类型自动类型转换成long类型(8个字节): 	
		在左侧补充七个字节的0,因为补充的是0,对于原有数据大小没有影响
		00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101        
总结(打肿脸充胖子):
	根据需求在左侧补充若干个字节的0,因为补充的是0,对于原有数据大小没有影响

package com.itheima02_zhuanhuan;

//自动类型转换练习一
public class Demo01Convert {
    public static void main(String[] args) {
        int i = 1;
        byte b = 2;
        /*
            b是byte类型(占1个字节),i是int类型(占4个字节),类型不一致,
            会发生自动类型转换,把byte类型的b,转换成int类型(左侧补充3个字节的0)
            byte类型的b的2: 00000010
            int类型的b的2: 00000000 00000000 00000000 00000010

            byte + int --> int + int --> int
                结果为int类型(占4个字节),不能直接赋值给左侧byte类型(占1个字节)的变量

            一句话: 大萝卜不能直接放入小坑中
            解决方案:
                1.把坑变大(目前采用这种方式): 把左侧的byte类型变量,改成int类型变量
                2.把萝卜变小(后面采用这种方式): 强制类型转换
         */
        //byte x = b + i;

        /*
            b是byte类型(占1个字节),i是int类型(占4个字节),类型不一致,
            会发生自动类型转换,把byte类型的b,转换成int类型(左侧补充3个字节的0)
            byte类型的b的2: 00000010
            int类型的b的2: 00000000 00000000 00000000 00000010

            byte + int --> int + int --> int
                结果为int类型(占4个字节),可以直接赋值给左侧int类型(占4个字节)的变量

         */
        int y = b + i;
        System.out.println(y);
    }
}

package com.itheima02_zhuanhuan;

//自动类型转换练习二
public class Demo02Convert {
	public static void main(String[] args){
		int i = 1; 
		double d = 2.5;
		/*
            d是double类型(占8个字节),i是int类型(占4个字节),类型不一致,
            会发生自动类型转换,把int类型的i,转换成double类型
            int类型i的值1,转换成double类型i的值1.0

            double + int --> double + double --> double
                结果为double类型(占8个字节),不能直接赋值给左侧int类型(占4个字节)的变量

            一句话: 大萝卜不能直接放入小坑中
            解决方案:
                1.把坑变大(目前采用这种方式): 把左侧的int类型变量,改成double类型变量
                2.把萝卜变小(后面采用这种方式): 强制类型转换
         */
		//int x = d + i;
		//System.out.println(x);

		/*
            d是double类型(占8个字节),i是int类型(占4个字节),类型不一致,
            会发生自动类型转换,把int类型的i,转换成double类型
            int类型i的值1,转换成double类型i的值1.0

            double + int --> double + double --> double
                结果为double类型(占8个字节),可以直接赋值给左侧double类型(占8个字节)的变量
         */
		double y = d + i;
		System.out.println(y);
	}
}

3.2 强制类型转换【从大到小强制】

1.强制类型转换概念:
	取值范围大的数据或者变量,不能直接赋值给取值范围小的变量,
	必须进行强制类型转换(大萝卜不能直接放入小坑当中)        
    long类型的888: 888-256-512
		00000000 00000000 00000000 00000000 00000000 00000000 00000011 0111 1000
    强制类型转换为byte类型:
		01001111: 120        
     long num = 888L;
	 byte b = (byte)num;//把num强制类型转换成byte类型,砍掉左侧的7个字节的内容	
2.格式:	
	转后类型 变量名称 = (转后类型)转前数字/变量;	
3.问题:
	可能损失精度    
举例:00000000
	有一个long类型(8个字节)的数字5:	
		00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
	long类型强制类型转换成int类型(4个字节):
		砍掉左侧的四个字节的内容,目前砍掉都是0,对数据大小没有影响,只要砍掉的有1,就会影响数据大小
		00000000 00000000 00000000 00000101        
	long类型强制类型转换成short类型(2个字节):	
		砍掉左侧的六个字节的内容,目前砍掉都是0,对数据大小没有影响,只要砍掉的有1,就会影响数据大小
		00000000 00000101	        
    long类型强制类型转换成byte类型(1个字节):	
		砍掉左侧的七个字节的内容,目前砍掉都是0,对数据大小没有影响,只要砍掉的有1,就会影响数据大小
		00000101	
总结:    
 	根据需求,砍掉左侧的若干字节的内容,如果砍掉都是0,对数据大小没有影响,
	只要砍掉的有1,就会影响数据大小

package com.itheima02_zhuanhuan;
//强制类型转换练习一
public class Demo03Convert {
	public static void main(String[] args){
		//short类型变量，内存中占2个字节 
		short s = 1;
		/*
            s是short类型(占2个字节),1是int类型(占4个字节),类型不一致,
            会发生自动类型转换,把short类型的s,转换成int类型(左侧补充2个字节的0)
            short类型s的1: 00000000 00000001
            int类型的s的1: 00000000 00000000 00000000 00000001

            short + int --> int + int --> int
                结果为int类型(占4个字节),不能直接赋值给左侧short类型(占2个字节)的变量

            一句话: 大萝卜不能直接放入小坑中
            解决方案:
                1.把坑变大(以前采用这种方式): 把左侧的short类型变量,改成int类型变量
                2.把萝卜变小(目前采用这种方式): 强制类型转换
         */
		//s = s + 1;

		//System.out.println(s);

		/*
            s是short类型(占2个字节),1是int类型(占4个字节),类型不一致,
            会发生自动类型转换,把short类型的s,转换成int类型(左侧补充2个字节的0)
            short类型s的1: 00000000 00000001
            int类型的s的1: 00000000 00000000 00000000 00000001

            short + int --> int + int --> int
                结果为int类型(占4个字节),不能直接赋值给左侧short类型(占2个字节)的变量

            但是把int类型的结果数据强制类型转换为short类型(砍掉左侧的2个字节的内容)
            int类型的结果2: 00000000 00000000 00000000 00000010
            强转成short类型的结果2: 00000000 00000010
         */
		s = (short)(s + 1);
		System.out.println(s);
	}
}

package com.itheima02_zhuanhuan;

//强制类型转换练习二
public class Demo04Convert {
	public static void main(String[] args){
		/*
			小数数字1.5是double类型(占8个字节),不能直接赋值给左侧的int变量(占4个字节)

			一句话: 大萝卜不能直接放入小坑中
            解决方案:
                1.把坑变大(以前采用这种方式): 把左侧的short类型变量,改成int类型变量
                2.把萝卜变小(目前采用这种方式): 强制类型转换
		 */
		//int j = 1.5;
		//System.out.println(j);

		/*
			小数数字1.5是double类型(占8个字节),不能直接赋值给左侧的int变量(占4个字节)
			但是我们把数字1.5强制类型转换成int类型(直接砍掉小数部分)
		 */
		int i = (int)1.5;
		System.out.println(i);
	}
}

3.3 ASCII码表

计算机是一个二货,只能存储0和1,所以存储到计算机中的所有内容都会转换成0和1进行存储
所以我们在计算机中存储的字符也不例外,也需要把字符转换成0和1进行存储
问题: 如何把字符转换成对应的0和1进行存储呢?
解决方案:
	编码表：就是将人类的文字和一个十进制数进行对应起来组成一张表格。
存储字符时：需要查找ASC码表,找到字符对应的数字,将数字转换为二进制数存放到计算机中        
使用字符时：将对应的二进制数转换为十进制 找到ASC表中对应的字符 显示出来 
总结:
	存储字符时:
		'a' --> 97 --> 1100001	26个小写字母的ASCII码值是连续的,相差1
        'A' --> 65 --> 1000001	26个大写字母的ASCII码值是连续的,相差1
        '0' --> 48 --> 110000	10个数字字符的ASCII码值是连续的,相差1        
        小写字母的ASCII码值比对应的大写字母多32        
    使用字符时
    	1100001 --> 97 --> 'a'
        1000001 --> 65 --> 'A'
        110000  --> 48 --> '0'

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

package com.itheima02_zhuanhuan;

//char和int之间的运算原理
public class Demo05Char {
    public static void main(String[] args) {
        char ch = 'a';
        System.out.println(ch);//a
        /*
            ch是char类型,1是int类型,不一致,会发生自动类型转换
            byte/short/char类型,至少会自动类型转换为int类型
            把char类型转换成int类型
            问题:
                如何把char类型自动转换成int类型呢?
                查看ASCII码表
                'a' --> 97

                char + int --> int + int --> int
                'a'  + 1  --> 97 + 1 --> 98
         */
        System.out.println(ch + 1);//98
        /*
            ch是char类型,1是int类型,不一致,会发生自动类型转换
            byte/short/char类型,至少会自动类型转换为int类型
            把char类型转换成int类型
                char + int --> int + int --> int
                'a'  + 1  --> 97 + 1 --> 98
            但是最终把int类型的结果强制类型转换为char类型
            问题:
                如何把int类型的结果强制类型转换为char类型?
                查看ASCII码表:
                    98 --> 'b'
        */
        System.out.println((char)(ch + 1));//b        
    }
}

Codefacebook

关注

4
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
two文档

运算符【重点】键盘录入【重点】数据类型转换【难点非重点: 理解】能够获取键盘录入的数据完成各种数学运算能够知道类型转换的格式和顺序能够说出常见的运算符有哪几种能够知道除法和取余的区别能够完成字符和字符串的加法能够知道&&和&的区别能够使用三元运算符完成获取两个数中较大值能够使用键盘录入数据并完成两个数据求和。
复制链接

扫一扫