黑马程序员_03. java语言的基本组成

三、黑马程序员_java语言的基本组成（详解）

--------  android培训、 java培训、期待与你交流 --------

在java语言中由以下部分组成：
A.注释； B.关键字； C.标识符；D.常量； E.变量； F.运算符； G.语句； H.函数； I.数组

A.注释概述及其分类
a:什么是注释
在源文件中用于解释说明程序的文字，就是给我们的代码加上注解,也可以用来帮助我们调试程序。
b:注释的分类
(1): 单行注释  格式： // 注释的文字
(2): 多行注释  格式： /* 注释的文字 */
(3): 文档注释  格式： /** 注释的文字 */
注意：单行注释里不能嵌套多行注释，但是可以有单行注释，多行注释中可以有单行注释，多行注释中不可以有多行注释。

B.java中的关键字
a:什么是关键字
就是被java语言赋予特殊含义的单词。
b:关键字的特点
组成关键的字母都是小写
c:常见关键字
abstract interface final class static ..... 

C.标识符
标识符就是给类,接口,方法,变量等起名字时使用的字符序列。
(1).标识符的组成规则
由英文的大小写字母、数字、$和_组成。不能以数字开头、不能是java中的关键字、严重区分大小写。

(2).标识符中常见的命名规则
a:包(就是文件夹，它的存在是为了解决我们同一个目录下不能同时存在两个相同名称的文件。)
字母都是小写
单级包：  itcast
多级包：  cn.itcast
b:类或者接口
一个单词： 首字母大写，其余字母小写 如： Student,Person,Animal等。
多个单词： 每一个单词的首字母都是大写，其余字母小写 如： TestDemo,OutputStream,RuntimeException等。
c:方法或者变量
一个单词：  字母全是小写   name ， age
多个单词：   从第二个单词开始，首字母大写，其余字母小写  getName ， getAge
d:常量
一个单词：   字母全是大写 如： NUM,PI等。
多个单词：   字母全是大写，每一个单词之间使用 _ 隔开 如： MAX_VALUE

D.常量
常量就是在程序的执行过程中其值不发生改变的量。

a:Java中常量的分类
(1): 字符串常量 用双引号括起来的内容 "HelloWorld" ,"Hello"
(2): 整数常量 所有整数 12,23
(3): 小数常量 所有小数 12.34,56.78
(4): 字符常量 用单引号括起来的内容   'a','A','0'  (注意事项：单引号中只能是单个字母，单个数字，单个符号)
(5): 布尔常量 较为特有，只有true和false
(6): 空常量 只有一个值，那就是null.

b:Java针对整数常量提供了4种表现形式
(1):二进制
(2):八进制
(3):十进制
(4):十六进制

1:进制
是人们规定的一种进位方法。 对于任何一种进制--X进制，就表示某一位置上的数运算时是逢X进一位。
二进制就是逢二进一，八进制是逢八进一，十进制是逢十进一，十六进制是逢十六进一(进制越大，表现形式越短)。

(1).二进制的数据表现形式
由0,1组成。 以0b开头(1.7版本开始的，b可大写)
(2).八进制的数据表现形式
由0,1,…7组成。 以0开头
(3).十进制的数据表现形式
由0,1,…9组成。 整数默认是十进制的
(4).十六进制的数据表现形式
由0,1,…9,a,b,c,d,e,f(大小写均可)。 以0x开头(x可大写).

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

E.变量
在程序执行的过程中，在某个范围内其值可以发生改变的量(例如：苹果的价钱)
理解： 就相当与数学中的未知数
变量其实是内存中的一小块区域
(1).为什么要定义变量

用来不断的存放同一类型的常量，并可以重复使用

(2).变量的定义格式

数据类型 变量名 = 变量值 ；

(3)数据类型
a.为什么有数据类型
我们都知道，变量其实就是内存中的一小块区域。我们定义一个变量，其实就是开辟了一个内存空间。如果没有数据类型，那么我们需要开辟多大的内存空间合适呢？为了解决这种问题，java就给我们提供了不同的数据类型，那么针对不同的数据类型，在内存中分配了不同大小的内存空间。
b:Java中数据类型的分类
(1): 基本数据类型
(2): 引用数据类型： 数组 ， 类 ， 接口
c:基本数据类型的详细讲解
(1): 数值型
整数型 字节数 范围
 byte 1(8bit)       -128  ~  127
 short 2(16bit)   -2^15 ~  2^15 - 1
 int 4(32bit)      -2^31 ~  2^31 - 1
 long 8(64bit)      -2^63 ~  2^63 - 1
