Java语法基础-1

水深无声 2022-09-28 13:28 233阅读 0赞

# 1. 关键字 #

## 1.1 关键字概述 ##

被Java语言赋予特定含义的单词

## 1.2 关键字特点 ##

组成关键字的字母全部小写

## 1.3 关键字注意事项 ##

*  goto和const作为保留字存在,目前并不使用
 *  类似Notepad++这样的高级记事本,针对关键字有特殊的颜色标记，非常直观

![用于定义数据类型的关键字][20150915084548059]  
![用于定义访问权限修饰符的关键字][20150915084600280]

# 2. 标识符 #

## 2.1 标识符概述 ##

就是给类，接口，方法，变量等起名字时使用的字符序列

## 2.2 组成规则 ##

由英文大小写字母、数字字符、$（美元符号）、\_（下划线）组成

## 2.3 注意事项 ##

*  不能以数字开头
 *  不能是Java中的关键字
 *  区分大小写

## 2.4 标识符常见命名规则：见名知意 ##

### 2.4.1 包 ###

其实就是文件夹，用于把相同的类名进行区分，全部小写，单级：liuyi，多级：cn.itcast

### 2.4.2 类或者接口 ###

一个单词：单词的首字母必须大写，举例：Student,Dog  
多个单词：每个单词的首字母必须大写举例：HelloWorld，StudentName

### 2.4.3 方法和变量 ###

一个单词：单词的首字母小写，举例：main,age  
多个单词：从第二个单词开始，每个单词的首字母大写，举例：studentAge,showAllNames()

### 2.4.4 常量 ###

一个单词：全部大写，举例：PI  
多个单词：每个字母都大写，用\_隔开，举例：STUDENT\_MAX\_AGE

# 3. 注释 #

## 3.1 注释概述 ##

用于解释说明程序的文字

## 3.2 Java中注释分类格式 ##

*  单行注释，格式： //注释文字
 *  多行注释，格式： /\* 注释文字 \*/
 *  文档注释，格式：/*\* 注释文字* /

/* 注释：用于解释说明程序的文字 Java中注释的分类及格式 单行注释：// 多行注释：/星 星/ 注意：多行不可以嵌套使用，而单行是可以的 文档注释：被javadoc工具解析生成一个说明书，面向对象部分讲解。 */
    
    //这是我的注释案例
    class ZhuShiDemo {
        //main方法是主方法
        //是程序的入口
        //被jvm调用
        public static void main(String[] args) {
            System.out.println("好好学习,天天向上");
        }
    }

*  对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行
 *  对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档
 *  注释是一个程序员必须要具有的良好编程习惯
 *  初学者编写程序可以养成习惯：先写注释再写代码
 *  将自己的思想通过注释先整理出来，在用代码去体现
 *  因为代码仅仅是思想的一种体现形式而已

/* 需求：我准备写一个java程序，把"HelloWorld"这句话输出在控制台 分析： A:要写一个Java程序，必须定义类 B:把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法 C:把数据输出在控制台，必须使用输出语句 实现： A:java语言提供了一个关键字：class用来定义类，后面跟的是类名 B:main方法的格式是固定的： public static void main(String[] args) { } C:输出语句的格式是固定的： System.out.println("HelloWorld"); "HelloWorld"这个内容是可以改变的 */
    
    //这是我的HelloWorld案例
    class HelloWorld {
        /* 为了程序能够独立运行，定义main方法 main方法是程序的入口 被jvm自动调用 */
        public static void main(String[] args) {
            //为了把数据显示在控制台，我们就使用了输出语句
            System.out.println("HelloWorld");
        }
    }

# 4. 常量、进制和进制转换 #

## 4.1 常量概述 ##

在程序执行的过程中其值不可以发生改变

## 4.2 Java中常量分类 ##

### 4.2.1 字面值常量 ###

*  字符串常量：用双引号括起来的内容，举例：“hello”，“world”
 *  整数常量：所有整数，举例：12，23
 *  小数常量：所有小数，举例：12.34，56.78
 *  字符常量：用单引号括起来的内容，举例：‘a’,’A’,’0’
 *  布尔常量，较为特有，举例：true，false
 *  空常量，举例：null

### 4.2.2 自定义常量 ###

