JAVA入门基础--(上课的笔记2）

1.1 隐式类型转换

• 规则： 是用小范围的数据类型 直接转到 大范围的数据类型

• 范围的排序：

  byte < short = char < int < long < float < double

• 作用-用途：比如两个软件进行交互，对方发给你一个整数， 你并不知道这个数据有多大。我就需要用long类型去接收。 不管他发的有多大的整数， 我long都能接收。

• 细节：-- 不同的数据类型是无法进行运算的，必须把他们统一为同一种类型才可以运算。

  class Demo {
      public static void main(String[] args){
          byte a = 10;
          short s = 20;
          //byte b = a + s;  //编译报错  因为 a+s的结果是 int类型
          byte b = (byte) (a + s) ;
          System.out.println(b);
      }
  }

  2：比 int 大的数据类型 进行运算的时候， 小范围数据类型 会自动转到大范围数据类型去。

  public class Demo9 {
      public static void main(String[] args) {
          long lo = 100L;
          double d = 3.14;
          //int a = lo +d; // 编译报错  long和double运算  long会自动转double
          double dou = lo +d;
          System.out.println(dou);
  ​
          long lon = (long) (lo + d);
          System.out.println(lon);
      }
  }

1.2 强制类型转换

规则： 从大范围的数据类型 只能强制转到 小范围的数据类型

• 情况1： 转过去 数据就发生改变。 意义不大

          int a = 200;
          byte b = (byte)a;  // 强制类型转换
          System.out.println(b); // -56

• 情况2： 转过去之后 数据不发生改变

          int c = 100;
          byte d = (byte)c; // 意义所在
          System.out.println(d); //100

• 情况3： 小数转整数

          double dou = 3.14;
          int i = (int)dou; //意义所在
          System.out.println(i);//3 

1.3 注意事项

• boolean类型 不参与任何的类型转换

  boolean b = true;
  int c = b; //编译报错 
  int a = (int)b; //编译报错
  System.out.println(a);

• 常量优化机制。基本类型中 只有比int小的数据类型 才有常量优化机制

  public class Demo11 {
      public static void main(String[] args) {
          System.out.println(100); // 默认是 int 类型 4个字节。
  ​
          byte b = 100; // 正确的。 100虽然是int的 但是他是一个常量数据。  常量优化机制 
              //底层 其实是这样的 byte b = (byte)100;
  ​
          int a = 100;
          //byte c = a;  //因为a是变量  只有常量才有 常量优化机制。
  ​
  ​
          byte d = 80 + 20;  //正确的  常量优化
              // 常量的运算 在编译成class文件的时候，  就已经把 80+20  变成了100 
              // 也就是说 等这句话 编译到了class文件的时候 就变成了 byte d = 100;  就又符合常量优化机制了。
  ​
          byte e = 80;
          //byte f = e+20; //  编译报错  e是变量
  ​
          // 以上的特点 ---演示的都是 比int小的 基本类型常量。
          // 在基本类型里面 只有 比int小的数据 才遵循常量优化机制。  比int大的没有。
  ​
          System.out.println(3.14); // 默认是double类型
  ​
          //float flo = 3.14;  // 编译报错 double转float 报错。    比int大的没有常量优化机制。
  ​
          // 所以我们为了在 一个 小数常量的时候  告诉jvm  我这个小数常量 不再是默认是 double类型了 所以 我们就在小数后面加一个 F
          System.out.println(3.14F);  // 是float类型
  ​
          float flo = 3.14F;
  ​
          System.out.println(b);
      }
  }
  ​

• long类型数据后面 为什么要加L

  public class Demo12 {
      public static void main(String[] args) {
          //int a = 100;
          //long lo = a;
          //System.out.println(lo);
  ​
          long lo = 100;
          System.out.println(lo);
  ​
          System.out.println(10000); //默认是int类型     int类型的范围 21亿
  ​
          //System.out.println(10000000000); //100亿
          // 所以 我们此时 就想 写一个 比21亿大的数据
          // 你需要告诉jvm  我现在写的这个数 不再是 int类型的  而是long类型     你怎么告诉jvm  你只需要在后面加一个 L 就告诉他了。
  ​
          System.out.println(10000000000L);
      }
  }   
  ​

2.1 算术运算符： + - * / %

public class Demo13 {
    public static void main(String[] args) {
        System.out.println(10+10); // 加法
        System.out.println(+10); // 正号 
​
​
        System.out.println(10-10); // 0
        System.out.println(-10); // -10
​
        System.out.println(10*10); //100
​
        System.out.println(100/5); // 20
​
        //除法的注意事项
​
        System.out.println(10/4); // 2
        
        System.out.println(10 / 3); // 3
        System.out.println(10 / 3.0); // 3.33333333
        System.out.println(10.0 / 3); // 3.33333333
        System.out.println(10.0 / 3.0);// 3.33333333
        // 为什么这样啊？？
        // 用类型转换来解释  不同的数据类型是无法进行运算的，必须把他们统一为同一种类型才可以运算。
​
        // 取余数
        // 10 / 3 = 3   -----   1
​
        System.out.println(10 % 3); // 1
        System.out.println(-10 % 3); // -1
            // -10 / 3 = -3   ---  -1 
        System.out.println(10 % -3); // 1
            //  10 / -3 = -3  ---  1
        System.out.println(-10 % -3); // -1
        // 结论： 取余数 最终结果的符号  取决于 % 左侧的数据的符号。
        // 为什么？？
    }
}

题目练习1：

键盘录入一个数值 （只能是3位数） 进行拆分 并打印出每一位数

int a = 键盘录入; //345 ​ 控制台打印如下： ​ 3 ​ 4 ​ 5

Scanner sc = new Scanner(System.in);
​
int a = sc.nextInt();   // 345
​
// 345 % 10    ---- 5
// 345 /10  ---  34 %10  ---4
// 345 /10 /10    3%10  ---3
​
System.out.println(a/10/10%10);
System.out.println(a/10%10);
System.out.println(a%10);

字符的加法

System.out.println('a' + 0); // ？？
                // char + int
                //   |
                // int  + int   --- 结果int

码表：记录了 数字和字母的一一对应关系， 因为计算机只能存储数字。

'0' -- 48 'A' -- 65 'a' -- 9

System.out.println(true + 0); //编译报错 
             // boolean + int
             //  |
             //  int   + int    因为boolean不参与任何的类型转换 所以boolean是无法转为 int的

字符串连接符

System.out.println("a" + 0 ); //a0  
            //   String + int
            //   任何的其他类型 和 String 进行+ ， 其他类型 全部 转为 String 再+。
            //   0 -> "0"  true ->"true"
            //   String + String
            //   "a" + "0"
            //   字符串的+  是连接符 链接在一起。
            //   "a0"
​
System.out.println(10+20+"a"); //30a
                //  30 + "a"
                //  30a
​
System.out.println("a"+10+20); //a1020
                // "a10" + 20
                // "a1020"
​
int a = 10;
System.out.println(a); //10
System.out.println("a" + a); //a10

题目练习2：

键盘录入 两个数 分别用a和b接收 ​ int a = 键盘录入1; // 4 ​ int b = 键盘录入2; //2 ​ 打印 a和b加的过程和结果

和窗口打印的结果是如下： ​ 4 + 2 = 6

import java.util.Scanner;
public class Demo16 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
​
        int a = sc.nextInt(); //4
        int b = sc.nextInt(); //2
        
        //System.out.println("4 + 2 = "+ (a+b) );
        //System.out.println("a + b = "+ (a+b) );
        System.out.println(a + " + b = "+ (a+b) );
​
        System.out.println(a + " + " + b + " = "+ (a+b) );
                        // 4 + " + " + 2 + " = "+ 6
                        // "4+" + 2 + " = "+ 6
                        // "4+2"+ " = "+ 6
                        // "4+2=" + 6
                        // "4+2=6"
    }
}

