关键字,数据类型,存储单位,强制类型转换,运算符(二)

273 阅读14分钟

关键字

  • 是指在程序中,Java已经定义好的单词,具有特殊含义。

  • 关键字的特点:全都是小写字母。

    关键字含义
    abstract表明类或者成员方法具有抽象属性
    assert断言,用来进行程序调试
    boolean基本数据类型之一,声明布尔类型的关键字
    break提前跳出一个块
    byte基本数据类型之一,字节类型
    case用在switch语句之中,表示其中的一个分支
    catch用在异常处理中,用来捕捉异常
    char基本数据类型之一,字符类型
    class声明一个类
    const保留关键字,没有具体含义
    continue回到一个块的开始处
    default默认,例如,用在switch语句中,表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
    do用在do-while循环结构中
    double基本数据类型之一,双精度浮点数类型
    else用在条件语句中,表明当条件不成立时的分支
    enum枚举
    extends表明一个类型是另一个类型的子类型。对于类,可以是另一个类或者抽象类;对于接口,可以是另一个接口
    final用来说明最终属性,表明一个类不能派生出子类,或者成员方法不能被覆盖,或者成员域的值不能被改变,用来定义常量
    finally用于处理异常情况,用来声明一个基本肯定会被执行到的语句块
    float基本数据类型之一,单精度浮点数类型
    for一种循环结构的引导词
    goto保留关键字,没有具体含义
    if条件语句的引导词
    implements表明一个类实现了给定的接口
    import表明要访问指定的类或包
    instanceof用来测试一个对象是否是指定类型的实例对象
    int基本数据类型之一,整数类型
    interface接口
    long基本数据类型之一,长整数类型
    native用来声明一个方法是由与计算机相关的语言(如C/C++/FORTRAN语言)实现的
    new用来创建新实例对象
    package
    private一种访问控制方式:私用模式
    protected一种访问控制方式:保护模式
    public一种访问控制方式:共用模式
    return从成员方法中返回数据
    short基本数据类型之一,短整数类型
    static表明具有静态属性
    strictfp用来声明FP_strict(单精度或双精度浮点数)表达式遵循IEEE 754算术规范
    super表明当前对象的父类型的引用或者父类型的构造方法
    switch分支语句结构的引导词
    synchronized表明一段代码需要同步执行
    this指向当前实例对象的引用
    throw抛出一个异常
    throws声明在当前定义的成员方法中所有需要抛出的异常
    transient声明不用序列化的成员域
    try尝试一个可能抛出异常的程序块
    void声明当前成员方法没有返回值
    volatile表明两个或者多个变量必须同步地发生变化
    while用在循环结构中