/* 常量： 在程序执行过程中，其值不发生改变的量。 分类： A:字面值常量 B:自定义常量(后面讲) 字面值常量 A:字符串常量 用双引号括起来的内容。 举例："hello","world","HelloWorld" B:整数常量 所有的整数 举例：100,200 C:小数常量 所有的小数 举例：10.23,110.11 D:字符常量 用单引号括起来的内容 举例：'a','A','0' 错误的：'ab' E:布尔常量 比较特殊 举例：true,false F:空常量 后面讲 举例：null */
    class ConstantDemo {
        public static void main(String[] args) {
            //字符串常量的输出
            System.out.println("hello");
    
            //整数常量的输出
            System.out.println(100);
    
            //小数常量的输出
            System.out.println(100.10);
    
            //字符常量的输出
            System.out.println('a');
            System.out.println('A');
            System.out.println('0');
            //这个是有问题的
            //System.out.println('ab');
    
            //布尔常量的输出
            System.out.println(true);
            System.out.println(false);
        }
    }

## 4.3 Java针对整数常量提供了4种表现形式 ##

二进制，八进制，十进制，十六进制

![20150915164034428][]

## 4.4 进制概述 ##

进制：就是进位制，是人们规定的一种进位方法。 对于任何一种进制–X进制，就表示某一位置上的数运算时是逢X进一位。二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一。

PS：  
二进制的由来：任何数据在计算机中都是以二进制的形式存在的。二进制早期由电信号开关演变而来。

一个整数在内存中一样也是二进制的，但是使用一大串的1或者0组成的数值进行使用很麻烦。所以就想把一大串缩短点，将二进制中的三位用一位表示。这三位可以取到的最大值就是7超过7就进位了，这就是八进制。但是对于过长的二进制变成八进制还是较长，所以出现的用4个二进制位表示一位的情况，四个二进制位最大是15，这就是十六进制。

规律：进制越大，表现形式越短。

## 4.5 不同进制的数据组成 ##

*  二进制，由0，1组成。以0b开头
 *  八进制，由0，1，…7组成。以0开头
 *  十进制，由0，1，…9组成。整数默认是十进制的
 *  十六进制，由0，1，…9，a，b，c，d，e，f(大小写均可)。以0x开头

/* 不同进制的数据表现： 二进制：由0，1组成。以0b开头。 八进制：由0,1,...7组成。以0开头。 十进制：由0,1,...9组成。默认整数是十进制。 十六进制：由0,1,...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。 */
    class JinZhiDemo {
        public static void main(String[] args) {
            System.out.println(100); //十进制
    
            System.out.println(0b100); //二进制
            System.out.println(0100); //八进制
            System.out.println(0x100); //十六进制
        }
    }

运行结果

![20150915164604005][]

## 4.6 进制转换 ##

*  其他进制到十进制

![20150915165054264][]

*  十进制到其他进制

![20150915165352081][]

*  十进制和二进制的快速转换，8421码，也叫BCD码

![20150915165621349][]

*  二进制和八进制，十六进制如何转换  
    以十进制作为桥梁，二进制到八进制 3位组合，二进制到十六进制4位组合

PS：  
1、其他进制到十进制

*  系数：就是每一位上的数据
 *  基数：X进制，基数就是X
 *  权：在右边，从0开始编号，对应位上的编号即为该位的权
 *  结果：把系数\*基数的权次幂相加即可

2、十进制到其他进制  
除基取余，直到商为0，余数反转。

## 4.7 有符号数据表示法 ##

在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用补码进行的

*  原码：就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小
 *  反码：正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外
 *  补码：正数的补码与其原码相同；负数的补码是在其反码的末位加1

![20150915170205912][]

## 4.8 练习 ##

### 4.8.1 得到下面数据的十进制值 ###

0b10101
       =12^4 + 12^2 + 1*2^0    =16 + 4 + 1    =21 
    0123
       =18^2 + 28^1 + 3*8^0    =64 + 16 + 3    =83 
    0x3c
       =316^1 + c16^0    =48 + 12    =60

### 4.8.2 得到下面数据的二进制，十进制，十六进制 ###

52分别得到二进制，十进制，十六进制

得到二进制：