浮点数
float       4(32bit)      -3.403*10^38  ~ 3.403*10^38
double      8(64bit)   -1.798*10^308 ~ 1.798*10^308
(2): 字符型   char        2(16bit)   0 ~ 2^16 - 1 = 65535
(3): 布尔型   boolean     1


d.注意事项：
(1):整数默认是int类型的 ， 浮点数默认是 double类型的.

(2):作用域问题
变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量。
(3):初始化值问题
没有初始化值不能直接使用
(4):在一行上建议只定义一个变量
可以定义多个，但是不建议

e.数据类型的提升
(1):小的数据类型向大的数据类型转换叫数据类弄的提升;
(2):boolean类型不能转换为其他的数据类型;
(3):byte,short,char相互之间不转换，他们参与运算首先转换为int类型.

f.数据类型的强制转换
(1):强制转换的格式
目标数据类型 变量名=(目标数据类型)(被转换的数据);
如:
byte by1=10;
byte by = (byte)(by1+1);
(2)强制转换的注意事项
尽量不要使用强制类型转化，因为可能存在损失精度的问题。

(3):Java语言中的字符char可以存储一个中文汉字吗?为什么呢?
可以。因为Java语言采用的是Unicode编码。Unicode编码中的每个字符占用两个字节。所以，Java中的字符可以存储一个中文汉字

(4).字符和字符串参与运算
int i = 'a'+1;
System.out.println(i);
输出结果为98，说明字符a向int类型提升了，取出了自已对应的字符编码。

(5).字符串与基本数据类型参与运算
System.out.println("hello" + 'a' + 1 + true);
输出结果为：helloa1true,说明字符串与其它基本数据类型参与运算时，最终都会变成字符串。

F.运算符
是对常量和变量进行操作的符号称为运算符。

(1)算术运算符：
如：+ , - , * , / , % , ++ , -- 
++:自加。对原有的数据进行+1,放在操作数的前面和后面效果一样。
--:自减。对原有的数据进行-1,放在操作数的前面和后面效果一样。
注意事项：整数相除只能得到整数。如果想得到小数，请使用浮点数; /获取的是除法操作的商，%获取的是除法操作的余数 ；%运算结果的符号，取决于参与运算是左边的符号。

(2)赋值运算符
如：=， +=,-=,*=,/=,%=
把=右边的数据赋值给左边。

(3)比较运算符
如：== ,!= , < , > , <= , >= , instanceof(判断某一个对像是否是某一个类型)。
"=="不能写成"=";
用于参与比较，如果为真返回true，假则为false.

(4)逻辑运算符
如：& | ^ ! && ||
&:左右两边都参与运算；&&：如果左边为假则右边不参与运算了。
｜:左右两边都参与运算； ｜｜：如果左边为真，则右边不参与运算。
逻辑运算符一般用于连接boolean类型的表达式或者值。比如： 8<12<19要与成：12>8 & 12<19.

(5)位运算符
如：>> << >>> & | ^ ~
>>:被移的二进制最高位是0，空缺位则补0，是1则补1；
<<:被移除的最高位丢弃，空位补0；
>>>:二进制的最高位无论是0或1，最高位都补0；

(6)三元运算符
格式：(条件表达式)?表达式1：表达式2;
如果条件表达式为true, 运算后的结果是表达式1，否则为表达式2.

G.语句
在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。
也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程。
而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能

(1)：顺序结构
是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：写在前面的先执行，写在后面的后执行,从上往下，依次执行。

(2)选择结构--if语句
选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
a. if语句的格式1
if(比较表达式) {
语句体;
}
执行流程：先计算比较表达式的值，看其返回值是true还是false。如果是true，就执行语句体；如果是false，就不执行语句体.

b. if语句的格式2
if(比较表达式) {
语句体1;
}else {
语句体2;
}
执行流程：首先计算比较表达式的值，看其返回值是true还是false。如果是true，就执行语句体1；如果是false，就执行语句体2.
注意：else后面是没有比较表达式的，只有if后面有。