一共50个关键字,其中有const,goto是保留字。

  • 由于java是类C语言,所以保留了C中的一些关键字。在C语言中,const是用来定义常量的,goto是用来跳转的。

  • true,false,null这几个看起来像关键字,但从技术角度来说,他们是特殊的布尔值和空值。

    标识符

    简单来说,凡是程序员自己命名的部分都可以成为标识符。

    就是说,给类、变量、方法、包等命名的字符序列,我们称为标识符。

    1. 标识符的命名规则(必定遵守,否则编译或运行错误)

      • Java的标识符只能使用26个英文字母大小写,0-9的数字,下划线_,美元符号$
      • 不能使用Java的关键字(包含保留字)和特殊值(如null)
      • 数字不能作为开头
      • 不能有空格
      • 严格区分大小写
    2. 标识符的命名规范(约定俗成)

      • 见名知意

      • 类名、接口名等:每个单词的首字母大写,如:HelloWorld

      • 变量、方法名等:从第二个单词开始首字母大写,如:bookName

      • 包名:每一个单词都小写,单词之间使用点.分割,形式:xxx.yyy.zzz。

      • 常量名:每一个单词都使用大写,单词之间使用下划线_分割,如:MAX_VALUE

        数据类型

        Java的数据类型分为两大类:

        • 基本数据类型:包括整数、浮点数、字符、布尔。

        • 引用数据类型:包括类、数组、接口。

          基本数据类型

          四类八种基本数据类型:

          数据类型关键字内存占用(字节)存储范围或精度范围
          byte1-2的7次方到2的7次方
          short2-2的15次方到2的15次方-1
          整数int(默认)4-2的31次方到2的31次方-1
          long8-2的63次方到2的63次方-1
          浮点数float4精度:科学记数法的小数点后6~7位
          double(默认)8精度:科学记数法的小数点后15~16位
          字符char20-65535
          布尔boolean1true,false
          • String的值需要用" ",可以有0,1,多个字符

          • char的值需要用' ',只能有1个字符

          • 比如说"字"和'字'是两个不同的数据类型

          • float的值需要在后边加F或f

          • long的值比较大的时候需要在后边加L或l

          • boolean的值只能是true,false

            常量和变量

            1. 常量:不能修改的值,规定的值。

              • 常数:代码中写死的数字
              System.out.println(19);
              System.out.println("尚硅谷");
              
              • 声明的常量:也称最终变量。比如圆周率Math.PI
              final int MAX_NUM = 100
            2. 变量:在程序运行期间可以改变的量

              • 变量有三要素(数据类型、变量名、变量值)

              • 变量使用有要求(必须先声明后使用+使用之前变量必须初始化+变量在作用域内有效+变量在同一个作用域中不要重名/重复声明)

              • 如何声明变量

                /*
                格式:
                	数据类型 变量名;
                注意:又是声明和初始化放在一句完成,比如说 int age = 18;
                */
                

进制:

十进制:逢十进一,数字0-9

二进制:逢二进一,数字0-1

八进制:逢八进一,数字0-7

十六进制:逢十六进一,数字0-F(字母大小写都可以)

进制转换:

十进制-->二进制:

  1. 整数部分:除2倒取余

    十进制的25对应二进制11001

  2. 小数部分:乘2取整数

    十进制的0.6对应二进制0.10011001....

    (可以联想到float和double都不能完全准确的表示小数,如果对精度要求非常高,比如银行业务,可以使用高精度函数BigDecimal)

    二进制-->十进制

    11001-->1乘以2的四次+1乘以2的三次+0乘以2的二次+0乘以2的一次+1乘以2的一次=16+8+0+0+1=25

    十进制-->八进制

    十进制-->二进制-->右边开始三位一组换算成八进制

    25-->11 001-->31

    八进制-->十进制

    31-->十进制 3乘以8的1次+1乘以8的0次=24+1=25

    十进制-->十六进制

    十进制-->二进制-->四位一组转为十六进制

    34-->10 0010->22(十六进制)

    十六进制转换为二进制

    22->2乘16的1次+2乘16的0次=16*2+2=32+2=34

    进制在代码中的表示方法

    十进制:正常表示

    System.out.println(10);
    

    二进制:0b或0B开头

    System.out.println(0B10);
    

    八进制:0开头

    System.out.println(010);
    

    十六进制:0x或0X开头

    System.out.println(0X10);
    