52 / 2 = 26 0 26 / 2 = 13 0 13 / 2 = 6 1 6 / 2 = 3 0 3 / 2 = 1 1 1 / 2 = 0 1 0b110100

得到八进制：

52 / 8 = 6 4 6 / 8 = 0 6 064

得到十六进制：

52 / 16 = 3 4 3 / 16 = 0 3 0x34

### 4.8.3 有符号数据表示法的练习 ###

A：已知某数X的原码为10110100B，试求X的补码和反码。

符号位 数值位  
原码：10110100  
反码：11001011  
补码：11001100

B:已知某数X的补码11101110B，试求其原码

符号位 数值位  
补码： 11101110  
反码： 11101101  
原码： 10010010

# 5. 变量 #

## 5.1 变量概述 ##

在程序执行的过程中，在某个范围内其值可以发生改变的量，理解：如同数学中的未知数

## 5.2 变量定义格式 ##

数据类型 变量名 = 初始化值;  
注意：格式是固定的，记住格式，以不变应万变

## 5.3 变量的组成规则 ##

![20150915170726422][]

1、从本质上讲，变量其实是内存中的一小块区域，使用变量名来访问这块区域，因此，每一个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容），才能使用。通过画图说明一个变量的组成部分

数据类型，变量名，变量值

2、为什么要定义变量呢?用来不断的存放同一类型的常量，并可以重复使用

# 6. 数据类型和类型转换 #

## 6.1 数据类型 ##

6.1.1 Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间

6.1.2 所谓有效数字：具体地说，是指在分析工作中实际能够测量到的数字。所谓能够测量到的是包括最后一位估计的，不确定的数字。对于一个近似数，从左边第一个不是0的数字起，到精确到的位数止，所有的数字都叫做这个数的有效数字。

6.1.3 Java 各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响，以保证Java程序的可移植性。

*  Java语言的整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ’ ，如：
    
    int i1 = 600; //正确 long l1 = 88888888888L; //必须加l否则会出错
 *  与整数类型类似，Java浮点类型有固定的表数范围和字段长度，不受平台影响。
    
    Java浮点类型常量有两种表示形式，十进制数形式，如: 3.14 314.0
 *  科学记数法形式，如 3.14e2 3.14\*10^2
 *  Java 浮点型常量默认为 double 型，如要声明一个常量为 float 型，则需在数字后面加 f 或 F ，如：
    
    double d = 12345.6; //正确 float f = 12.3f; //必须加f否则会出错
 *  char 型数据用来表示通常意义上的“字符”
    
     *  字符常量为用单引号括起来的单个字符，例如：char ch1= ‘a’; char ch2=’中’;
     *  Java字符采用 Unicode 编码，每个字符占两个字节，因而可用十六进制编码形式表示。
     *  注：Unicode是全球语言统一编码
 *  boolean 类型适于逻辑运算，一般用于程序流程控制 。
 *  boolean 类型数据只允许取值 true 或 false ，不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。
 *  数据类型  
    
    
     *  基本数据类型：整型byte、short、int、long，浮点型float、double，字符型char，布尔型boolean
     *  引用数据类型：类class、接口interface、数组\[\]

![20150915120725784][]

![20150915120800513][]

/* 数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。 数据类型分类： A:基本数据类型 B:引用数据类型(类,接口,数值) 基本数据类型:4类8种 A:整数 占用字节数 byte 1 short 2 int 4 long 8 B:浮点数 float 4 double 8 C:字符 char 2 D:布尔 boolean 1 注意： 整数默认是int类型 浮点数默认是double类型。 长整型后缀用L或者l标记。建议使用L。 单精度浮点数用F或者f标记。建议使用F。 */
    class DataTypeDemo {
        public static void main(String[] args) {
            //定义变量的格式：
            //数据类型 变量名 = 初始化值;
    
            //定义一个字节变量
            byte b = 10;
            System.out.println(10);
            System.out.println(b);
    
            //定义一个短整型变量
            short s = 100;
            System.out.println(s);
    
            //定义一个整型变量
            int i = 1000;
            System.out.println(i);
    
            //超过了int的范围
            //int j = 1000000000000;
            long j = 1000000000000L;
            //long j = 100L;
            System.out.println(j);
    
            //定义浮点数据变量
            float f = 12.345F;
            System.out.println(f);
    
            double d = 12.345;
            System.out.println(d);
    
            //定义字符变量
            char ch = 'a';
            System.out.println(ch);
    
            //定义布尔变量
            boolean flag = true;
            System.out.println(flag);
        }
    }

