精华内容
下载资源
问答
  • java中有常见基本数据类型引用数据类型,基本数据类型为四类八种如下 整数型(byte,short,int,long) 浮点型(float,double) 字符型(char) 布尔型(boolean) 引用数据类型有很多 如常用 Scanner...

    java中有常见的基本数据类型和引用数据类型,基本数据类型为四类八种如下

    整数型(byte,short,int,long)

    浮点型(float,double)

    字符型(char)

    布尔型(boolean)

    引用数据类型有很多

    如常用的 Scanner Random String等

     

    数据类型的关系如下图

     

    转载于:https://www.cnblogs.com/yanyunpiaomaio/p/10513289.html

    展开全文
  • Java的运算符,包括赋值运算符算术运算符关系运算符逻辑运算符Java算术运算符除了通常的加(+)减(-)乘(*)除(\)还包括取模运算(%)自增(++)自减(--)运算。+,-,*,/ 比较简单,实验一下即可。取模运算(%)意为取余数,...

    Java的运算符,包括

    赋值运算符

    算术运算符

    关系运算符

    逻辑运算符

    Java算术运算符除了通常的

    加(+)

    减(-)

    乘(*)

    除(\)

    还包括

    取模运算(%)

    自增(++)

    自减(--)

    运算。+,-,*,/ 比较简单,实验一下即可。

    取模运算(%)意为取余数,只能适用于整数及char类型

    i++ 和 ++i 在理论上的区别是:

    i++:是先把i拿出来使用,然后再+1;

    ++i :是先把i+1,然后再拿出来使用;

    如 a= b + + 相当于a = b;b=b+1,即将b没有加1之前的值赋给a, 之后b 才加 1 ,此时a=b

    如 a = ++b 相当于b=b+1,a=b 即b先加1,再将加1后的值赋给a, 此时a=b+1

    赋值运算符分为两类

    一类是简单赋值

    “=”

    一类是复合赋值

    +=  >> a+=3 || a = a +3

    -= >> a-=3  ||  a = a -3

    *=  >> a*=3 || a = a * 3

    /= >> a/=3 || a = a / 3

    %= >> a%=3 || a =  a % 3

    关系运算符

    关系运算符也是双目运算符,用于关系表达式。

    关系运算符对两个操作数进行比较,并返回比较结果,比较结果的值为一个布尔值(true或false)

    关系运算符有6种

    “==”

    “!=”

    ">"

    "

    ">="

    "<="

    逻辑运算符

    逻辑运算符“&&”是双目运算符

    逻辑运算符“||”是双目运算符

    逻辑运算符“!”是单目运算符

    位运算符

    8178f57d68198f3cdbc1af8314df2e2c.png

    int a =10,b=5;

    System.out.println("&:" + (a &b));

    System.out.println("^:" + (a ^b));

    输出的结果是0

    1510的二进制是1010

    5的二进制是0101位运算与结果是0000,也就是0

    位运算或结果是1111, 也就是15

    表达式是由变量、常量和运算符的组合

    求圆面积的公式就是一个表达式,

    S =π* r *r;

    其中S、r为变量

    π为常量

    *为运算符

    表达式执行计算并返回计算结果。在表达式中运算符作用的变量或常量称为操作数。

    在求圆面积的表达式中,乘号(*)为运算符,π和r为操作数。

    在一些复杂的运算中,简单的表达式可以组合为复杂的表达式,其操作数本身可能就是一个表达式。例如:

    (num1+num2)*(x+y)

    上面的表达式中,运算符乘号(*)两边的操作数(num1+num2)和(x+y)本身就是一个表达式。

    表达式的计算结果一般为数值,如果表达式是一个关系表达式或逻辑表达式,表达式会返回一个布尔值,即真或假。

    根据运算符的不同,可以把表达式分为

    赋值表达式

    算术表达式

    关系表达式

    逻辑表达式

    赋值表达式用于把等号右边的操作数赋值给等号左边的变量;

    算术表达式用于数值运算;其结果是数值

    关系表达式用于条件判断;其结果是true,flase

    逻辑表达式用于逻辑操作。其结果是true,flase

    逻辑运算符“!”是单目运算符

    表达式的类型转换

    只要坚持"以不流失数据为前提"的大原则,既可以进行不同的类型转换

    使用不同的类型的数据,表达式都能继续存储

    规则:

    占用字节较少的数据类型转换成占用字节较多的数据类型,如字符类型转换成 int类型,int类型会转换成 float类型

    表达式中若某个操作数的类型为 double,则另一个操作数也会转换成double类型

    布尔类型不能转换成其他类型

    三目运算符

    d1357db70ede224699caa05d2a99cbe2.png

    展开全文
  • 分析基本数据类型特点,最大值最小值。 1、 基本类型:byte 二进制位数:8 包装类:java.lang.Byte 最小值:Byte.MIN_VALUE=-128(-27次方) 最大值:Byte.MAX_VALUE=127(27次方-1) 2、 基本类型:short...

    基本类型
    1、整数:包含int,short,byte,long
    2、浮点型:float,double
    3、字符:char
    4、布尔:boolean

    分析基本数据类型的特点,最大值和最小值。

    1、
    基本类型:byte 二进制位数:8
    包装类:java.lang.Byte
    最小值:Byte.MIN_VALUE=-128(-2的7次方)
    最大值:Byte.MAX_VALUE=127(2的7次方-1)
    2、

    基本类型:short 二进制位数:16
    包装类:java.lang.Short
    最小值:Short.MIN_VALUE=-32768 (-2的15次方)
    最大值:Short.MAX_VALUE=32767 (2的15次方-1)
    3、
    基本类型:int 二进制位数:32
    包装类:java.lang.Integer
    最小值:Integer.MIN_VALUE= -2147483648 (-2的31次方)
    最大值:Integer.MAX_VALUE= 2147483647 (2的31次方-1)
    4、
    基本类型:long 二进制位数:64
    包装类:java.lang.Long
    最小值:Long.MIN_VALUE=-9223372036854775808 (-2的63次方)
    最大值:Long.MAX_VALUE=9223372036854775807 (2的63次方-1)
    5、
    基本类型:float 二进制位数:32
    包装类:java.lang.Float
    最小值:Float.MIN_VALUE=1.4E-45 (2的-149次方)
    最大值:Float.MAX_VALUE=3.4028235E38 (2的128次方-1)
    6、
    基本类型:double 二进制位数:64
    包装类:java.lang.Double
    最小值:Double.MIN_VALUE=4.9E-324 (2的-1074次方)
    最大值:Double.MAX_VALUE=1.7976931348623157E308 (2的1024次方-1)

    展开全文
  • JAVA的总结笔记(二)

    2021-03-16 18:04:27
    1 类型转换 在Java中,一些数据类型之间是可以相互转换。分为两种情况:自动类型转换强制类型转换。 1.1 隐式转换(理解) ​ 把一个表示数据范围小数值或者...整数默认是int类型,byte、short和char类型数据参与

    1 类型转换

    在Java中,一些数据类型之间是可以相互转换的。分为两种情况:自动类型转换和强制类型转换。

    1.1 隐式转换(理解)

    ​ 把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的,直接书写即可。例如:

    double num = 10; // 将int类型的10直接赋值给double类型
    System.out.println(num); // 输出10.0
    

    ​ 类型从小到大关系图:

    在这里插入图片描述

    说明:

    1. 整数默认是int类型,byteshortchar类型数据参与运算均会自动转换为int类型。
    2. 在java中对整数常量存在优化机制;
    3. 对long类型的数据建议无论是否超int范围,都建议加L
    4. boolean类型不能与其他基本数据类型相互转换。
    byte b1 = 10;
    byte b2 = 20;
    byte b3 = b1 + b2; 
    /* 第三行代码会报错,b1和b2会自动转换为int类型,计算结果为int,
    int赋值给byte需要强制类型转换。*/
    // 修改为:
    int num = b1 + b2;
    // 或者:
    byte b3 = (byte) (b1 + b2);
    

    1.2 强制转换(理解)

    ​ 把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

    ​ 强制类型转换格式:目标数据类型 变量名 = (目标数据类型)值或者变量;
    (小的类型)变量名 = (小的类型) 大的数据值;

    ​ 例如:

    double num1 = 5.5;
    int num2 = (int) num1; // 将double类型的num1强制转换为int类型
    System.out.println(num2); // 输出5(小数位直接舍弃)
    

    1.3 类型转换案例(理解)

    案例代码:

    byte a = 3;
    byte b = 4;
    byte c = a + b; //错误。因为两个byte变量相加,会先提升为int类型
    byte d = 3 + 4; //正确。常量优化机制
    

    常量优化机制:

    ​ 在编译时,整数常量的计算会直接算出结果,并且会自动判断该结果是否在byte取值范围内,

    ​ 在:编译通过

    	不在:编译失败
    

    2. 运算符

    2.1 算术运算符

    2.1.1 运算符和表达式(了解)

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

    表达式:用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。

    ​ 不同运算符连接的表达式体现的是不同类型的表达式。

    举例说明:

    int a = 10;
    int b = 20;
    int c = a + b;
    

    +:是运算符,并且是算术运算符。

    a + b:是表达式,由于+是算术运算符,所以这个表达式叫算术表达式。

    2.1.2 算术运算符(应用)

    符号 作用 说明
    + 参看小学一年级
    - 参看小学一年级
    * 参看小学二年级,与“×”相同
    / 参看小学二年级,与“÷”相同
    % 取余 获取的是两个数据做除法的余数

    注意:

    1. /和%的区别:两个数据做除法,/取结果的商,%取结果的余数。

    2. 整数操作只能得到整数,要想得到小数,必须有浮点数参与运算。

    int a = 10;
    int b = 3;
    System.out.println(a / b); // 输出结果3
    System.out.println(a % b); // 输出结果1
    

    2.1.3 字符的“+”操作(理解)

    char类型参与算术运算,使用的是计算机底层对应的十进制数值。需要我们记住三个字符对应的数值:

    ‘a’ – 97 a-z是连续的,所以’b’对应的数值是98,'c’是99,依次递加

    ‘A’ – 65 A-Z是连续的,所以’B’对应的数值是66,'C’是67,依次递加

    ‘0’ – 48 0-9是连续的,所以’1’对应的数值是49,'2’是50,依次递加

    // 可以通过使用字符与整数做算术运算,得出字符对应的数值是多少
    char ch1 = 'a';
    System.out.println(ch1 + 1); // 输出98,97 + 1 = 98
    
    char ch2 = 'A';
    System.out.println(ch2 + 1); // 输出66,65 + 1 = 66
    
    char ch3 = '0';
    System.out.println(ch3 + 1); // 输出49,48 + 1 = 49
    

    算术表达式中包含不同的基本数据类型的值的时候,整个算术表达式的类型会自动进行提升。

    提升规则:

    byte类型,short类型和char类型将被提升到int类型,不管是否有其他类型参与运算。

    整个表达式的类型自动提升到与表达式中最高等级的操作数相同的类型

    ​ 等级顺序:byte,short,char --> int --> long --> float --> double

    例如:

    byte b1 = 10;
    byte b2 = 20;
    // byte b3 = b1 + b2; // 该行报错,因为byte类型参与算术运算会自动提示为int,int赋值给byte可能损失精度
    int i3 = b1 + b2; // 应该使用int接收
    byte b3 = (byte) (b1 + b2); // 或者将结果强制转换为byte类型
    -------------------------------
    int num1 = 10;
    double num2 = 20.0;
    double num3 = num1 + num2; // 使用double接收,因为num1会自动提升为double类型
    

    2.1.4 字符串的“+”操作(理解)

    当“+”操作中出现字符串时,这个”+”是字符串连接符,而不是算术运算。

    System.out.println("itheima"+ 666); // 输出:itheima666
    

    在”+”操作中,如果出现了字符串,就是连接运算符,否则就是算术运算。当连续进行“+”操作时,从左到右逐个执行。

    System.out.println(1 + 99 + "年黑马");            // 输出:100年黑马
    System.out.println(1 + 2 + "itheima" + 3 + 4);   // 输出:3itheima34
    // 可以使用小括号改变运算的优先级 
    System.out.println(1 + 2 + "itheima" + (3 + 4)); // 输出:3itheima7
    

    2.1.5 数值拆分(应用)

    需求:

    ​ 键盘录入一个三位数,将其拆分为个位,十位,百位,打印在控制台

    示例代码:

    import java.util.Scanner;
    public class Test {
    	public static void main(String[] args) {
    		// 1:使用Scanner键盘录入一个三位数
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入一个三位数");
    		int num = sc.nextInt();
    		// 2:个位的计算:数值 % 10
    		int ge = num % 10;		
    		// 3:十位的计算:数值 / 10 % 10
    		int shi = num / 10 % 10;	
    		// 4:百位的计算:数值 / 100
    		int bai = num / 100;
    		// 5:将个位, 十位, 百位拼接上正确的字符串, 打印即可
    		System.out.println("整数"+num+"个位为:" + ge);
    		System.out.println("整数"+num+"十位为:" + shi);
    		System.out.println("整数"+num+"百位为:" + bai);
    		
    	}
    }
    

    2.2 自增自减运算符(理解)

    符号 作用 说明
    ++ 自增 变量的值加1
    自减 变量的值减1

    注意事项:

    ​ ++和-- 既可以放在变量的后边,也可以放在变量的前边。

    ​ 单独使用的时候, ++和-- 无论是放在变量的前边还是后边,结果是一样的。

    ​ 参与操作的时候,如果放在变量的后边,先拿变量参与操作,后拿变量做++或者–。

    ​ 参与操作的时候,如果放在变量的前边,先拿变量做++或者–,后拿变量参与操作。

    ​ 最常见的用法:单独使用。

    int i = 10;
    i++; // 单独使用
    System.out.println("i:" + i); // i:11
    
    int j = 10;
    ++j; // 单独使用
    System.out.println("j:" + j); // j:11
    
    int x = 10;
    int y = x++; // 赋值运算,++在后边,所以是使用x原来的值赋值给y,x本身自增1
    System.out.println("x:" + x + ", y:" + y); // x:11,y:10
    
    int m = 10;
    int n = ++m; // 赋值运算,++在前边,所以是使用m自增后的值赋值给n,m本身自增1
    System.out.println("m:" + m + ", m:" + m); // m:11,m:11
    

    练习:

    int x = 10;
    int y = x++ + x++ + x++;
    System.out.println(y); // y的值是多少?
    /*
    解析,三个表达式都是++在后,所以每次使用的都是自增前的值,但程序自左至右执行,所以第一次自增时,使用的是10进行计算,但第二次自增时,x的值已经自增到11了,所以第二次使用的是11,然后再次自增。。。
    所以整个式子应该是:int y = 10 + 11 + 12;
    输出结果为33。
    */
    注意:通过此练习深刻理解自增和自减的规律,但实际开发中强烈建议不要写这样的代码!小心挨打!
    

    2.3 赋值运算符(应用)

    赋值运算符的作用是将一个表达式的值赋给左边,左边必须是可修改的,不能是常量。

    符号 作用 说明
    = 赋值 a=10,将10赋值给变量a
    += 加后赋值 a+=b,将a+b的值给a
    -= 减后赋值 a-=b,将a-b的值给a
    *= 乘后赋值 a*=b,将a×b的值给a
    /= 除后赋值 a/=b,将a÷b的商给a
    %= 取余后赋值 a%=b,将a÷b的余数给a

    注意:

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

    short s = 10;
    s = s + 10; // 此行代码报出,因为运算中s提升为int类型,运算结果int赋值给short可能损失精度
    
    s += 10; // 此行代码没有问题,隐含了强制类型转换,相当于 s = (short) (s + 10);
    

    2.4 关系运算符(应用)

    关系运算符有6种关系,分别为小于、小于等于、大于、等于、大于等于、不等于。

    符号 说明
    == 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

    注意事项:

    ​ 关系运算符的结果都是boolean类型,要么是true,要么是false。

    ​ 千万不要把“”误写成“=”,"“是判断是否相等的关系,”="是赋值。

    int a = 10;
    int b = 20;
    System.out.println(a == b); // false
    System.out.println(a != b); // true
    System.out.println(a > b); // false
    System.out.println(a >= b); // false
    System.out.println(a < b); // true
    System.out.println(a <= b); // true
    
    // 关系运算的结果肯定是boolean类型,所以也可以将运算结果赋值给boolean类型的变量
    boolean flag = a > b;
    System.out.println(flag); // 输出false
    

    2.5 逻辑运算符(应用)

    逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式,以判断程序中的表达式是否成立,判断的结果是 true 或 false。

    符号 作用 说明
    & 逻辑与 a&b,a和b都是true,结果为true,否则为false
    | 逻辑或 a|b,a和b都是false,结果为false,否则为true
    ^ 逻辑异或 a^b,a和b结果不同为true,相同为false
    ! 逻辑非 !a,结果和a的结果正好相反
    //定义变量
    int i = 10;
    int j = 20;
    int k = 30;
    
    //& “与”,并且的关系,只要表达式中有一个值为false,结果即为false
    System.out.println((i > j) & (i > k)); //false & false,输出false
    System.out.println((i < j) & (i > k)); //true & false,输出false
    System.out.println((i > j) & (i < k)); //false & true,输出false
    System.out.println((i < j) & (i < k)); //true & true,输出true
    System.out.println("--------");
    
    //| “或”,或者的关系,只要表达式中有一个值为true,结果即为true
    System.out.println((i > j) | (i > k)); //false | false,输出false
    System.out.println((i < j) | (i > k)); //true | false,输出true
    System.out.println((i > j) | (i < k)); //false | true,输出true
    System.out.println((i < j) | (i < k)); //true | true,输出true
    System.out.println("--------");
    
    //^ “异或”,相同为false,不同为true
    System.out.println((i > j) ^ (i > k)); //false ^ false,输出false
    System.out.println((i < j) ^ (i > k)); //true ^ false,输出true
    System.out.println((i > j) ^ (i < k)); //false ^ true,输出true
    System.out.println((i < j) ^ (i < k)); //true ^ true,输出false
    System.out.println("--------");
    
    //! “非”,取反
    System.out.println((i > j)); //false
    System.out.println(!(i > j)); //!false,,输出true
    

    2.6 短路逻辑运算符(理解)

    符号 作用 说明
    && 短路与 作用和&相同,但是有短路效果 (只要左边是false,右边就会短路)
    || 短路或 作用和|相同,但是有短路效果 (只要左边是true,右边就会短路)

    在逻辑与运算中,只要有一个表达式的值为false,那么结果就可以判定为false了,没有必要将所有表达式的值都计算出来,短路与操作就有这样的效果,可以提高效率。同理在逻辑或运算中,一旦发现值为true,右边的表达式将不再参与运算。

    • 逻辑与&,无论左边真假,右边都要执行。

    • 短路与&&,如果左边为真,右边执行;如果左边为假,右边不执行。

    • 逻辑或|,无论左边真假,右边都要执行。

    • 短路或||,如果左边为假,右边执行;如果左边为真,右边不执行。

    int x = 3;
    int y = 4;
    System.out.println((x++ > 4) & (y++ > 5)); // 两个表达都会运算
    System.out.println(x); // 4
    System.out.println(y); // 5
    
    System.out.println((x++ > 4) && (y++ > 5)); // 左边已经可以确定结果为false,右边不参与运算
    System.out.println(x); // 4
    System.out.println(y); // 4
    

    2.7 三元运算符(理解)

    三元运算符语法格式:

    关系表达式 ? 表达式1 : 表达式2;
    

    解释:问号前面的位置是判断的条件,判断结果为boolean型,为true时调用表达式1,为false时调用表达式2。其逻辑为:如果条件表达式成立或者满足则执行表达式1,否则执行第二个。

    举例:

    int a = 10;
    int b = 20;
    int c = a > b ? a : b; // 判断 a>b 是否为真,如果为真取a的值,如果为假,取b的值
    

    2.8 三元运算符案例(应用)

    需求:

    ​ 一座寺庙里住着三个和尚,已知他们的身高分别为150cm、210cm、165cm,请用程序实现获取这三个和尚的最高身高。

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

    3. 流程控制语句

    在一个程序执行的过程中,各条语句的执行顺序对程序的结果是有直接影响的。所以,我们必须清楚每条语句的执行流程。而且,很多时候要通过控制语句的执行顺序来实现我们想要的功能。

    3.1 流程控制语句分类(了解)

    ​ 顺序结构

    ​ 分支结构(if, switch)

    ​ 循环结构(for, while, do…while)

    3.2 顺序结构(了解)

    顺序结构是程序中最简单最基本的流程控制,没有特定的语法结构,按照代码的先后顺序,依次执行,程序中大多数的代码都是这样执行的。

    顺序结构执行流程图:

    在这里插入图片描述

    3.3 分支结构之if语句

    3.3.1 if语句格式1(理解)

    格式:
    if (关系表达式) {
        语句体;	
    }
    

    执行流程:

    ①首先计算关系表达式的值

    ②如果关系表达式的值为true就执行语句体

    ③如果关系表达式的值为false就不执行语句体

    ④继续执行后面的语句内容

    在这里插入图片描述

    示例:

    public class IfDemo {
    	public static void main(String[] args) {
    		System.out.println("开始");
            
    		// 如果年龄大于18岁, 就可以上网吧
    		int age = 17;
    		
    		if(age >= 18){
    			// int a = 10;
    			System.out.println("可以上网吧");
    		}
    			
    		System.out.println("结束");
    	}
    }
    

    3.3.2 if语句格式2(理解)

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

    执行流程:

    ①首先计算关系表达式的值

    ②如果关系表达式的值为true就执行语句体1

    ③如果关系表达式的值为false就执行语句体2

    ④继续执行后面的语句内容

    在这里插入图片描述

    示例:奇偶数

    ​ 任意给出一个整数,请用程序实现判断该整数是奇数还是偶数,并在控制台输出该整数是奇数还是偶数。

    public class Demo2If {
    	public static void main(String[] args) {
    		// 程序判断一个数, 是奇数还是偶数
    		int num = 9;
    		
    		if(num % 2 == 0){
    			System.out.println("偶数");
    		}else{
    			System.out.println("奇数");
    		}
    	}
    }
    

    3.3.3 if语句格式3(理解)

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

    执行流程:

    ①首先计算关系表达式1的值

    ②如果值为true就执行语句体1;如果值为false就计算关系表达式2的值

    ③如果值为true就执行语句体2;如果值为false就计算关系表达式3的值

    ④…

    ⑤如果没有任何关系表达式为true,就执行语句体n+1。

    在这里插入图片描述

    示例:

    ​ 定义一个在0~100之间的变量a, 90100优秀,8089良好,7079中等,6069及格,0~59请努力加油!

    public class Demo3If {
    	public static void main(String[] args){
    		int score = 65;
    		if(score >= 90 && score <= 100){
    			System.out.println("优秀");
    		}else if (score >= 80 && score <= 89){
    			System.out.println("良好");
    		}else if (score >= 70 && score <= 79){
    			System.out.println("中等");
    		}else if (score >= 60 && score <= 69){
    			System.out.println("及格");
    		}else if (score >= 0 && score <= 59){
    			System.out.println("请努力加油");
    		}else{
    			System.out.println("成绩有误!");
    		}
    	}
    }
    

    3.3.4 if语句格式3案例(应用)

    需求:小明快要期末考试了,小明爸爸对他说,会根据他不同的考试成绩,送他不同的礼物,假如你可以控制小明的得分,请用程序实现小明到底该获得什么样的礼物,并在控制台输出。

    分析:

    ​ ①小明的考试成绩未知,可以使用键盘录入的方式获取值

    ​ ②由于奖励种类较多,属于多种判断,采用if…else…if格式实现

    ​ ③为每种判断设置对应的条件

    ​ ④为每种判断设置对应的奖励

    import java.util.Scanner;
    public class IfTest02 {
    	public static void main(String[] args){
    		// 1. 使用Scanner录入考试成绩
    		Scanner sc = new Scanner(System.in);
    		System.out.println("请输入您的成绩:");
    		int score = sc.nextInt();
    		// 2. 判断成绩是否在合法范围内 0~100
    		if(score >=0 && score <= 100){
    			// 合法成绩
    			// 3. 在合法的语句块中判断成绩范围符合哪一个奖励
    			if(score >= 95 && score <= 100){
    				System.out.println("自行车一辆");
    			}else if(score >= 90 && score <= 94){
    				System.out.println("游乐场一次");
    			}else if(score >= 80 && score <= 89){
    				System.out.println("变形金刚一个");
    			}else {
    				System.out.println("挨顿揍, 这座城市又多了一个伤心的人~");
    			}
    		}else{
    			// 非法的话, 给出错误提示
    			System.out.println("您的成绩输入有误!");
    		}
    	}
    }
    
    展开全文
  • (1)数值类型之间转换:整数和小数之间数值类型转换 (2)不同数值类型大小关系:byte < short < int < long < float < double (3)两种类型转换 **①自动类型转换:小转大** 例1: int ...
  •  基本数据类型包括byte、int、char、long、float、double、booleanshort。  java.lang.String类是final类型,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,我们应该用StringBuffer类 6、int...
  • java 幻影_Java之运算符

    2021-02-28 14:41:05
    算术运算符算术运算符用在数学表达式中,它们的作用在数学中的作用一样...关系运算符下表为Java支持的关系运算符位运算符Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),...
  • Java数据类型简单数据类型布尔类型字符类型整数类型浮点数类型 在Java里,数据类型也是有分类。数据类型分为简单数据类型复合数据类型。 简单数据类型分为:布尔类型、字符类型、整数类型、浮点类型。 复合数据...
  • Java 运算符Java 运算符算术运算符自增自减运算符关系运算符位运算符Java定义了位运算符,应用于整数类型(int),长整型(long),短整型(short),字符型(char),字节型(byte)等类型。 位运算符作用在所有位上,...
  • Java基础总结(学Java这一篇就够了)

    热门讨论 2021-02-02 16:36:09
    2、java程序的编译运行、JDK、JRE、JVM的关系、环境变量、HelloWorld程序 3、公开类、标识符、关键字 二、数据类型 4、字面值、变量、数据类型基础、编码方式 5、char、转义、整数型、精度损失 6、浮点型、布尔型...
  • java运算符

    2019-11-18 13:41:36
    JAVA算术运算符除通常用加(+)、减(-)、乘()、除(/)之外,还包括取模运算(%)自增(++)及自减(–)运算。 取模运算(%)意为取余数,可适用于整数char类型及浮点数。 ## 3.关系运算符* < >= &...
  • 数据类型与运算符变量与类型1、java中常用基本数据类型总结较为重要知识点:数据类型大小操作系统是多少位没有关系基本数据类型对应包装类型:两个特殊 char—Charcater,int—Integer,别首字母...
  • Java学习——day 01

    2018-12-14 09:50:31
    主要内容 jdk、jre、jvm区别 Java环境配置 ...char类型注意点(可以直接当做整数来使用,注意两者之间转换关系) 自动转型、强制转型、类型提升 笔记详解 1. jdk、jre、jvm区别联...
  • 1.2 Java运算符

    2020-10-26 22:29:36
    Java基础语法 1 类型转换 在Java中,一些数据类型之间是可以相互转换。分为两种情况:自动类型转换强制类型转换。 1.1 隐式转换(理解) ​ 把一个表示数据范围小数值或者...整数默认是int类型,byte、short和char
  • Java300集目录。

    2020-02-28 18:10:45
    1_300集java课程介绍 2_计算机语言发展史_java历史_java核心优势_java三大版本的区别 ...6_标识符unicodeGBK各种字符集的关系 7_整数类型进制转换编程中的L问题 8_浮点数_浮点数误差问题 9_char_...
  • Java基础语法

    2021-03-14 21:26:56
    1 类型转换 在Java中,一些数据类型之间是可以相互转换。分为两种情况:自动类型转换强制类型转换。 1.1 隐式转换(理解) 把一个表示数据范围小数值或者变量赋值给另... 整数默认是int类型,byte、short和char.
  • Java面向对象总结

    2017-10-22 15:40:51
    类之间的关系 关联关系、继承关系、聚合关系、实现关系、多态关系 JAVA类的定义 成员变量+构造函数+封装方法 成员变量会被默认初始化,局部变量不会默认初始化 变量有四类八种引用类型(byte,short,int,...
  • 数据类型大小操作系统是多少位没有关系 基本数据类型对应包装类型:两个特殊 char—Charcater,int—Integer,别首字母大写 在字符变量中:计算机中字符本质上是一个整数. 在 C 语言中使用 ASCII 表示...
  • java面试题

    2018-04-27 19:55:38
    答:swtich()传递应该是一个整数表达式,所以它值只能是:int、short、char、byte所以longString都不能作用在swtich()上。 jspservlet之间联系? 答:jsp前段动态页面,servlet是纯java类 jsp被编译之后...
  • java 中数据类型分类

    2019-10-01 02:33:12
    java中数据类型分为基本数据类型引用数据类型两大类,基本数据类型包括数值型,字符型(char),布尔型(boolean)三种类型,其中数值型又包括整数类型(byte,short,int,long)浮点类型(float,double);...
  • Java基础语法-day02

    2020-11-04 22:39:25
    Java基础语法 1 类型转换 在Java中,一些数据类型之间是可以相互转换。分为两种情况:自动类型转换强制类型转换。 1.1 隐式转换 ​ 把一个表示数据范围小数值或变量...整数默认是int类型,byte、short和char类型
  • 1 类型转换 在Java中,一些数据类型之间是可以相互转换。分为两种情况:自动类型转换强制类型转换。 1.1 隐式转换(理解) ​ 把一个表示数据范围小数值或者...整数默认是int类型,byte、short和char类型数据参与运
  • java面试笔记整理

    2020-10-26 14:33:08
    实例关系和继承关系是对象之间静态关系;消息传递是对象之间动态联系唯一形式,也是计算唯一形式;方法是消息序列。 基本数据类型与引用数据类型 1、基本数据类型 基本数据类型只有8种,可按照如下分类 ①...
  • java基本数据类型

    2019-10-20 09:11:41
    先来一张图阐述一下数据类型的关系 基本数据类型分为八种三类,三类是数值型,字符型,布尔型。 数值型又分为整数浮点型,整数型包括byte,short,int,long。浮点型分为float,double。 字符型是char。 ...
  • java基础——基本语法

    2019-07-14 22:50:59
    字符:char 字符本质:整数 65536个字符 字符比较大小->关系运算符 整数:int (byte,short,long) ±21亿 小数:double (float) 默认类型 1.0 布尔:boolean true/false b) 创建使用变量 ...
  • java 面试题 总结

    2009-09-16 08:45:34
    基本数据类型包括byte、int、char、long、float、double、booleanshort。 java.lang.String类是final类型,因此不可以继承这个类、不能修改这个类。为了提高效率节省空间,我们应该用StringBuffer类 3、int ...
  • 2、Java字符char可以存储一个中文汉字 3、整数相除结果只能得到整数。 4 、整数想得到小数,把其中一个数变成小数,另一个数在运算时候会自动类型提升 5、%运算符结果符号只左边有关系,与右边无关 6...
  • Java基础_数据类型

    2018-05-26 13:23:20
    基本数据类型 4类8种 整数byte,short,int,long ... 实参与形参的关系是实参把值赋给形参 引用数据类型的传值规则 参数问题 1.类:当方法的参数是类名的时候,实现传递是该类的对象 2.抽象...
  • Java基础阶段性总结一、JDK、JREJVM三者的关系二、数据类型(8种基本数据类型引用数据类型)1.基本类型字面值规则(5条)1)整数字面值为int类型;2)byte、short、char三种比int小的整数可以用范围内的值直接赋值...

空空如也

空空如也

1 2 3 4
收藏数 76
精华内容 30
关键字:

java的char和整数的关系

java 订阅