02.变量_数据类型转换_运算符

第一章.常量

1.概述:在代码运行的过程中,值不会发生改变的数据,我们跟这种常量叫做"字面值"
2.分类:
  a.整数常量:所有整数
  b.小数常量:所有带小数点的  -> 2.5   2.0
  c.字符常量:带单引号的 -> 单引号中必须有且只能有一个内容  -> 'a'   '啊'  '11'(不是)  ' '
  d.字符串常量:带双引号的 -> 双引号中有没有内容都可以   ""
  e.布尔常量:true false
  f.空常量:null  代表数据不存在,不能直接使用,null是为引用类型初始化的

public class Demo01ChangLiang {
    public static void main(String[] args) {
        //整数常量
        System.out.println(10);
        //小数常量
        System.out.println(10.5);
        //字符常量
        System.out.println('a');
        //字符串常量
        System.out.println("hello world");
        //布尔常量
        System.out.println(true);
        System.out.println(false);
        //空常量
        //System.out.println(null);
    }
}

public class Demo02ChangLiang {
    public static void main(String[] args) {
        System.out.println(10+3);//13
        System.out.println(10-3);//7
        System.out.println(10*3);//30

        /*
           /前后如果都是整数,结果只取整数部分
           /前后只要有一个是小数,结果就是正常小数
         */
        System.out.println(10/3);//3
        System.out.println(10/3.0);//3.3333333333333335
    }
}

第二章.变量

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128 至 127 定义byte变量时超出范围,废了
短整型	short	2个字节	-32768 至 32767
整型	int（默认）	4个字节	-231 至 231-1 正负21个亿 -2147483648——2147483647
长整型	long	8个字节	-263 至 263-1 19位数字
单精度浮点数	float	4个字节	1.4013E-45 至 3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324 至 1.7977E+308
字符型	char	2个字节	0 至 216-1
布尔类型	boolean	1个字节	true，false(可以做判断条件使用)

实际开发中,常用:

整数: int long

小数: float double

布尔: true false

1.变量的介绍以及使用

1.在代码的运行过程中,值会随着不同的情况发生改变的数据
  比如double price = 2.5   -> price = price*0.8
2.作用:临时存储一个数据
  什么时候想操作这个数据了,直接用变量名即可
3.定义格式:
  数据类型 变量名 = 值   -> 将等号右边的值赋值给等号左边的变量
                         有等号必须先看等号右边的,哪怕等号右边有运算,我们都要先算出最终结果,再将结果赋值给等号左边的变量
      
  数据类型 变量名1 = 值,变量名2 = 值...   -> 一次性定义多个相同类型的变量
      
4.数据类型:
  java中的数据类型:
    基本类型:4类8种
          整型:  byte short int long
          浮点型: float double 
          字符型: char
          布尔型: boolean
    引用类型:
          类 数组 接口 枚举 注解 Record
              
5.注意:
  a.String不属于基本类型,属于引用类型,但是定义格式和基本类型一样
  b.整数默认类型int;小数默认类型double
      
6.从取值范围给基本类型从小到大排序: byte,short,char  -> int -> long -> float -> double      

public class Demo01Var {
    public static void main(String[] args) {
        //整数
        int num1 = 10;
        num1 = 20;
        System.out.println(num1);
        //long型 -> 定义long型的变量,值后面加L或者l
        long num2 = 10L;

        //float 型 -> 定义float型的变量,值后面加F或者f
        float num3 = 10.5F;
        System.out.println(num3);
        //double型 -> 定义double型的变量
        double num4 = 10.5;
        System.out.println(num4);

        //char
        char num5 = 'a';
        System.out.println(num5);

        //boolean
        boolean num6 = true;
        boolean num7 = false;
        /*
          将num7代表的false赋值给了变量num6
          所以num6变成了false
         */
        num6 = num7;
        System.out.println(num6);

        //字符串->引用类型->字符串类型用String表示
        String s = "abc";
        System.out.println(s);
    }
}

