带你从零学大数据系列之Java篇---第二章:Java语法基础

温馨提示:如果想学扎实,一定要从头开始看凯哥的一系列文章(凯哥带你从零学大数据系列),千万不要从中间的某个部分开始看,知识前后是有很大关联,否则学习效果会打折扣.

系列文章第一篇是 拥抱大数据：凯哥带你从零学大数据系列-学习大数据前奏(必读)(点我)!

上一篇:拥抱大数据：凯哥带你从零学大数据系列之Java篇---第一章:Java开篇

本章重点：

• 数据类型的分类
• 标识符的规则、规范
• 各种数据类型的变量定义
• 转义字符的使用
• 数据类型转换
• 常用的运算符

2.1. 数据类型

2.1.1. 数据类型概念

在编程中， 其实就是操作着各种数据进行各种的运算。 所有的数据在计算机中进行存储的时候都是有自己的类型的。 数据类型， 即数据存储的类型。

在Java中， 数据类型分为两类: 基本数据类型 和 引用数据类型

本章节中， 只考虑基本数据类型。 引用数据类型， 在后面的章节中讨论。

2.1.2. 基本数据类型分类

2.2. 标识符

2.2.1. 标识符的概念

程序的运行， 其实就是若干数据的运算。 每一个数据都有类型， 就是上述的数据类型。 除此之外， 每一个数据都需要有一个唯一标识来表示。 这个用来表示内存中的某一个数据的表示形式， 就是一个标识符。

类似数学中的代数。
x = 10;
y = 20;
在进行 x + y 的时候， 我们知道其实计算的是 10 + 20。 因此此时x就代表了数字10， y就代表了数字20。
这里的x、y就是标识符。

2.2.2. 标识符的命名规则

标识符， 是由若干个字符组成的有序序列。 在标识符的命名中， 应该遵循以下命名的规则：

1. 由字母、数字、下划线和$符号组成。
2. 不能以数字作为开头。
3. 不能与系统关键字或者保留字重名。

关键字、保留字:
其实也是一个字符序列， 同样遵循上述两点要求。 不过这些字符序列， 已经被系统占用了。 有些被占用后， 被赋予了特殊的含义， 这样的被称为 关键字。 有些字符序列被占用， 但是暂未赋予特殊含义， 在后续的版本更新中， 可能会使用， 这样的被称为  保留字。

2.2.3. 标识符的命名规范

在实际开发中， 遵循了标识符的命名规则的情况下， 有些标识符是可以随意命名的。 比如如下的标识符:

a1, a2, a3, a4, a5, a6, a7

但是， 这样的标识符， 在实际使用过程中， 可读性极差。 在使用的时候， 基本很难理解这个标识符想要表示什么数据。 因此标识符的命名， 在遵循命名规则的同时， 还需要遵循一些命名的规范。

标识符的命名规范， 首先需要遵循 望文知意， 即一个标识符的命名， 应该一眼能够看出来想表示什么含义。 例如:

name： 表示姓名
age: 表示年龄
gender: 表示性别

但是， 在遵循了望文知意的基础上， 有些标识符的命名会比较长。 例如:

ageofperson: 人的年龄
countofstudent: 学生的数量

这样的标识符， 可读性也不高， 因为无法很快的分隔开每一个单词。 所以， 在此基础上， 还需要在遵循驼峰命名法

• 大驼峰命名法： 每一个单词的首字母都大写。
• 小驼峰命名法： 首单词除外， 从第二个单词开始， 每个单词的首字母都大写。

大驼峰命名法: AgeOfPerson、CountOfStudent
小驼峰命名法: ageOfPerson、countOfStudent

 

备注:
后续的课程中， 如果没有特殊说明， 默认使用小驼峰命名法。

2.3. 变量、常量

2.3.1. 概念

在程序中， 使用标识符表示程序中的某个数据。

• 如果某个数据在程序运行的过程中， 值是可以改变的， 这样的数据被称为是变量。
• 如果某个数据在程序运行的过程中， 值是不可以改变的， 这样的数据被称为是常量。

例如:
一个人的年龄、身高、体重， 都是可以发生改变的， 因此这样的数据， 常用变量表示。
一个人的出生日期、身份证号码， 是不可以发生改变的， 因此这样的数据， 常用常量表示。

2.3.2. 定义

变量的定义， 遵循最基础的语法: 数据类型 标识符;

/**
 * @Description Java变量的定义
 */
