从0开始学java-Day02——数据类型，变量和常量，运算符

最新推荐文章于 2023-07-15 15:14:05 发布

zlg_javaDream

最新推荐文章于 2023-07-15 15:14:05 发布

阅读量218

点赞数

分类专栏： java基础

本文链接：https://blog.csdn.net/weixin_48583602/article/details/106862584

版权

java基础专栏收录该内容

30 篇文章 3 订阅

订阅专栏

01计算机的信息单元和存储单元

*A:计算机中最小的信息单元是比特位（b），简称位
*B: 计算机中储存和运算的最小单位是?
    * a: 一个字节,也就是一个byte.
        * win+r--cmd--回车            
    * b: 常用储存单位
        *1B（字节） = 8bit
        *1KB = 1024B
        *1MB = 1024KB
        *1GB = 1024MB
        *1TB = 1024GB
        *1PB = 1024TB

02Java中的数据类型：基本和引用

* A:为什么有数据类型
    * Java语言是强制类型型语言，对于每一种数据都定义了明确的具体数据类型
* B:Java中数据类型的分类
    * 基本数据类型: 基本数据类型是Java语言中内置的类型，分别是整数类型、小数类型、字符类型、布尔类型。
        这四类八种基本类型是最简单、最基础的类型。
        * 整数(byte、short、int、long)、小数(float、double)、字符类型(char)、布尔类型(boolean)
    * 引用数据类型: 是强大的数据类型，它是基于基本数据类型创建的。JavaSE中提供了一个超级类库，类库中包含了近万种引用数据类型。
        我们要学习的的引用类型：数组、类、接口

03Java中基本数据类型：四类八种

* A: 数据类型四类八种
    *四类   八种    字节数   数据表示范围
    *整型   byte     1     -128～127
           short    2     -32768～32767
           int      4     -2147483648～2147483648（默认）
           long     8     -263～263-1
    *浮点型 float    4     -3.403E38～3.403E38
           double   8     -1.798E308～1.798E308（默认）
    *字符型 char     2     表示一个字符，如('a'，'A'，'0'，'家')，值必须加上单引号，且只能存一个字符
    *布尔型 boolean  1     只有两个值true与false
    
*   整型，浮点属于数值型，布尔char属于非数值型

04java中引用数据类型

*java中的引用数据类型：类，接口，数组
* String 是引用数据类型中的一种，是一种类，可以当作基本数据类型来使用，其值要加双引号。
* Scanner也是一种引用数据类型，作用是接受用户在键盘输入的值
*引用类型使用步骤：
    a.导包
    import java.util.Scanner或者import java.util.*
    b.创建Scanner类对象
    Scanner sc = new Scanner(System.in);
    c.使用常用方法
    int age = sc.nextInt();//接受int型数据，用户若输入字符会出异常
    double score = sc.nextDouble();//接受double型，用户若输入字符会出异常
    String name = sc.next();//接受String型，不会出现异常

05变量概述

* A: 理解什么是变量?
    * a: 变量是一个内存中的小盒子（小容器），容器是什么？生活中也有很多容器，例如水杯是容器，用来装载水；你家里的大衣柜是容器，用来装载衣裤；饭盒是容器，用来装载饭菜。那么变量是装载什么的呢？答案是数据！结论：变量是内存中装载数据的小盒子，你只能用它来存数据和取数据。

* 概念：一个存储空间的表示，其值是可以发生变化的。

06变量创建的三要素

*变量的声明和使用：
   a.声明，如：int money;
   b.赋值，如：money = 1000;
   c.使用，如：输出打印money;
ab可以合成一步--->int money = 1000;
  该语句的含义：在内存空间中开辟了一个int型的空间，给这个空间命名为money，并且赋值1000；

*定义变量的语法格式：
    数据类型  变量名  =  变量值;
    * int         a    =  100;      
    * B:代码:
    public class Variable {
        public static void main(String[] args) {
            int a = 10;
            double b = 3.14;
            char c = 'z';
            String s = "i love java";
        
            a = 20;
            System.out.println(a);
        }
    }

07定义所有的基本数据类型变量

* 八种基本类型数据的创建
  byte b = 1;//定义字节型变量
  short s = 200;//定义短整型变量
  int i = 50000;//定义整型变量
  long l = 2147483648L;//定义长整型变量（数值后面要加L）
  float f = 3.14F;//定义单精度变量（数值后面要加F）
  double d = 3.14;//定义双精度变量
  char c = 'a';//定义字符型变量
  boolean b = true;//定义布尔型变量
  