运行结果:

![20150915171707439][]

6.1.4 使用变量的时候要注意的问题：

A：作用域  
变量定义在哪个大括号内，它就在这个大括号内有效。  
并且，在同一个大括号内不能同时定义同名的变量。

B：初始化值  
没有初始化值的变量不能直接使用。  
你只要在使用前给值就行，不一定非要在定义的时候立即给值。  
推荐在定义的时候给值。

定义变量的格式：  
 a：数据类型 变量名 = 初始化值;  
 b：数据类型 变量名;  
变量名 = 初始化值;  
C：在一行上建议只定义一个变量  
 可以定义多个，但是不建议

## 6.2 类型转换 ##

### 6.2.2 默认转换(从小到大的转换) ###

A：byte，short，char—int—long—float—double  
B：byte，short，char相互之间不转换，他们参与运算首先转换为int类型

### 6.2.2 强制转换： ###

从大的数据类型到小的数据类型  
格式：目标数据类型 变量 = (目标数据类型) (被转换的数据);  
注意：不要随意的去使用强制转换，因为它隐含了精度损失问题

/* 面试题： byte b1=3,b2=4,b; b=b1+b2; b=3+4; 哪句是编译失败的呢？为什么呢？ b = b1 + b2;是有问题的。 因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。 常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。 */
    class DataTypeDemo6 {
        public static void main(String[] args) {
            //定义了三个byte类型的变量，b1，b2，b3
            //b1的值是3，b2的值是4，b没有值
            byte b1 = 3,b2 = 4,b;
    
            //b = b1 + b2; //这个是类型提升，所有有问题
    
            b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。
        }
    }

1、在定义Long或者Float类型变量的时候，要加L或者f。  
 整数默认是int类型，浮点数默认是double。  
 byte，short在定义的时候，他们接收的其实是一个int类型的值。  
 这个是自己做了一个数据检测的，如果不再它们的范围内，就报错。

2、byte值的问题

byte b1 = 127;
    byte b2 = (byte)128; //-128
    byte b3 = (byte)129; //-127
    byte b4 = (byte)130; //-126
    byte的范围：-128 ~ 127
    128：10000000
    -128：10000000 (这里的1即是符号位，也是数值位)

3、数据类型转换之默认转换  
byte，short，char – int – long – float – double  
long：8个字节  
float：4个字节  
A：它们底层的存储结构不同  
B：float表示的数据范围比long的范围要大  
long：2^63-1  
float：3.4\*10^38 > 2\*10^38 > 2\*8^38 = 2\*2^3^38 = 2\*2^114 > 2^63-1

4、Java语言中的字符char可以存储一个中文汉字吗?为什么呢?  
 可以。因为java语言中的字符占用两个字节。Java语言采用的是Unicode编码。

# 7. 运算符 #

## 7.1 运算符 ##

*  运算：对常量和变量进行操作的过程称为运算。
 *  运算符：对常量和变量进行操作的符号称为运算符
 *  操作数：参与运算的数据称为操作数
 *  用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式。  
    不同运算符连接的式子体现的是不同类型的表达式。

举例：int a = 3 + 4;  
这是做了一个加法运算，+就是运算符，是算术运算符，我们还有其他很多的运算符，3和4就是参与运算的操作数据，3 + 4整体其实就是一个算数表达式

## 7.2 算术运算符 ##

![算术运算符][20150915121051511]

除法的时候要注意一个问题，整数相除，只能得到整数，要想得到小数，可以\*1.0

*  \++和–的应用  
    单独使用：放在操作数的前面和后面效果一样。(这种用法是我们比较常见的)  
    参与运算使用：放在操作数的前面，先自增或者自减，然后再参与运算；放在操作数的后面，先参与运算，再自增或者自减。  
    作用：就是对变量进行自增1或者自减1。
 *  \+的用法：加法，正号，字符串连接符
 *  运算符的优先级（由高到低）

![运算符的优先级][20150915173435776]

## 7.3 赋值运算符 ##