public class Demo02Var {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        /*
          /前后都是整数, 结果是整数
          /前后如果有一个为小数, 结果是小数
         */
        System.out.println(a / b);

        System.out.println("==================");

        /*
          从复用性上来看,将结果单独赋值给一个变量比较好
          比如:因为后面啥时候想使用a+b的结果,直接用add就行了
          没必要重新算一遍了
         */
        int add = a+b;
        System.out.println(add);
        int sub = a-b;
        System.out.println(sub);
        int mul = a*b;
        System.out.println(mul);
        int div = a/b;
        System.out.println(div);
    }
}

public class Demo03Var {
    public static void main(String[] args) {
       /*
          \:代表的是转义字符

          a.可以将具有特殊含义的字符转成普通字符
          b.可以将普通字符转成具有特殊含义的字符
        */

        /*
           n:本身普通字符
           \n:换行符
         */
        System.out.println("hello\nworld");

        /*
           t:本身是普通字符
           \t:制表符,相当于tab键
         */
        System.out.println("hello\tworld");

        /*
           \:本身具有特殊含义
           \\:前面的\将后面的\转义了,此时后面的\就变成普通的字符了
         */
        //用字符串表示一个路径
        String path = "F:\\idea\\io";
        System.out.println(path);
    }
}

public class Demo04Var {
    public static void main(String[] args) {
       var i = 10;
       System.out.println(i);
    }
}

2.变量使用时的注意事项

1.变量不初始化(第一次赋值)不能直接使用
2.在同一个作用域(一对大括号就是一个作用域)中,不能定义重名的变量 
3.不用的作用域之间不要随意互相访问
  a.在小作用域中能使用大作用域中的内容
  b.在大作用域中不能直接使用小作用域中的内容

public class Demo05Var {
    public static void main(String[] args) {
        int i = 10;
        System.out.println(i);

        //int i = 20;  只要变量名前面确定类型,就是定义
        i = 20;//二次赋值,不是重新定义
        System.out.println(i);

        {
            int j = 100;
            System.out.println(j);
            System.out.println(i);
        }
        //System.out.println(j);
    }
}

第三章.标识符

1.概述:就是给类,方法,变量取的名字
2.硬性规定:
     a.不能以数字开头,不能是关键字
     b.名字中可以包含数字,_,$,字母,但是不要数字开头
  软性建议
     a.给类取名字:大驼峰式(每个单词首字母大写)
     b.给方法,变量取名字:小驼峰(从第二个单词开始首字母大写)

第四章.数据类型转换

1.什么时候发生:
  a.等号左右两边类型不一致
  b.大类型和小类型做运算
2.什么叫大类型,什么叫小类型
  两个类型相遇了,取值范围大的就叫做大类型,取值范围小的就叫做小类型 -> 相对的
3.分类:
  自动类型转换
  强制类型转换(强转)

按照取值范围从小到大排列: byte short char -> int -> long -> float -> double

1.自动类型转换->小转大

1.情况1:  取值范围大的类型 变量名 = 取值范围小的类型  -> 小类型自动提升为大类型
2.情况2:  取值范围大的类型和取值范围小的类型数据做运算  -> 小类型自动提升为大类型

public class Demo01DataType {
    public static void main(String[] args) {
        /*
          等号右边的100是整数,整数默认类型int
          等号左边num1是long型
          将int型的数据给long型的变量,相当于将取值范围小的类型给取值范围大的变量
          发生了自动类型转换
         */
        //long num1 = 100;
        long num1 = 100L;
        System.out.println(num1);

        /*
         等号右边的10是整数,整数默认类型int
         等号左边num2是double型
         将int型数据给double型变量,相当于将取值范围小的类型给取值范围大的变量
         发生了自动类型转换
         */
        double num2 = 10;
        System.out.println(num2);


        double a = 10.0;
        int b = 10;

        /*
          大类型和小类型做运算了
          小类型会自动提升为大类型
          double+int  -> double+double
         */
        double sum = a+b;
        System.out.println(sum);

    }
}