*引用类型String的定义：
 String s1 = "abcd"；//定义字符串变量

08变量定义使用注意事项

* A：变量使用的注意事项
    * a: 变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
        public static void main(String[] args) {
        int x;
        x = 20; //为x赋值20
        System.out.println(x);//读取x变量中的值，再打印
        }

*B：变量不可以重复定义(即声明变量的时候变量名不能重复)，可以重复赋值。

* c:变量使用时有作用域的限制。
        public static void main(String[] args) {
        int x = 20;
        {
            int y = 20;
        }
        System.out.println(x);//读取x变量中的值，再打印
        System.out.println(y);//读取y变量中的值失败，失败原因，找不到y变量，因为超出了y变量作用范围，所以不能使用y变量
        }

其他：

当在程序中使用“+”的时候，符号只要有一个是字符串，该行执行语句中所有的“+”都起拼接作用，除非出现括号。

         int a = 1;
        int b = 2;
        System.out.println("结果是："+a+b);//结果是：12
        System.out.println("结果是："+(a+b));//结果是：3

如果+符号两边都是数值型，则求和

09常量的概念和定义

*A:常量的概念：一个存储空间的表示，其值不可以发生变化。
*B:常量的定义：使用final修饰常量，在声明的时候就赋值且值不可以再改变。如：
   final double MY_PI = 3.14;
*C:常量名要求全部大写，多个单词的话，使用下划线进行连接
*D:优点是更加安全
*E:注意点
    * a: 整形常量默认是int类型
    * b: 小数常量默认是double类型
    * c: 定义长整形数据如果值超过int取值范围后面要+"L"
    * d: 定义float类型的数据后面要+"F" 否则默认是double

10Java中的常量

* A: 常量的定义
    * 常量就是不变的数据量, 在程序执行的过程中其值不可以发生改变
* B: 常量分类
    * a: 整数类型
        * 十进制表示方式：正常数字   如 13、25等
        * 二进制表示方式：以0b(0B)开头    如0b1011 、0B1001 
        * 十六进制表示方式：以0x(0X)开头   数字以0-9及A-F组成  如0x23A2、0xa、0x10 
        * 八进制表示方式：以0开头   如01、07、0721
    * b: 小数类型
        * 如1.0、-3.15、3.168等
    * c: 布尔类型
        * true、false
    * d: 字符类型
        * 如'a'，'A', '0', '家'
        * 字符必须使用’’ 包裹，并且其中只能且仅能包含一个字符。
    * e: 字符串类型
        * 字符串String类型是一种引用类型，我们先了解作为常量类型的使用方式
        * 如“我爱Java”，“0123”，“”，“null”
        * 字符串必须使用“”包裹，其中可以包含0~N个字符。

11程序中输出Java中的常量

* A: 案例代码
    /*
       Demo_1类，演示Java中的所有类型的常量
       程序当中输出：
         输出整数常量
         小数常量
         布尔常量
         字符常量
         字符串常量
    */
    public class Demo_1{
        public static void main(String[] args){
            //输出整数 十进制
            System.out.println(50);
            
            //输出整数，二进制, 数字开头0B
            System.out.println(0B11);
            
            //输出整数，八进制，数字开头0
            System.out.println(051);
            
            //输出整数，十六进制，数组开头0X  0-9 A-F
            System.out.println(0XE);
            
            //输出浮点数据
            System.out.println(5.0);
            
            //输出布尔数据，只有2个值，true，false 关键字
            System.out.println(true);
            System.out.println(false);
            
            //输出字符常量，单引号包裹，只能写1个字符
            System.out.println('a');
            
            //输出字符串常量，双引号包裹，可以写0-n个字符
            System.out.println("HelloWorld");
        }
    }

12数据类型转换_自动转换

- A:  自动类型转换
- a:表示范围小的数据类型转换成范围大的数据类型，这种方式称为自动类型转换自动类型转换格式：
```
    范围大的数据类型 变量 = 范围小的数据类型值；
    如：
            double d = 1000;
        或
            int i = 100;
            double d2 = i;
```
  *注意点： a..两个不同数据类型进行运算，数据类型要相互兼容，如：都是数值型 b.两个不同数据类型进行运算，会自动提升为较大的数据类型 c.byte，short，char在进行运算时，会提升为int型在进行计算，计算结果也是int型如：byte a = 1;
```
  byte b = 2;
  byte c = a +b;//这里会编译报错，需改为 byte c = (byte)(a+b);
```

13数据类型转换_强制转换