表达式概念

把数据通过运算符连接起来的式子就叫做 表达式。

public class Demo18 {
    public static void main(String[] args) {
        //表达式概念：  把数据通过运算符连接起来的式子就叫做 表达式。
            // 表达式 肯定都会有一个结果。
            // 表达式 一般情况下 都是不能单独成一条语句 
        int a = 10;
        int b = 20;
        //a+b; //编译报错
        System.out.println(a+b);
        int c = a+b;
        System.out.println(c);
        
        int d = a+b*b+a;
        System.out.println(d); //420
​
        int e = 10;
        int f =  e+=1 ;
        System.out.println(e); //11
        System.out.println(f); //11
    }
}

自增自减运算符 ++ --

//自增自减运算符 ++ --
// 用在变量自身的。  ++就是自身加1   --就是自身减1
​
int a = 10;
a++;
System.out.println(a); // 11
​
int b = 10;
++b;
System.out.println(b); //11
​
// 结论1 不管++ 放在变量的前面 还是放在变量的后面   这个变量经过++之后  自身就会+1
​
​
int c = 10;
int d = c++;
//int d = (c+=1) -1;
System.out.println(c); // 11
System.out.println(d); // 10
​
// 结论2  当++放在变量后面的时候   c++ 这个整体表达式的结果  取的是 c还没有加1的那个值。
​
int e = 10;
int f = ++e;
//int f = e+=1;
System.out.println(e); // 11
System.out.println(f); // 11
​
// 结论3  当++放在变量前面的时候  ++e 这个整体表达式的结果  取的是 e加1之后的值。