2.强制类型转换_大转小

1.情况1:取值范围小的类型 变量名 = 取值范围大的类型   -> 报错
2.怎么强转:
  取值范围小的类型 变量名 = (取值范围小的类型)取值范围大的类型

public class Demo02DataType {
    public static void main(String[] args) {
        /*
          等号右边是小数,小数默认类型double
          等号左边i是int型
          将double型的数据赋值给int型的数据,相当于将取值范围大的类型赋值给取值范围小的类型
          需要强转
         */
         //int i = 2.5;
         int i = (int) 2.5;
         System.out.println(i);

        /*
           等号右边是小数,小数默认类型为double
           等号左边j是float型
           将double型数据赋值给float型数据,相当于将取值范围大的类型赋值给取值范围小的类型
           需要强转
         */
         //float j = 2.5;
         float j = (float)2.5;
         System.out.println(j);
    }
}

3.强转的注意事项

1.不要随意写成强转形式,除非没有办法,否则会出现精度损失,数据溢出现象
2.byte和short如果等号右边是字面值,不超范围,不需要我们自己手动强转,jvm帮我们自动强转了
  byte和short的变量如果等号右边有变量参与运算,byte和short会自动提升为int型,如果最终结果重新赋值给byte或者short的变量,需要我们自己手动强转  
3.char类型如果做运算,会自动提升为int,会去ASCII码表中找这个字符对应的int值,如果ASCII码表中没有,去自动去unicode码表(万国码)中查找字符对应的int值     

public class Demo03DataType {
    public static void main(String[] args) {
        //精度损失
        int a = (int) 2.9;
        System.out.println(a);

        /*
          数据溢出

          int用32位二进制表示
          100亿:36位二进制
         */
        int b = (int)10000000000L;
        System.out.println(b);//1410065408

        System.out.println("======================");

        byte num1 = 100;
        System.out.println(num1);

        /*
           byte = byte+int  -> int+int
         */
        byte result = (byte)(num1+1);
        System.out.println(result);

        System.out.println("===================");
        char c = 'a';
        System.out.println(c+0);
        System.out.println('中'+0);
    }
}

第五章.运算符

1.算数运算符

符号	说明
+	加法
-	减法
*	乘法
/	除法
%(模)	取余

public class Demo01SuanShu {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;
        
        int add = a+b;
        System.out.println(add);
        int sub = a-b;
        System.out.println(sub);
        int mul = a*b;
        System.out.println(mul);
        int div = a/b;
        System.out.println(div);
        int mod = a%b;
        System.out.println(mod);
    }
}

+:
  加法
  字符拼接-> 任意类型遇到字符串都会变成字符串

public class Demo02SuanShu {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

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

        int add = a+b;
        System.out.println("a与b的和为:"+add);
        System.out.println("add = " + add);

    }
}

2.自增自减运算符(也算算数运算符的一种)

1.格式:
  变量++:后自加
  ++变量:前自加
  变量--:后自减
  --变量:前自减
2.++ -- 每次只+ - 1
3.分类:
 单独使用:++ -- 自己单独成为一句,没有和别的语句掺和使用
        符号在前在后都是先运算
 混合使用:++ -- 和其他语句混合使用
        符号在前:先运算,再使用运算后的值
        符号在后:先使用原值,完事之后再加减

public class Demo03SuanShu {
    public static void main(String[] args) {
        //单独使用
        int i = 10;
        i++;
        System.out.println(i);

        //混合使用
        int j = 10;
        //int result = ++j;
        int result = j++;
        System.out.println(result);
        System.out.println(j);

        System.out.println("==================");
        int c = 10;
        c = c++;
        System.out.println(c);
        System.out.println(c);
    }
}