* A: 强制类型转换
    *a: 表示范围大的数据类型转换成范围小的数据类型，这种方式称为强制类型转换
    *b: 强制类型转换格式：
    范围小的数据类型  变量 = (范围小的数据类型) 范围大的数据类型值;
    如：
    int  i = (int)6.718;   //i的值为6
    或
    double  d = 3.14;
    int  i2 = (int)d;     //i2的值为3
    再如：
    int a = 81.29;
    double b = 2;
    int c = (int)(a+b);//83  先运算，把结果转换int
    int d = (int)a+b;//83   先把a转换int，再进行计算
*注意点：
    a.强制类型转换可能会损失数据精度，没有特殊要求慎用。
    b.short、byte、char等类型的变量在参与运算时会先被隐含地转换为int类型，再参与运算
    c.char类型和int类型运算时，char类型的值会查询ASCII码，转换为对应的int型数字，再参与运算

14算数运算符_1

* A: 常见操作
    运算符 运算规则       范例             结果
    +   正号             +3               3
    +   加               2+3              5
    +   连接字符串       “中”+“国”       “中国”
    -   负号            int a=3;-a       -3
    -   减              3-1               2
    *   乘              2*3               6
    /   除              5/2               2
    %   取模（取余）      5/2               1
    ++  自增1         int a=1;a++/++a      2
    --  自减1         int b=3;a--/--a      2