基本的赋值运算符：=，把=右边的数据赋值给左边。  
扩展的赋值运算符：+=、-=，\*=，/=，%=，+= 把左边和右边做加法，然后赋值给左边。

## 7.4 关系运算符 ##

![关系运算符][20150915121144989]

*  比较运算符的结果都是boolean型，也就是要么是true，要么是false。
 *  比较运算符“==”不能误写成“=”

## 7.5 逻辑运算符 ##

![逻辑运算符][20150915121233289]

*  逻辑运算符用于连接布尔型表达式，在Java中不可以写成3

## 7.6 位运算符 ##

位运算是直接对二进制进行运算

![位运算符][20150915121317217]

![位运算符的细节][20150915121408273]

/* 位运算符： &,|,^,~ <<,>>,>>> 注意： 要做位运算，首先要把数据转换为二进制。 */
    class OperatorDemo {
        public static void main(String[] args) {
            //&,|,^,~
    
            int a = 3;
            int b = 4;
    
            System.out.println(3 & 4);
            System.out.println(3 | 4);
            System.out.println(3 ^ 4);
            System.out.println(~3);
        }
    }
    /* 分析：因为是位运算，所以我们必须先把数据换算成二进制。 3的二进制：11 00000000 00000000 00000000 00000011 4的二进制：100 00000000 00000000 00000000 00000100 &位与运算：有0则0。 00000000 00000000 00000000 00000011 &00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000000 结果是：0 |位或运算：有1则1。 00000000 00000000 00000000 00000011 |00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000111 结果是：7 ^位异或运算：相同则0，不同则1。 00000000 00000000 00000000 00000011 &00000000 00000000 00000000 00000100 ----------------------------------- 00000000 00000000 00000000 00000111 结果是：7 ~按位取反运算符：0变1，1变0 00000000 00000000 00000000 00000011 ~11111111 11111111 11111111 11111100 (补码) 补码：11111111 11111111 11111111 11111100 反码：11111111 11111111 11111111 11111011 原码：10000000 00000000 00000000 00000100 结果是：-4 */

## 7.7 三目运算符 ##

*  格式：(关系表达式)?表达式1：表达式2；  
    
    
     *  如果条件为true，运算后的结果是表达式1；
     *  如果条件为false，运算后的结果是表达式2；
 *  示例：获取两个数中大数。

int x=3，y=4，z;
    z = (x>y)?x：y；//z变量存储的就是两个数的大数。

[20150915084548059]: /images/20220708/b346da37db954b9da082055938fc54ef.png
[20150915084600280]: /images/20220708/ff5fbd0abe7a4789954806134aee17e7.png
[20150915164034428]: /images/20220708/1fefa7c5c88d481486a74054de8a1ac4.png
[20150915164604005]: /images/20220708/c13c830c70f043fba53f0e944ee70028.png
[20150915165054264]: /images/20220708/a58456f27b7f4cf396107fab3bab3bd6.png
[20150915165352081]: /images/20220708/92c7704d53934b298919d5d7fb16a263.png
[20150915165621349]: /images/20220708/3111d6b2ca8f4f82a5500d47fd2ded30.png
[20150915170205912]: /images/20220708/9c0746bcf9e34efe9a1bc9ea6bf11b8d.png
[20150915170726422]: /images/20220708/1ee6e018e2ac478da8220f831a6b200e.png
[20150915120725784]: /images/20220708/f32a8786ee0d43feab5fb2da97bb026c.png
[20150915120800513]: /images/20220708/9e78ef8f6a8141858043238152215ee1.png
[20150915171707439]: /images/20220708/1dd9e97ee13f4866961a55cfd33f394c.png
[20150915121051511]: /images/20220708/b2951246faf44fe49fec203bfbf40e3c.png
[20150915173435776]: /images/20220708/845c4544b83e4640843a5bc6e013453e.png
[20150915121144989]: /images/20220708/52b7762918fa453da545df41d5d315a5.png
[20150915121233289]: /images/20220708/ff029a69374f4589a058c20109e68340.png
[20150915121317217]: /images/20220708/40103ea3be12460199f498a8a567274c.png
[20150915121408273]: /images/20220708/63419c82304b4063b492d2305ae0793b.png