数据在计算机底层中的存储

  1. 只有二进制

  2. 计算机中最小的存储单位是位,bit,一位表示几种情况,两种要么是0,要么是1,

  3. 计算机中最基本存储单位是字节,byte,一个字节有8位。

  4. 文件大小,硬盘的容量等都是以字节为单位

  5. 计算机底层用补码来存储,符号位是最高位,0表示正数1表示负数。原码、补码、反码

    规定:正数的原码、反码、补码是三码合一,就是一样的

    负数的原码,最高为是符号位,其余是数字位,把数字转为二进制。

    例如:-25的二进制原码,以一个字节为例,10011001

    ​ 反码在原码的符号位不变情况下,其余位取反,0变1,1变0,

    例如:-25的二进制反码,以一个字节位例 11100110

    补码,在反码的基础上+1

    例如:-25的二进制补码,以一个字节为例 11100111

  6. 1个字节到底可以存储多大的数字?-128~127

    各个特殊值的对应的补码

    最大的正整数:0111 1111 -->127

    最小的正整数:0000 0001 -->1

    最大的负整数:1111 1111 -->-1

    最小的负整数:1000 0001 -->-127

    正0:0000 0000 -->0

    负0:1000 0000 -->-128 用它表示0没有意义,浪费位置,所以用它来表示一个特殊值-128

    -1的三码:

    原码:1000 0001

    反码:1111 1110(除了符号位外,其余位取反)

    补码:1111 1111(反码+1)

    -127的三码:

    原码:1111 1111

    反码:1000 0000(除了符号位外,其余位取反)

    补码:1000 0001(反码+1)

    -127-1=-128

    1000 0001-1 =1000 0000

计算机存储单位

字节(Byte):是计算机用于存储信息的计量单位,一字节等于8位;

(bit):是数据存储的最小单位,也就是二进制。二进制系统中,每个0或1就是一个位,叫做bit 比特。其中8位就称为一个字节。

转换关系

  • 8 bit = 1 Byte
  • 1024 Byte = 1 KB
  • 1024 KB = 1 MB
  • 1024 MB = 1 GB
  • 1024 GB = 1 TB

如何存储小数

  • 为什么float(4个字节)比long(8个字节)的存储范围大?

  • 为什么double(8个字节)比float(4个字节)精度范围大?

  • 为什么float和double不精确

因为float、double底层也是二进制,先把小数转为二进制,然后把二进制表示为科学记数法,然后只保存:

①符号位②指数位③尾数位

如何存储字符

在Java中使用的是Unicode编码集

编码表

在计算机的内部都是二进制的0、1数据,如何让计算机可以直接识别人类文字的问题呢?就产生出了编码表的概念。编码表 :就是将人类的文字和一个十进制数进行对应起来组成一张表格。例如:

字符数值
048
A65
a97

A和a的数值差了32而不是26,大写字母和小写字母之间隔了'[','',']','^','_','`'这六个字符

字符常量的几种表示方式

(1)'一个字符'

例如:'A','0','尚'

(2)转义字符

\n:换行
\r:回车
\t:Tab键
\\:\
\":"
\':'
\b:删除键Backspace

System.out.println('\\');
System.out.println("hello\tworld\njava");

(3)\u字符的Unicode编码值的十六进制型

例如:'\u5c1a'代表'尚'

		char c = '\u5c1a';		char c = '尚';		String s = '尚';//错误的,哪怕是一个字符,也要使用双引号				char c2 = '';//错误,单引号中有且只能有一个字符		String s2 = "";//可以,双引号中可以没有其他字符,表示是空字符串

(4)直接给char类型变量赋值十进制的0~65535之间的Unicode编码值

例如:'尚' 的编码值是23578

​ 'a'的编码值是97

char c1 = 23578;System.out.println(c1);//尚char c2 = 97;System.out.println(c2);//a

强制类型转换(显示类型转换)

1.5 赋值到int 类型变量会发生什么?产生编译失败,肯定无法赋值。

int i = 3.14; // 错误

想要赋值成功,只有通过强制类型转换,将double 类型强制转换成int 类型才能赋值。

  • 强制类型转换:将取值范围大的类型强制转换成取值范围小的类型

比较而言,自动转换是Java自动执行的,而强制转换需要我们自己手动执行。

转换格式:

数据类型 变量名 = (数据类型)被强转数据值;

(1)当把存储范围大的值(常量值、变量的值、表达式计算的结果值)赋值给了存储范围小的变量时,需要强制类型转换,提示:有风险,可能会损失精度或溢出

int i = (int)3.14;//强制类型转换,损失精度double d = 1.2;int num = (int)d;//损失精度int i = 200;byte b = (byte)i;//溢出