题目练习3：

int a = 10;
int b = 20;
int c = a++  +  ++b;  
System.out.println(a);   
System.out.println(b);  
System.out.println(c);  

题目练习4

int a = 10;
int b = 20;
int c = 30;
int d = 40;
int e = a++ + --b - --c + d-- * ++a + --b;  
System.out.println(e);  

2.2 赋值运算符

基本赋值运算符 =

int a = 10;

复合赋值运算符 += -= *= /= %=

int a = 10;
a+=5;   // a 先和右边的 5进行相加   结果 赋值给 左边的a
System.out.println(a); // 15    

注意事项：复合赋值运算符 有强制类型转换的动作。

public class Demo17 {
    public static void main(String[] args) {
        
        
        byte b = 10;
        b += 10; // 正确 因为有强制类型转换 在里面 
        System.out.println(b); //20 
        
    }
}

2.3 比较运算符 > < >= <= == !=

// 比较运算符的结果 都是boolean类型  true false
System.out.println(5 > 4);  //true
System.out.println(5 < 4);  //false
​
System.out.println(5 >= 4); //true
System.out.println(5 >= 5); //true 
​
System.out.println(5==5); // true
System.out.println(5==4); //false
​
System.out.println(7 != 8); //true
System.out.println(7 != 7); //false

2.4 逻辑运算符

// 逻辑运算符  只用来计算 boolean类型 
​
// &  并且      两瓶酒  一瓶是真的 一瓶是假的 
System.out.println(true & false );
System.out.println(false & true );
System.out.println(false & false );
System.out.println(true & true ); //true
//应用
//int a = sc.nextInt();
//System.out.println(a>0 & a<100); //只有a是0-100范围内的时候才是true 其他都是false
​
System.out.println("-----------------------");
​
// |  或者     两者选一   一瓶是真的 一瓶是假的  
System.out.println(true | true );
System.out.println(true | false ); 
System.out.println(false | false ); //false
//应用
//int a = sc.nextInt();
//System.out.println(a<0 | a>100); //a是负数  和 大于100的数 都是 true  0-100之间的都是false
​
System.out.println("-----------------------");
​
// !  取反    不是真 那就是假
System.out.println( ! true); //false
​
System.out.println("-------------------");
// ^  异或    异  不同   惑 疑惑 
​
System.out.println(true ^ true);  //false 
System.out.println(true ^ false); //true
System.out.println(false ^ false); //false
​
​
//System.out.println("a" ^ "b"); //编译报错 
System.out.println("a" != "b"); //true
System.out.println(3 != 4); //true
System.out.println(true != false);  //true

短路逻辑运算符： && || ​ && 并且 只不过 只要看到第一个是false 后面再有多少个 也不执行了。 ​ || 或者 只不过 只要看到第一个是 true 后面在也不看了。

int a = 10;          
System.out.println(4>5 & a++>0 ); 
System.out.println(a); //11
​
int b = 10;          
System.out.println(4>5 && b++>0 ); 
System.out.println(b); //10
​
int c = 10
System.out.println(6 >5 || c++>0 );  //true
System.out.println(c); //10

2.5 三元运算符

boolean类型数据 ? 值1 : 值2;

public class Demo25 {
    public static void main(String[] args) {
        //boolean类型数据 ? 值1 : 值2;
​
        int a =   true ? 10 : 20;
        System.out.println(a);
        
        //请用户键盘录入 1或者0  如果用户录入1 代表 确认   如果用户 录入2 代表 取消。
        //int a = 键盘录入;
        System.out.println( a == 1 ? "确认" : "取消" );
​
        //int c = 键盘录入;
        //int d = 键盘录入;
        int c = 10;
        int d = 20;
        
        int e = c > d ? c : d;
        System.out.println(e); //20
​
        //int f = c > d ? c+d : c-d;
        //System.out.println(f); //
​
        int m = 10;
        int n = 20;
        int p = 30;
​
        //求三个数的最大值。
        int temp = m>n ? m :n;
        int max = temp >p  ? temp : p;
        System.out.println(max); //30
​
        // 合起来
        int max1 = m > n ? (m>p?m:p) : (n>p?n:p);
        System.out.println(max1);
    }
}