public class JavaSyntax {
   public static void main (String[] args) {
       // 1. 定义一个变量
       int age;
       // 2. 定义多个相同类型的变量
       int height, weight;
       // 3. 定义一个变量， 并赋初始值
       int score=100;
       // 4. 定义多个变量， 同时给某些变量赋初始值
       int chineseScore=99, mathScore=100, englishScore;
  }
}

常量的定义， 需要使用到关键字final

/**
 * @Description Java常量的定义
 */
public class JavaSyntax{
   public static void main (String[] args) {
       // 1. 定义一个常量， 并赋初始值
       final int birthYear = 2000;
       // 2. 定义一个常量， 不赋初始值
       final int birthMonth;
       //   给一个常量赋初始值
       birthMonth = 7;
       // 注意： 这里给一个常量赋值的时候， 一旦有初始值了， 就不能再进行其他的赋值操作了
       // birthMonth = 7; // 即便此时赋的值和原来的值是相同的， 这里依然是有问题的
  }
}

2.3.3. 各种类型的变量的定义

/**
 * @Description Java各种数据类型的变量的定义
 */
public class JavaSyntax{
   public static void main (String[] args) {
       byte n1=10;
       short n2=10;
       int n3=10;
       long n4=10;
       // 浮点数字默认的类型推导是double类型， 如果需要给float变量赋值， 需要在最后添加一个f
       float n5=3.14f;
       double n6=3.14;
       char n7='a';
       boolean n8=true;
  }
}

2.3.4. 注意事项

局部变量或者局部常量， 在使用的时候一定要有值。 如果某一个局部变量或者局部常量没有值， 这个变量或者常量将无法使用。

局部变量: 定义在某一个局部代码段中的变量， 例如定一个方法中的变量。

/**
 * @Description Java变量的使用
 */
public class JavaSyntax{
   public static void main (String[] args) {
       // 1. 定义一个变量， 不赋初始值
       int age;
       // 2. 使用这个变量的值
       System.out.println (age);// 这里有问题， 因为age没有值
  }
}

2.4. 转义字符

2.4.1. 概念

在一个字符中， 单引号表示一个字符的开始和结尾。 在单引号中， 可以写任意的字符， 但是不能是单引号。 因为单引号是有特殊含义的， 用来匹配字符的开始和结尾。 如果此时， 如果要表示单引号， 就需要使用到转义字符了。

转义字符， 是一个特殊的字符 \， 有两层含义:

• 将某一个具有特殊含义的字符变成普通字符， 没有特殊的含义。
• 将某些普通字符变成具有特殊含义的字符。

2.4.2. 使用

/**
 * @Description Java转义字符的使用
 */
public class JavaSyntax{
   public static void main (String[] args) {
       // 1. 将特殊字符转义， 变成普通字符
       char c1='\'';
       char c2='\\';
       
       // 2. 将某些普通字符， 变成特殊字符
       char c3='\n';// 换行符
       char c4='\r';// 回车符
       char c5='\t';// 制表符
  }
}

2.5. 数据类型转换

2.5.1. 类型转换的概念

一个变量声明完成后, 在内存中已经开辟好了空间, 此时是不允许调整空间大小的, 也就是说这个变量的数据类型是不允许改变的。这里说的数据类型转换, 指的是声明一个新的指定类型的变量, 将原来变量中的值拷贝到新的变量中。

4.5.2. 类型转换的分类

数据类型转换可以分为两种:

• 自动类型转换
  • 又叫做隐式转换, 一般是由取值范围小的数据类型, 向取值范围大的数据类型转换
  • 转换过程不需要任何额外操作
  • 转换后, 没有任何精度丢失情况
• 强制类型转换
  • 又叫做显式转换, 一般是由取值范围大的数据类型, 向取值范围小的数据类型转换
  • 转换过程需要强制操作, 不能自动完成
  • 转换后, 可能会出现精度丢失的情况

2.5.3. 示例代码

/**
 * @Description 数据类型转换
 */
public class JavaSyntax{
   public static void main (String[] args) {
byte a=10;
int b=a;// 由 byte 类型转型为 int 类型, 自动完成, 不需要任何额外操作

int c=128;
byte d=(byte)c;// 由 int 类型转型为 byte 类型, 强制操作, 会存在精度丢失
  }
}

2.5.4. 特殊说明

• byte, short, char 类型的数据在进行运算的时候, 会自动的转型为int类型
• 浮点型转整型, 会舍去小数点后面所有的内容, 只保留整数部分

2.6. 常用运算符

2.6.1. 算术运算符

2.6.1.1. 运算符分类

2.6.1.2. 特殊说明