(2)boolean类型不参与

(3)当某个值想要提升数据类型时,也可以使用强制类型转换

int i = 1;int j = 2;double shang = (double)i/j;

提示:这个情况的强制类型转换是没有风险的。

String str = "123";

特殊的数据类型转换

1、任意数据类型的数据与String类型进行“+”运算时,结果一定是String类型

System.out.println("" + 1 + 2);//12

2、但是String类型不能通过强制类型()转换,转为其他的类型

String str = "123";int num = (int)str;//错误的int num = Integer.parseInt(str);//后面才能讲到,借助包装类的方法才能转

运算符(Operator)

  • 表达式:用运算符连接起来的式子
  • 运算符的分类: 按照功能分:算术运算符、赋值运算符、比较运算符、逻辑运算、条件运算符...
分类运算符
算术运算符+-*/%++--
赋值运算符=+=-=*=/=%=
关系运算符>>=<<===!=
逻辑运算符&、`^!&&`
条件运算符(条件表达式)?结果1:结果2;
位运算符(了解)&、`~^<<>>>>>`
  • 按照操作数个数分:一元运算符(单目运算符)、二元运算符(双目运算符)、三元运算符 (三目运算符)

    一元运算符:操作数只有一个 例如:正号(+) +a 负号(-) -a 自增自减 ++i i++ 逻辑非: !true

    二元运算符:操作数有两个 例如:加法:a+b 减法:a-b 大于:a>b 逻辑与:a&b 三元运算符:条件 ? 结果1 : 结果2

算术运算符

算术运算符符号解释
+加法运算,字符串连接运算,正号
-减法运算,负号
*乘法运算
/除法运算,整数/整数结果还是整数
%求余运算,余数的符号只看被除数
++--自增自减运算

自加自减运算

理解:++ 运算,变量自己的值加1。反之,-- 运算,变量自己的值减少1,用法与++ 一致。

  1. 单独使用
  • 变量在单独运算的时候,变量前++和变量后++,变量的是一样的;
  • 变量前++ :例如 ++a
  • 变量后++ :例如 a++
public class OperatorDemo3 {	public static void main(String[] args) {		// 定义一个int类型的变量a		int a = 3;		//++a;		a++;        // 无论是变量前++还是变量后++,结果都是4		System.out.println(a);	}}

​ 2.复合使用

  • 其他变量放在一起使用或者和输出语句放在一起使用前++后++就产生了不同。
  • 变量前++ :变量先自身加1,然后再取值。
  • 变量后++ :变量先取值,然后再自身加1。
public class OperatorDemo03 {	public static void main(String[] args) {		// 其他变量放在一起使用		int x = 3;		//int y = ++x; // y的值是4,x的值是4,		int y = x++; // y的值是3,x的值是4				System.out.println(x);		System.out.println(y);		System.out.println("==========");        		// 和输出语句一起		int z = 5;		//System.out.println(++z);// 输出结果是6,z的值也是6		System.out.println(z++);// 输出结果是5,z的值是6		System.out.println(z);                int a = 1;        a = a++;//(1)先取a的值“1”放操作数栈(2)a再自增,a=2(3)再把操作数栈中的"1"赋值给a,a=1        int i = 1;        int j = i++ + ++i * i++;        /*        从左往右加载        (1)先算i++        ①取i的值“1”放操作数栈        ②i再自增 i=2        (2)再算++i        ①i先自增 i=3        ②再取i的值“3”放操作数栈        (3)再算i++        ①取i的值“3”放操作数栈        ②i再自增 i=4        (4)先算乘法        用操作数栈中3 * 3 = 9,并把9压会操作数栈        (5)再算求和        用操作数栈中的 1 + 9 = 10        (6)最后算赋值        j = 10        */	} }
  • 小结:
    • ++在前,先自加,后使用;
    • ++在后,先使用,后自加。