Java短期班day02

努力的啊精

已于 2023-01-20 16:12:10 修改

阅读量48

点赞数

分类专栏： java基础文章标签： java

于 2023-01-20 15:51:55 首次发布

本文链接：https://blog.csdn.net/qq_54495306/article/details/128741918

版权

java基础专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一、Input

演示接受键盘输入的数据
1. 先写导报语句 import java.util.Scanner;
2. 定义对象 Scanner sc = new Scanner(System.in);
3. 通过对象名，调用对象的方法，从键盘输入读取数据
      int x = sc.nextInt();
      sc.nextDouble()
      sc.nextLine()

      nextInt(), nextDouble()读取数值，数值与数值之间的分隔符默认是空格
      但是nextLine方法，以回车作为不同字符串的分隔符

import java.util.Scanner;//导包语句

public class input {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建Scanner对象

        int a = sc.nextInt();//以空格作为间隔符

        String s1  = sc.nextLine();
        String s2  = sc.nextLine();//以回车作为间隔符

        System.out.println("a=" + a);
        System.out.println("s1=" + s1);
        System.out.println("s2=" + s2);

    }
}

二、算数运算符

  算数运算符:
  1. + 运算符
     a. 正号
     b. 普通的加法运算
     c. 字符串的拼接

    凡是有字符串参与的+运算，都是字符串拼接的运算，
    当参与运算的操作数都是数值型数据时，才会执行数值加法

 2. / 除法运算
    a. 当参与运算的操作数都是整数时，运算结果会丢弃小数部分，只保留整数部分
    b. 如果说我们希望/运算的结果是一个小数，可以通过强制类型转化 也可以 隐式类型转化             double doubleResult = 1.0 * aValue / bValue;//隐式

3. %  取模(求除法运算余数)


4. ++和--
      (++或--)单独使用效果自增(自减), 若参与运算，位置不同，效果不同

      ++(--)：单目运算符，只针对一个操作数，让操作数的结果自增1(自减1)
      a. ++(--)放在操作数之前使用： ++a(--a)
      b. ++(--)放在操作数之后使用:  a++(a--)

      c. 但是，当自增(自减)运算，并非单独存在，而是参与其他的运算，此时++(--)在前或者在后，会影响
         其他运算的结果
         1）当++(--)在前的时候，操作数是先自增(自减), 自增(自减)之后的结果，在参与其他运算
         2）当++在后的时候，操作数先参与其他运算，在自增1(自减1)

         ++(--)影响的是自增(自减)时机

5.复合运算符有隐式类型转化

三、逻辑运算符

逻辑运算符 针对 true false boolean类型的值做运算

  &:  true & false = false  true & true = true  false & true = false   false & false = false
   只要至少有一个操作数是false，结果就是false，只有当两个操作数都是true的时候，&运算的结果，才是true

 |:  true | false = true  true | true = true  false | true = true   false | false = false
    只要至少有一个操作数是true，结果就是true，只有当两个操作数都是false，|运算的结果才是false

 !:  !true = false  !false = true

^:  相同为false， 不同为true
    true ^ true = false  false ^ false = false
    true ^ false = true  false ^ true = true

 与运算符： &  && 它们的运算规则和运算结果都是一样的
 或运算符   |  || 它们的运算规则和运算结果都是一样的
 它们有没有区别呢？有区别  && || 它们的运算比较智能有 短路效果

 && 与运算比较智能, 当它发现&&运算符的第一个操作数结果已经是false，
  第二个操组数(对应的表达式)不去管他，直接得到结果&&的结果false

&  这种与运算，比较的死板，即使&第一个操作数，它已经是false，此时它仍然会计算第二个操作数(表达式)，
  在把计算好的两个操作数的结果，做与运算，得到最终结果

&&: 有短路效果，当第一个操作数为false，直接得出与运算的结果

| || 类似，|| 也会有短路效果，当||发现第一个操作数是true，就不执行第二个表达式，直接得到结果 true
如果我们发现，第一个操作数结果true，第二个操作数，结果都应该是true

注意事项:
   a. 注意 && || 它们具有短路效果
   b.  0 < a < 10

四、Exercise

/*
    1.
     byte b1 = 1, b2 = 2, b;
     b = b1+ b2;
     b= 1 + 2;
     哪句是编译失败的呢？为什么呢？
     首先，大家之所以会认为，第一行和第三行代码会报错，原因是一个整数常量值，默认属于int数据类型
     byte b = 整数常量值   相当于  大数据类型的值 ——> 小数据类型的值(丢失精度)
     但是，实际上它们却并没有报错原因是:
         编译器在编译的时候，自动做了检查，编译器是可以认识常量值，判断常量值是否在byte数据类型
         的表示范围之内

    2.
      byte b = 129;
     这句代码有没有问题？
     如果有问题，是否有办法完成上述赋值功能？


 */
public class Exercise {

    public static void main(String[] args) {
        // 第一题
        byte b1 = 1, b2 = 2, b;
        b= 1 + 2;
        //  byte,short,char相互之间不转换，他们参与运算首先转换为int类型
        //  有同学会觉得疑惑，为啥这里编译器就不能在自动判断值的范围了呢？编译器是无法知道变量的值
        //b = b1+ b2;
        //b = b1 + 10;


        //第二题
        // 报错的原因是因为，编译器经过判断发现129值，超出了byte所表示的范围(-128 - 127)
        //byte byteValue = 129;

        // 可以通过强制类型转化，完成赋值
        byte byteValue = (byte) 129;
        //  int: 00000000 00000000 00000000 10000001
        //  byte:  10000001
        //         11111111  -127
        System.out.println(byteValue); // -127


        // 还有一种特殊情况
        //  一个整数常量值 默认数据类型 int
        long longValue = 9999999999L;
    }
}