c. if语句的格式3：
if(比较表达式1) {
语句体1;
}else if(比较表达式2) {
语句体2;
}else if(比较表达式3) {
语句体3;
}
...
else {
语句体n+1;
}
执行流程：首先计算比较表达式1看其返回值是true还是false，如果是true，就执行语句体1，if语句结束。如果是false，接着计算比较表达式2看其返回值是true还是false，
如果是true，就执行语句体2，if语句结束。如果是false，接着计算比较表达式3看其返回值是true还是false，
...
如果都是false，就执行语句体n+1。
注意： 当只要有一个条件满足时，if语句结束。else是可以省略，但是不建议省略。


d. 问：if语句和三元的有什么区别呢？
答：首先，三元运算符是if else 语句的一种简写格式，是用来简化代码的；三元运算符运算后一定要有结果，而if else 语句运算完后可以没有结果。
三元运算符实现的，都可以采用if语句实现，反之不成立。

(3)选择结构--switch语句
a. switch语句的格式
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
case 值3:
语句体3;
break;
....
default：
语句体n+1;
break;
}
b. switch语句的格式解释
(1):switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举(什么是枚举，以后再讲)
JDK7以后可以是String
(2):case后面跟的是要和表达式进行比较的值
(3):语句体部分可以是一条或多条语句
(4):break表示中断，结束的意思，可以结束switch语句


执行流程:先计算表达式的值,然后和case后面的匹配，如果匹配成功就执行对应的语句，遇到break就会结束,否则执行default控制的语句。

c. switch语句的注意事项：
a:case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
b:default可以省略吗?
可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
c:break可以省略吗?
可以省略，但是结果可能不是我们想要的。
会出现一个现象：case穿透。
最终我们建议不要省略
d:default一定要在最后吗?
不是，可以在任意位置。但是建议在最后。
e:switch语句的结束条件
a:遇到break就结束了
b:执行到末尾就结束了

d. 问：选择结构if语句和swtich语句的什么区别呢？
答：if和switch语句很像。如果判断的具体数值不多，而是符合byte short int char这四种类型。虽然两个语句都可以使用，建议使用switch语句。因为效率稍高。
  if除了可以判断具体的数值以外，还可以判断boolean的值进行判断，对区间进行判断。而switch只可以判断具体的值，而对于区间的判断会很费劲。if的使用范围更广。

(4)循环结构
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

a. 循环结构的分类
(1). for循环;
(2). while循环;

b. for循环结构
(1).格式：
for(初始化表达式语句;判断条件语句;控制条件语句) {
循环体语句;

(2).执行流程：
a:执行初始化语句(初始化表达式语句只执行一次);
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到B继续。
(3).注意事项
a:判断条件语句无论简单还是复杂结果是boolean类型。
b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
c:一般来说：有左大括号就没有分号，有分号就没有左大括号

c. while循环结构
(1).基本格式：
while(判断条件语句) {
循环体语句;
}
(2).完整格式：
  初始化表达式语句;
   while(判断条件语句) {
循环体语句;
控制条件语句;
}
(3).执行流程：
a:执行 初始化表达式语句;
b:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
c:执行循环体语句;
d:执行控制条件语句
e:回到b继续。

(4).do...while语句的格式：

do {
循环体语句;
控制条件语句;
}while(判断条件语句);

(5).执行流程：
a:执行 初始化表达式语句;
b:执行循环体语句;
c:执行控制条件语句;
d:执行判断条件语句,看其返回值是true还是false
如果是true，就继续执行
如果是false，就结束循环
e:回到b继续。

(6).三种循环语句的区别:
(1). do...while循环至少执行一次循环体。
而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。
(2). a： 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用for循环。
因为变量及早的从内存中消失，可以提高内存的使用效率。
b:建议优先考虑for循环，然后是while循环 ，最后是do...while循环

注意：一定要控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
(7).两种最简单的死循环格式
a. while(true){...}
b. for(;;){...}

(8).控制跳转语句
a.概述：
比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情。为了弥补这个缺陷，Java就提供了break，continue和return来实现控制语句的跳转和中断。
b.控制跳转语句的分类 
break 中断
continue 继续
return 返回 
c.break的使用场景
(1):在选择结构switch语句中
(2):在循环语句中
注意：离开使用场景的存在是没有意义的
d.作用
(1):退出单层循环
(2)退出多层循环(几乎不使用)
要想实现这个效果，就必须知道一个东西;带标签的语句；
格式：标签名：语句
e.continue的使用场景
(1):在循环语句中
(2):离开使用场景的存在是没有意义的
作用:跳出一次循环，执行下一步操作.
f.return的作用
return 就是退出一个方法。
跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。

H.函数
(1).方法的描述：方法就是完成特定功能的代码块，在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
(2).方法的格式
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
方法体;
return 返回值;
}
(3).方法的格式
(1): 修饰符 比较多,后面会详细介绍。目前使用  public static
(2): 返回值类型 用于限定返回值的数据类型
(3): 方法名 就是一个名称，它的存在是为了方便我们调用方法
(4): 参数类型 限定调用方法时传入参数的数据类型
(5): 参数名 是一个变量，接收调用方法时传入的参数
这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
(6): 方法体 完成功能的代码
(7): return 结束方法以及返回方法指定类型的值 
(8): 返回值 就是功能的结果，由return带回，带回给调用者