* B: 注意事项
    *a:加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。在打印语句中，+号前后只要
       出现一个字符串，所有的+号都起连接作用，除非出现（）。
       例如：int a = 1;
             int b=2;
             System.out.println("结果是:"+a+b);//结果是:12
             System.out.println("结果是:"+(a+b);//结果是:3
    *b:除法“/”当两边为整数时，取整数部分，舍余数。
       当其中一边为浮点型时，按正常规则相除。 
    *c:“%”为整除取余符号，小数取余没有意义。结果符号与被取余符号相同。
    *d:整数做被除数，0不能做除数，不会编译报错，运行会异常
    *e:小数做被除数，整除0不会报错且结果为Infinity，对0取模不会报错且结果为NaN
* C:代码演示
public class OperatorDemo1 {
    public static void main(String[] args) {
    /*
     * 常量使用算数运算符
     */
    System.out.println(10+20);
    
    /*
     * 变量使用算数运算符
     */
    int x = 10;
    int y = 20;
    //"+"作为加法运算使用
    int z = x + y; 
    //"+"作为连接字符串使用
    System.out.println("x="+x);
    System.out.println("y="+y);
    System.out.println("z="+z);
}

}

15算数运算符_2

* A:算数运算符++、--的使用
    * a: ++运算符，会在原有值的基础上自增1
       举例：
           int a = 8;
           System.out.println(a++);//8
            System.out.println(a);//9
    * b: --运算符，会在原有值的基础上自减1。
* B:++  -- 位置的使用
    * a:++,--后置时，先使用变量a原有值参与运算操作，运算操作完成后，变量a的值自增1或者自减1；
    * b:++，--前置时，先将变量a的值自增1或者自减1，然后使用更新后的新值参与运算操作。

16赋值运算符

* A: 赋值运算符的使用
    运算符 运算规则    范例      结果
    =   赋值      int a=2      2
    +=  加后赋值    int a=2，a+=2    4
    -=  减后赋值    int a=2，a-=2    0
    *=  乘后赋值    int a=2，a*=2    4
    /=  整除后赋值   int a=2，a/=2    1
    %=  取模后赋值   int a=2，a%=2    0

* B：案例演示
    
     * 赋值运算符
     * +=, -=, *=, /=, %= ： 
     * 上面的运算符作用：将等号左右两边计算，会将结果自动强转成等号左边的数据类型,再赋值给等号左边的
     * 注意：赋值运算符左边必须是变量
 
    public class OperatorDemo2 {
        public static void main(String[] args) {
            byte x = 10;
            x += 20;// 相当于 x = (byte)(x+20);
            System.out.println(x);
        }
    }

17关系运算符(比较运算符)

* A:比较运算符的使用
    运算符 运算规则    范例  结果
    ==  相等于     4==3    False
    !=  不等于     4!=3    True
    <   小于      4<3      False
    >   大于      4>3      True
    <=  小于等于   4<=3     False
    >=  大于等于   4>=3     True

18逻辑运算符

* A: 逻辑运算符的使用
    运算符 运算规则    范例      结果
    &   与       false&true  False
    |   或       false|true  True
    ^   异或      true^flase  True
    !   非       !true       Flase
    &&  短路与    false&&true  False
    ||  短路或    false||true  True

    规律小结:
        短路与&&:参与运算的两边数据，有false，则运算结果为false；具有短路功能
       短路或||:参与运算的两边数据，有true，则运算结果为true；具有短路功能
       逻辑非!（取反） : 参与运算的数据，原先是true则变成false，原先是false则变成true。

19三元（目）运算符（又叫条件运算符）

* A: 格式:
    (布尔条件表达式)？表达式1：表达式2；
    如果布尔表达式结果为true，执行表达式1
    如果布尔表达式结果为flase，执行表达式2
    
    *注意：返回值的数据类型必须和接受的数据类型一致
    
* B: 代码案例
    一：
    System.out.println( 3>2 ? “正确” : “错误” ); 
    // 三元运算符运算后的结果为true，运算结果为表达式1的值“正确”，然后将结果“正确”，在控制台输出打印

    二：
    int a = 3;
    int b = 4;
    String result = (a==b) ? “相等” : “不相等”;  
    //三元运算符运算后的结果为false，运算结果为表达式2的值“不相等”，然后将结果赋值给了变量result

    三：
    int n = (3>2 && 4>6) ? 100 : 200;
    //三元运算符运算后的结果为false，运算结果为表达式2的值200,然后将结果200赋值给了变量n

20运算符优先级

优先级 描述      运算符
1   括号      ()、[]
2   正负号     +、-
3   自增自减，非  ++、--、!
4   乘除，取余   *、/、%
5   加减      +、-
6   移位运算    <<、>>、>>>
7   大小关系    >、>=、<、<=
8   相等关系    ==、!=
9   按位与     &
10  按位异或    ^
11  按位或     |
12  逻辑与     &&
13  逻辑或     ||
14  条件运算    ?:
15  赋值运算    =、+=、-=、*=、/=、%=
16  位赋值运算   &=、|=、<<=、>>=、>>>=

21商场库存清单案例

A: 案例分析.
    * a:观察清单后，可将清单分解为三个部分（清单顶部、清单中部、清单底部）
    * b:清单顶部为固定的数据，直接打印即可
    * c:清单中部为商品，为变化的数据，需要记录商品信息后，打印
        经过观察，我们确定一项商品应该有如下几个属性：
        品牌型号: 即商品名称，String型
        尺寸：物品大小，double型
        价格：物品单价，double型
        配置：这一项为每种商品的配置信息，String型
        库存数：这一项为每种商品的库存个数，int型

    * d:清单底部包含了统计操作，需经过计算后，打印
        我们发现两个单独的可变化量
        总库存数：所有商品总个数，int型
        库存商品总金额：所有商品金额，double型

B: 案例代码实现
    //步骤一:  创建Demo01库存清单.java文件，编写main主方法
    public class Demo01库存清单 {
        public static void main(String[] args) {
        }
    }
    //步骤二:  记录每种库存商品信息
    //苹果笔记本电脑
    String macBrand = "MacBookAir";
    double macSize = 13.3;
    double macPrice = 6988.88;
    int macCount = 5;

    //联想Thinkpad笔记本电脑
    String thinkpadBrand = "ThinkpadT450";
    double thinkpadSize = 14.0;
    double thinkpadPrice = 5999.99;
    int thinkpadCount = 10;

    //华硕ASUS笔记本电脑
    String ASUSBrand = "ASUS-FL5800";
    double ASUSSize = 15.6;
    double ASUSPrice = 4999.50;
    int ASUSCount = 18;

    //步骤三: 统计库存总个数、库存总金额
    int totalCount = macCount + thinkpadCount + ASUSCount;
    double totalMoney = (macCount * macPrice) + (thinkpadCount * thinkpadPrice) + (ASUSCount * ASUSPrice);

    //步骤四: 列表顶部
    System.out.println("------------------------------商城库存清单-----------------------------");
    System.out.println("品牌型号    尺寸  价格  库存数");

   步骤四:打印库存清单中部信息
    //列表中部
    System.out.println(macBrand+"   "+macSize+" "+macPrice+"    "+macCount);
    System.out.println(thinkpadBrand+"  "+thinkpadSize+"    "+thinkpadPrice+"   "+thinkpadCount);
    System.out.println(ASUSBrand+"  "+ASUSSize+"    "+ASUSPrice+"   "ASUSCount);
   打印库存清单底部信息
    //列表底部
    System.out.println("-----------------------------------------------------------------------");
    System.out.println("总库存数："+totalCount); 
    System.out.println("库存商品总金额："+totalMoney);