在实际开发过程中,我们用的都是单独使用

3.赋值运算符

1.基本赋值运算符
  =
    
2.复合赋值运算符
  +=
     int i = 10;
     i+=1;   -> i = i+1
  -=
  *=
  /=
  %=  
         
3.注意:
  针对于byte,short参与复合赋值运算符运算,jvm会自动转型

public class Demo04FuZhi {
    public static void main(String[] args) {
        int i = 10;
        i+=10;//i = i+10
        System.out.println(i);

        i/=3;
        System.out.println(i);

        i%=3;
        System.out.println(i);

        System.out.println("=================");
        byte b = 10;
        b+=1;//b = b+1
        //b = b+1;
        System.out.println(b);
    }
}

4.关系运算符(比较运算符)

1.结果:boolean类型的结果 -> true -> false
2.作用:做判断条件使用    

符号	说明
==	判断符号前后结果是否相等,如果相等为true;否则为false
>	判断符号前的数据是否大于符号后的数据,如果大于为true;否则为false
<	判断符号前的数据是否小于符号后的数据,如果小于为true;否则为false
>=	判断符号前的数据是否大于或者等于符号后的数据,如果大于或者等于为true;否则为false
<=	判断符号前的数据是否小于或者等于符号后的数据,如果小于或者等于为true;否则为false
!=	判断符号前后结果是否不相等,如果不相等为true;否则为false

public class Demo05Compare {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;
        boolean result1 = a==b;
        System.out.println(result1);// false

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

5.逻辑运算符

1.结果:boolean型
2.作用:连接多个boolean条件的

符号	说明
&&(与)	有假则假,符号前后结果有一个为false,结果就是false;符号前后都是true,结果才是true
||(或)	有真则真,符号前后结果有一个为true,结果就是true;符号前后都是false,结果才是false
!(非,取反)	不是true,就是false;不是false,就是true

public class Demo06LuoJi {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 10;

        boolean result = (a > b) && (a == c);
        System.out.println(result);

        boolean result01 = (a > b) || (a == c);
        System.out.println(result01);

        boolean result02 = !(a > b);
        System.out.println(result02);
    }
}

&:有假则假,如果符号前面为false,还会继续判断符号后面的
&&:有假则假,如果符号前面为false.符号后面就不判断了 -> 短路效果

|:有真则真,如果符号前面为true,还会继续判断符号后面的 
||:有真则真,如果符号前面为true,符号后面就不判断了 -> 短路效果 

public class Demo07LuoJi {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //boolean result = ++a > 100 & ++b > 100;
        boolean result = ++a > 100 && ++b > 100;
        System.out.println(result);
        System.out.println(a);
        System.out.println(b);
    }
}

int score = 60
判断score的值是否在0-100之间
    
数学写法:0<=score<=100  
java写法:score>=0 && score<=100

6.三元运算符

1.格式:
  boolean表达式?表达式1:表达式2
2.执行流程:
  先走boolean表达式,如果是true,就走?后面的表达式1,否则就走:后面的表达式2

public class Demo08SanYuan {
    public static void main(String[] args) {
        int score = 60;
        String result = score>=60?"及格":"不及格";
        System.out.println(result);
    }
}

需求:有两个和尚,分别身高为150  , 170 获取两个和尚的最高身高

public class Demo09SanYuan {
    public static void main(String[] args) {
        int heShang1 = 150;
        int heShang2 = 170;
        int result = heShang1 > heShang2 ? heShang1 : heShang2;
        System.out.println(result);
    }
}

需求:有三个和尚,分别身高为150 210 170 获取三个和尚的最高身高

public class Demo10SanYuan {
    public static void main(String[] args) {
        int heShang1 = 150;
        int heShang2 = 210;
        int heShang3 = 170;
        int temp = heShang1 > heShang2 ? heShang1 : heShang2;
        int result = temp > heShang3 ? temp : heShang3;
        System.out.println(result);
    }
}