note_doit_day02_变量a只能存放同一种类型的数据-优快云博客

本文链接：https://blog.youkuaiyun.com/dq_dsj/article/details/118894975

1.变量:
   内存--->一块田地
   变量--->田地中的萝卜坑
   *一个变量只能存储一个数据,并且一种类型的变量只能存储这种类型的数据.
   变量概念:内存中一块临时存储数据的空间.
   示例:Demo_01:

       /*
       变量
           就是内存中一块临时存储数据的空间

       定义变量的格式
           数据类型变量名 = 变量值;    --定义变量并赋值
           数据类型变量名            --定义变量
           变量名 = 变量值               --变量赋值
           数据类型:就是当前容器能够存储的数据的类型
           变量名:变量名称
           变量值:容器中存储的数值
           int 整数
           double 小数
           char 字符
           boolean 布尔
       */
       public class Demo_01
       {
           public static void main(String[] args)
           {
               //数据类型变量名 = 变量值
               int a = 10;
               //给变量a赋值
               a = 20;
               System.out.println(a);

               //定义一个小数类型变量
               double a1=10.1;
               System.out.println(a1);
               //定义一个字符类型变量
               char a2='a';
               System.out.println(a2);
               //定义一个布尔类型变量
               boolean a3=false;
               a3=true;
               System.out.println(a3);
           }
       }

   示例:Demo02_Var:
       /*
       变量注意事项
           1.变量使用之前必须赋值,不赋值不能使用
           2.变量是由作用域的
           3.变量不可以重复定义,在相同作用域范围内,变量名不能重复.
       */
       public class Demo02_Var
       {
           public static void main(Strins[] args)
           {
               int a;
               a = 10;
               int b;
               {
                   int b;//报错:变量不可以重复定义
                   b=10;
                   System.out.println(b);
               }
               int b;
           }
       }

2.计算机的存储单元:
   最小的信息单位叫做"位(bit)",要么存"0"要么存"1".
   最基本的存储单元叫"字节(byte)",一个字节占8个位,可存储256个数.
   *当程序需要使用内存的时候,系统最少分配一个字节.
   1B(字节)=8bit
   1KB=1024B
   1MB=1024KB
   1GB=1024MB
   1TB=1024GB
   1PB=1024TB

3.基本数据类型
       数据类型       关键字       内存占用       取值范围
   整数型:
       字节型           byte       1字节           -128至127
       短整型           short       2字节           -32768至32767
       整型           int           4字节           -2^31至2^31
       长整型           long       8字节           -2^63至2^63
   浮点数:
       单精度浮点数   float       4字节           忽略
       双精度浮点数   double       8字节           忽略
   字符型:
       字符型           char       2字节           0至2^16
   布尔类型:
       布尔类型       boolean       1字节           true,false

   示例:Demo03_Var:
           /*
               基本类型 4类8种
                   整数
                       byte       1   -128 +127
                       short       2
                       int           4   默认
                       long       8   需要在末尾加上l或者L,推荐L
                   小数
                       float       4   f或F
                       double       8   默认
                   字符
                       char       2
                   布尔
                       boolean       1
               引用类型String
                   String是引用类型,但是现在来说使用方法和基本类型类似
                   String s = ""

           */
           public class Demo03_Var
           {
               public static void main(String[] args)
               {
                   byte b = 10;
                   System.out.println(b);

                   //long l = 1000000000000000;//报错,因为默认是int类型
                   //System.out.println(l);
                   long l = 1000000000000000L;//正确
                   System.out.println(l);

                   float f = 3.14f;//正确

                   System.out.println("-------------------------------------");
                   String s = "abc";
                   System.out.println(s);

               }
           }

4.数据类型转换:
   1.自动类型提升:(小萝卜放大坑)
       char c = 'a';
       int i = c;
       //输出c得到97
   2.强制类型转换:(大萝卜放小坑,多余部分消除)
       int i = (int)10.1
       System.out.println(i);
       //输出10
       int i2=97;
       char c2=(char)i2;
       System.out.println(c2);
       //输出a

       byte b3 = 10+20;
       System.out.println(b3);//输出30

       byte b1=10;
       byte b2=20;
       byte b3=b1+b2;//编译报错
       byte b4=(byte)(b1+b2);//正确输出30