(4).如何写一个方法
(1):返回值类型: 明确功能结果的数据类型
(2):参数列表: 你要传递几个参数，以及每一个参数的数据类型

(5).方法调用(有明确返回值的调用)
a:单独调用,一般来说没有意义，所以不推荐。
b:赋值调用,推荐方案。
c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作。

(6).要注意事项
a.方法不调用不执行
b.方法与方法是平级关系，不能嵌套定义
c.方法定义的时候参数之间用逗号隔开
d.方法调用的时候不用在传递数据类型

(7).方法重载概述
在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
参数列表不同是指，可以是参数个数不同或参数类型不同。


I.数组
(1):数组概述
数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器，数组既可以存储基本数据类型，也可以存储引用数据类型。

(2):数组定义格式
格式1： 数据类型[] 数组名；
格式2： 数据类型   数组名[];
例如：
int[] a； 定义了一个int类型的数组a；
int a[]; 定义了一个int类型的a数组；
推荐使用第一种定义方式。

(3):数组的初始化
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

(4):数组的初始化的分类
a:动态初始化的格式：
数据类型[] 数组名 = new 数据类型[数组长度];
如： int[] arr = new int[3]; 定义了一个int类型的数组arr，这个数组可以存放3个int类型的值。

b:静态初始化的格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例： int[] arr = new int[]{1,2,3};

简化格式：
数据类型[] 数组名 = {元素1,元素2,…};
举例： int[] arr = {1,2,3}; 在定义的arr数组中存放了3个int类型的值。
数组长度：数组长度其实就是数组中元素的个数。

(5)java中的内存分类
a:栈: 存放的是局部变量
局部变量：在方法定义中或者方法声明上的变量都是局部变量。
b:堆: 存放的是所有new出来的东西
特点：
a: 每一个new出来的东西都会为其分配一个地制值。
b: 每一个变量都有一个默认的值
byte，short，int，long  -- 0
float，double   -- 0.0
char   -- '\u0000'
boolean   -- false
引用数据类型   -- null
c: 使用完毕就变成了垃圾，等待垃圾回收器对其回收
c:方法区:加载字节码，里面又分为静态方法区和非静态方法区。
d:本地方法区:和系统相关
e:寄存器:(cpu使用)
(6):二维数组
a.概述：
其实二维数组其实就是每一个元素为一维数组的数组。

b:二维数组格式1
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组有多少个一维数组
n表示每一个一维数组的元素个数
举例:
int[][] arr = new int[3][2];
定义了一个二维数组arr
这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
每个一维数组有2个元素，可以通过arr[m][n]来获取
表示获取第m+1个一维数组的第n+1个元素
c:注意事项
(1):以下格式也可以表示二维数组
a:数据类型 数组名[][] = new 数据类型[m][n];
b:数据类型[] 数组名[] = new 数据类型[m][n];
这两种格式不推荐使用
(2):注意下面定义的区别
int x,y;
int[] x,y[];

d:二维数组格式2
数据类型[][] 变量名 = new 数据类型[m][];
m表示这个二维数组有多少个一维数组
这一次没有直接给出一维数组的元素个数，可以动态的给出。
举例：
int[][] arr = new int[3][];
arr[0] = new int[2] ;
arr[1] = new int[3];
arr[2] = new int[1];

e:二维数组格式3
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}...};
简化版:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
这个格式属于静态初始化:由我们指定具体的元素值,由系统给分配长度
举例: 
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr = {{1,2,3},{5,6},{7}};