• + - * % 和数学计算中没有区别
• 两个整型的数据进行除法, 结果还是整型, 会将计算的浮点结果强转成整型
• 自增运算符++, 用在变量前, 表示是前取变量值, 后对这个变量进行+1操作
• 自增运算符++, 用在变量后, 表示是先对这个变量进行+1操作, 然后再取变量值
• 自减同自增

2.6.1.3. 示例代码

/**
 * @Description 算术运算符
 */
public class JavaSyntax{
   public static void main(String[] args) {
       int x=10, y=3;
       System.out.println (x+y);// 13
       System.out.println (x-y);// 7
       System.out.println (x*y);// 30
       System.out.println (x/y);// 3
       System.out.println (x%y);// 1
       
       System.out.println (x++);// 10
       System.out.println (x);    // 11 
       System.out.println (++y);// 4
       System.out.println (y);// 4
  }
}

2.6.2. 赋值运算符

2.6.2.1. 运算符分类

2.6.2.2. 特殊说明

赋值运算，也是有运算结果的。 赋值运算的结果就是赋值完成后的变量的值。

2.6.2.3. 示例代码

/**
 * @Description 赋值运算符
 */
public class JavaSyntax {
   public static void main (String[] args) {
       int x;
       System.out.println (x=10);// 10x = 10
       System.out.println (x+=10);// 20x = x + 10
       System.out.println (x-=10);// 10x = x - 10
       System.out.println (x*=10);// 100x = x * 10
       System.out.println (x/=10);// 10x = x / 10
       System.out.println (x%=3);// 1x = x % 10
  }
}

2.6.3. 关系运算符

2.6.3.1. 运算符分类

2.6.3.2. 示例代码

/**
 * @Description 关系运算符
 */
public class JavaSyntax{
   public static void main (String[] args) {
       int a=10, b=9;
       System.out.println (a>b);// true
       System.out.println (a<b);// false
       System.out.println (a==b);// false
       System.out.println (a!=b);// true
       System.out.println (a>=b);// true
       System.out.println (a<=b);// false
  }
}

2.6.4. 逻辑运算符

2.6.4.1. 运算符分类

2.6.4.2. 示例代码

/**
 * @Description 逻辑运算符
 */public class JavaSyntax{
   public static void main (String[] args) {
       boolean a=true, b=false;
       System.out.println (a&b);// false
       System.out.println (a|b);// true
       System.out.println (!b);   // true
       System.out.println (a^b);// true
       System.out.println (a&&b);// false
       System.out.println (a||b);// true
  }
}

2.6.5. 位运算符

2.6.5.1. 运算符分类

位运算符， 只能作用于两个整型的变量。 将两个整型变量计算出补码， 然后对每一位的数字， 进行类似于逻辑运算的操作。 1相当于true， 0相当于false。

2.6.5.2. 示例代码

/**
 * @Description 位运算符
 */
public class JavaSyntax{
   public static void main (String[] args) {
       int a=10, b=-8;
       // a的补码: 0000 1010
       // b的补码: 1111 1000
       System.out.println (a&b);// 0000 1000
       System.out.println (a|b);// 1111 1010
       System.out.println (a^b);// 1111 0010
       System.out.println (~a);  // 1111 0101
       System.out.println (a<<2);// 0010 1000
       System.out.println (b>>2);// 1111 1110
       System.out.println (b>>>2);// 0011 1110
  }
}

 

2.6.4. 三目运算符

2.6.4.1. 三目运算符描述

?:

三目运算符， 是一个带有点逻辑的运算符， 基础语法如下：

布尔结果表达式/布尔变量 ? 值1 ： 值2
如果问号前面的布尔值为true， 整体的结果为值1。 否则整体的结果为值2。

2.6.4.2. 示例代码

/**
 * @Description 三目运算符
 */
public class JavaSyntax{
   public static void main (String[] args) {
       int a=10, b=20;
       int max=a>b?a: b;// 逻辑: 计算变量a和b的最大值
       System.out.println (max);
  }
}

 

2.6.3. 运算符的优先级

2.6.4.1. 运算符的分类

按照运算符可以操作的数据的数量， 可以将运算符分为: 一元运算符、二元运算符、三元运算符

一元运算符: 只能操作一个数据，例如: + - ++ -- ! ~

二元运算符: 可以操作两个数据，例如: + - * /

三元运算符: 可以操作三个数据， 只有一个， 即三目运算符

2.6.4.2. 优先级

• 整体来看， 一元运算符 > 二元运算符 > 三元运算符
• 赋值运算符的优先级最低
• 算术运算中: 乘、除、模 > 加、减
• 逻辑运算符中: 与 > 或、异或
• 小括号的优先级最高