5.运算符:
   1.算数运算符:
       +:算数加号;连接字符串
       -;算数减号
       *:算数乘号
       /:算数除号
       ++:
       --:
   Demo05:
       /*
       算术运算符
       + 正常加法,也可以连接字符串
       - 正常减法
       *   正常乘法
       /   整数整除,不要余数,小数正常计算
       %   取模整数整除只要余数取模的符号知与被取模数相同

       ++   自增
           单独使用+1即可;混合使用:
           ++在前,先++再使用
           ++再后,先使用再++
       --   自减
           单独使用,减一
       */
       public class Demo05
       {
           public static void main(String[] args)
           {
               int a = 10;
               int b = 20;
               System.out.println(a+b+"是a+b的和");//正常输出
               System.out.println("a+b的和是"+a+b);//不正确输出,先算成字符串类型
               System.out.println("a+b的和是"+(a+b));//正确输出

               System.out.println(a-b);//-10
               System.out.println(a*b);//200
               System.out.println(a/b);//0
               System.out.println(5/2);//2
               System.out.println(5.0/2);//2.5

               System.out.println(5%2);//1
               System.out.println(a%b);//10
               System.out.println(-5%2);//-1
               System.out.println(-5%-2);//-1

               System.out.println("-----------------------------------------");
               int i = 10;
               int j=10;
               i++;//1.取到a的值;2.将a的值加一;3.将结果赋值给a
               i--;
               System.out.println(i);
               System.out.println(i++);//先打印i的值,再做++
               System.out.println(++j);//先做++,再打印j的值

               int c= 100;
               int d = c++;
               System.out.println(d);//100
           }
       }

   2.赋值运算符:
   Demo06:
       /*
           赋值运算符
           =,+=,-=,/=,*= 将等号两边先用指定的运算符连接,然后将结果强制类型转换为等号左边的类型,最后赋值给左边
       */
       public class Demo06
       {
           public static void main(String[] args)
           {
               int a= 10;
               a+=20;
               System.out.println(a);

               byte b =10;
               b+=20;//隐藏了一个强制类型转换
               //b=(byte)(b+20);
               System.out.println(b);
           }
       }

   3.比较运算符:
   Demo07:
   /*
       比较运算符
           比较运算符的结果是布尔值 true/false

           == 判断是否相等
           !=
   */

   public class Demo07
   {
       public static void main(String[] args)
       {
           int a = 10;
           int b = 20;
           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);//
           System.out.println(a!=b);//

           System.out.println((a+=b)>(a-=b));//
           System.out.println(10+20>20-10);//true
       }
   }

   4.位运算:
       12<<2(左移)
       1.先将12转换成2进制
       2.0000 1100---->
       0011 0000 48
       如果左移3位:
       0110 0000 96
       总结:
       M<<N=M*2^N

       12>>2(右移)
       1.0000 1100
       0000 0011 3
       总结:
       M>>N=M*2^N

   5.逻辑运算符:
   Demo08:
       /*
   逻辑运算符
       进行布尔值的计算结果也是布尔值
   && 双与并且有假则假
   || 双或或者有真则真
   ! 非   取反真变假假变真
   异或   不同才是true,相同即为false

   &和&&的区别
       都是并且的意思只要有一个条件是假的,结果一定是假的
       如果是&       判断第一个条件为假后还会继续判断第二个条件然后得出结论为假
       如果是&&   判断第一个条件为假后直接得出结果为假不再往后判断
   */
   public class Demo08
   {
       public static void main(String[] args)
       {
           boolean a=true;
           boolean b=false;
           System.out.println(true &&false);//false
           System.out.println(true ||false);//true
           System.out.println(true ^ false);//false

           System.out.println(a &&b);//false
           System.out.println(b ||b);//true
           System.out.println(!a);//false
           System.out.println(!b);//true

           int a1=10;
           int b1=20;
           System.out.println(a1>b1 && a1<b1);//false
           System.out.println((a1+=20)>50 && (a1+=100)>50);//由于没有短路功能,前面条件为false后面继续运算a=30
           System.out.println((a1+=20)>50 & (a1+=100)>50);//由于没有短路功能,前面条件为false后面继续运算a=130
       }
   }

   6.三元表达式:
   Demo09:
       /*
           三元运算符
           条件表达式 ? 表达式1 : 表达式2
           满足条件 true    执行表达式1
           不满足条件false   执行表达式2

           需要注意三元表达式一定会有一个结果这个结果一定要被使用

       */
       public class Demo09
       {
           public static void main(String[] args)
           {
               int a = 10;
               int b = 20;
               int max = a>b ? a : b;
               System.out.println(max);

               System.out.println(a>b ? "a大":"b大");
           }
       }

练习:
   public class Test01
   {
       public static void main(String[] args)
       {
           int bananaId = 1;
           String bananaName = "香蕉";
           double bananaPrice = 8.0;
           char bananaQuality = 'A';
           int bananaQuantity = 5;

           int appleId = 2;
           String appleName = "苹果";
           double applePrice = 6.5;
           char appleQuality = 'B';
           int appleQuantity = 3;

           int orangeId = 3;
           String orangeName = "橙子";
           double orangePrice = 9.0;
           char orangeQuality = 'A';
           int orangeQuantity = 4;

           double totalPrice = bananaPrice*bananaQuantity+applePrice*appleQuantity+orangePrice*orangeQuantity;
           System.out.println("-------------------------购买水果信息-------------------------");
           System.out.println("水果编号水果名称水果单价品质购买数量品质");
           System.out.println(bananaId+" "+bananaName+" "+bananaPrice+" "+bananaQuality+" "+bananaQuantity+" 公斤");
           System.out.println(appleId+" "+appleName+" "+applePrice+" "+appleQuality+" "+appleQuantity+" 公斤");
           System.out.println(orangeId+" "+orangeName+" "+orangePrice+" "+orangeQuality+" "+orangeQuantity+" 公斤");
           System.out.print("您购买水果的总价为");
           System.out.print(totalPrice);
       }
   }