黑马程序员_Java基础组成

Java语言基础组成

2.1关键字

main不是关键字，但被JVM所识别的名称。

关键字的定义和特点
定义：被Java语言赋予了特殊含义的单词。 特点：关键字中所有字母都为小写。
用于定义数据类型的关键字
class	interface	byte	short	int
long	float	double	char	boolean
void
用于定义数据类型值的关键字
ture	false	null
用于定义流程控制的关键字
if	else	switch	case	default
while	do	for	break	continue
return

用于定义访问权限修饰符的关键字
private	protected	public
用于定义类，函数，变量修饰符的关键字
abstract	final	static	synchronized
用于定义类与类之间的关键字
extends	implement
用于定义建立实例及引用实例，判断实例的关键字
new	this	super	instance of
用于异常处理的关键字
try	catch	finally	throw	throws
用于包的关键字
package	import
其他修饰符关键字
native	strictfp	transient	volatilo	assert

2.2标识符

• 在程序中自定义的一些名称
• 由26个英文字母大小写，数字：0-9，符号：“$” “_”  组成。
• 定义合法标识符规则：1，数字不可以开头  2，不可以使用关键字。
• Java中严格区分大小写
• 注意：在起名字时，为了提高阅读性，要尽量有意义。

Java中的名称规范：

• • 包名：多单词组成时所有字母都小写。xxxyyyzzz
  • 类名接口名：多单词组成时，所有字母的首字母大写。XxxYyyZzz
  • 变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单子首字母大写。xxxYyyZzz
  • 常量名：所有字母都大写。多单词时每个单词用下划线连接。XXX_YYY_ZZZ

2.3注释

• 用于注解说明解释程序的文字就是注释。
• 提高了代码的阅读性。
• Java中的注释格式：

1)单行注释　　格式：//注释文字

2）多行注释　　格式：/*  注释文字  */

3）文档注释　　格式：/**  注释文字  */

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

 /**
 这是我的Hello World程序。
 @author 小强
 */
 class Demo
 {
      /*
     这是主函数，程序的入口。
     他的出现可以保证程序的独立运行。
      */
     public static void main(String[] args)
     {
            //这是输出语句用于将括号内的数据打印到控制台。
            System.out.println("Hello World")
      }

18 }

2.4常亮和变量

1）常量

• 常量表示不能改变的数值。
• Java中常量的分类：

1. 整数常量，所有整数。
2. 小数常量，所有小数。
3. 布尔型常量，所有小数。
4. 字节常量。将一个数字字母或者符号用单引号（‘’）标识。（单引号里只能放一个字符！）
5. 字符串常量。将一个或者多个字符用双引号（“”）标识。
6. null常量。只有一个数值就是null。（对象，引用数据类型）

• 对于整数：Java有四种表现形式。进制越大，表现形式越短。

1. 十进制：0-9，满10进1。
2. 八进制：0-7，满8进1，用0开头表示。
3. 十六进制：0-9.A-F，满16进1，用Ox开头表示。
4. 二进制：0和1，满2进1。

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

由八个开关来表示一个最小的单位，叫字节。即八个二进制代表一个字节。

ascii编码表：用0和1不同的排列组合把生活中数据一一对应的表现出来。

进制转换：

十进制--->二进制　　原理：对十进制数进行除2运算。

二进制--->十进制　　原理：二进制乘以2的n次幂的过程。（从右开始乘）

十进制--->十六进制　　原理：四个二进制位代表一个十六进制位。

十进制--->八进制　　原理：三个二进制位代表一个八进制位。

2的	8	7	6	5	4	3	2	1次幂
	128	64	32	16	8	4	2	1	=255（1字节）

负数的二进制表现形式：正数二进制取反加1.

取反：将二进制的1变成0,0变成1。

负数的二进制最高位都是1，正数的最高位为0。

2）变量

• 变量的概念：
  • 内存中的一个存储区域
  • 该区域有自己的名称（变量名）和类型（数据类型）。
  • 给区域的数据可以在同一类型范围内不断变化。
• 为什么要定义变量：
  • 用来不断地存放同一类型的常量，并可以重复使用。（就是将不确定的数据进行存储。）
• 使用变量注意：
  • 变量的作用范围（一对{}中有效）
  • 初始化值
• 定义变量的格式：
  • 数据类型    变量名=初始化值;
  • 注：格式是固定的，记住格式，以不变应万变。　　
• 理解：变量就如同数学中的未知数。
• 通过明确数据类型，变量名称，数据来完成。
• Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间。

数据类型	基本数据类型(3)	数值型	整数类型：	byte（1）	short（2）	int（4）	long（8）
				字节 （-128~127）	短整型（-32768~32767）	整型	长整型
			浮点型(小数)：	float（4）	double（8）
				单精度	双精度
		字符型	char（2）	0~6535
		布尔型	boolean	true/false
	引用数据类型
		类：	class
		接口：	interface
		数组：	[]

整数默认：int     小数默认：double

long  l=4l      float  f=2.3f

• 自动类型转换（也叫隐式类型转换）
• 强制类型转换（也叫显式类型转换）
• 类型转换的原理
• 什么时候要用强制类型转换？
• 表达式的数据类型自动提升
  • 所有的byte型，short型和char的值将被提升到int型
  • 如果一个操作数是long型，计算结果就是long型。
  • 如果一个操作数是float型，计算结果就是float型。
  • 如果一个操作数是double型，计算结果就是double型。
• 分析：System.out.println('a')与System.out.println('a'+1)的区别。
  • char类型也可以进行运算，因为字符在ASCII编码表里面都有对应的数字。
  • 所有的计算机都支持ASCII编码表。

2.5运算符

• 算术运算符

运算符	运算	范例	结果
+	正号	+3	3
-	负号	b=4，-b	-3
+	加	5+5	10
-	减	6-4	2
*	乘	3*4	12
/	除	5/5	1
%	取模	5%5	0
++	自增（前）	a-2,b=++a	a=3,b=3
++	自增（后）	a=2,b=a++	a=3,b=2
--	自减（前）	a=2,b=--a	a=1,b=1
--	自减（后）	a=2,b=a--	a=1,b=2
+	字符串相加	“He”+"llo"	"Hello"

知识点：

1. 取模“%”：取余数。
2. 左边小于右边，结果是左边。例：1%5
3. 左边等于右边，结果是0。
4. 右边等于1，结果是0。
5. 取模时，负数只看左边被模数，右边正负都不管。例：1%-5  结果1      -1%5  结果-1
6. 字符串连接符“+”：字符串数据和任何数据使用+都是相连接，最终都变成字符串。例：“5+5=”+5+5  结果“5+5=55”
7. 打印时，输出结果要直观有意义，用+连接起来。把固定的用双引号引起来，不固定的变量用+想连接。如：“a="+a+",b="+b

转义字符：通过\来转变后面字母或者符号的含义。

1. \n：换行。
2. \b：退格。相当于backspace。
3. \r：按下回车键。windows中，回车符是由两个字符来表示\r,\n
4. \t：制表符。相当于tab键。
5. println:"ln":在结尾处换行。
6. 转义字符要写在被转义符号的前面。如：”\“hello\”“

• 赋值运算符

  • 符号：=  +=  -=  *=  /=  %=
  • 示例：int a,b,c; a=b=c=3;  int a=3;a+=5,等同运算a=a+5
  • 思考：short s=3; s=s+2   s+=2  有什么区别？
  • s=s+2:编译失败，因为s会被提升为int类型，运算后的结果还是int类型。无法赋值给short类型。
  • s+=2：编译通过，因为+=运算符在给s赋值时，自动完成了强转操作。

• 比较运算符

运算符	运算	范例	结果
==	相等于	4==3	false
！=	不等于	4!=3	true
<	小于	4<3	false
>	大于	4>3	true
<=	小于等于	4<=3	false
>=	大于等于	4<=3	false
instance of	检查是否是类的对象	”Hello“instance of string	true

注意：

1. 比较运算符的结果都是boolean型，即true/false.
2. 比较运算符”==“不能误写成”=“。

• 逻辑运算符:用于连接boolean类型的表达式。

运算符	运算	范例	结果
&	AND(与)	false&true	false
|	OR（或）	false|true	true
^	XOR(异或)	true^fales	true
!	Not（非）	!true	false
&&	AND（短路）	false&&true	false
||	OR(短路)	false||true	true

&：只要两边的boolean表达式结果，有一个为false,那么结果为false。只有两边都为true，结果为true。(有假它就假，主要看false)

true&true=true

true&false=false

false&true=false

false&true=false

|：两边只要有一个为true，结果为true。只有两边都有false,结果为false.（有真它就真,主要看true）

true|true=true

true|false=true

false|true=true

false|false=false

^异或：就是和|有点不一样，当true^true=false

^:两边相同结果是false,两边不同结果是true。

true^true=false

true^false=true

false^true=true

false^false=false

"！"：！true  非真。

&和&&的特点：

&：无论左边是true是false,右边都运算。

&&：当左边为false时，右边不运算。（效率更高）

|和||的特点：

|：两边都参与运算。

||：当左边为true,右边不运算。

• 位运算符

位（二进制）运算符
运算符	运算	范例
<<	左移	3<<2=12——>3*2*2=12
>>	右移	3>>1=1——>3/2=1
>>>	无符号右移	3>>>1=1——>3/2=1
&	与运算	6&3=2
|	或运算	6|3=7
^	异或运算	6^3=5
~	反码	~6=-7

• • <<:其实就是乘以2的移动的位数次幂。
  • >>：就是除以2的移动的位数次幂。

细节：

• • 位运算是直接对二进制进行运算。（此时0视为假，1视为真）
  • >>：最高位补什么有原有数据的最高位而定，最高位为0，右移后用0补空位，最高位为1，右移后用1补空位。
  • >>>：无论最高位是什么，右移后都用0补。
  • <<：空位补0，被移除的高位丢弃，空缺位补0。
  • &：二进制位进行&运算，只有1&1时结果是1，否则是0。
  • |：二进制进行|运算，只有0|0时结果是0，否则是1。
  • ^：任何相同二进制位进行^运算，结果是0,1^1=0,0^0=0. 不相同二进制位^运算结果是1,1^0=1,0^1=1　
  • 反码“~”：取反的意思。
  • 注意：一个数异或同一个数两次，结果还是那个数。相当于加密，然后再解密。

位运算练习：

1、最有效率的方式算出2乘以8等于几？  2<<3（8相当于2³，乘以就是向左移3位）

2、对两个整数变量的值进行互换（不需要第三方变量）

int n=3,m=8

（1）通过第三方变量：

 int n=3,m=8
 //1,通过第三方变量
 int temp;
 temp=n;
 n=m;
 m=-temp;
 //2,不用第三方变量(求和的方式)
 n=m+n;//11=3+8  如果n和m的值非常大，容易超出int 范围，损伤精度。
 m=n-m;//3=11-8
 n=n-m;//8=11-3
 //3,异或的方式
 n=n^m;
 m=n^m;//即m=(n^m)^m
 n=n^m;//即n=n^(n^m)

 class OperateDemo3
 {
     public.static.void.main(String[] args)
     {
         int num=60;
         //获取60的最低4位，通过&15
         int n1=num&15//=12;
         System.out.println(n1>9?(char)(n1-10+'A'):n1);//得到67，不是字符，后期会学到！
         //要获取下一组四位，将60右移4位
         int temp=60>>>4;//>>>:目的要把原有数值移光
         //对temp的值进行最低四位的获取
         int n2=temp&15//=3;
         System.out.println(n2>9?(char)(n1-10+'A'):n2);
         //0-9 'A'   'B'   'C'   'D'   'E'   'F'
         //      10  11   12   13  14   15
     }
 }

• 三元运算符

  • 格式：（条件表达式）？表达式1：表达式2；
  • 如果条件为true,运算后的结果为表达式1，若条件为false,运算后的结果为表达式2.
  • 示例：获取两个数中的大数。
    • int x=3,y=4,z;
    • z=(x>y)?x:y;//z变量存储的就是两数中的大数。

2.6语句

• 2.6.1判断结构

1、if（条件表达式）

　　{

　　　　执行语句；

　　}

---

　　2、if（条件表达式）//if else结构简写格式：变量=（条件表达式）？表达式1：表达式2；

　　{　　　　　　　//三元运算符　　好处：可以简化if else代码。弊端：因为是一个运算符，所以运算完必须有一个结果。

　　　　执行语句；

　　}

　　else

　　{

　　　　执行语句；

　　}

---

3、if（条件表达式）

　　{

　　　　执行语句；

　　}

　　else if

　　{

　　　　执行语句；

　　}

　　……

　　else

　　{

　　　　执行语句；

　　}

---

• 2.6.2选择结构

switch 语句格式：

switch(表达式)

{

　　case 取值1：

　　　　执行语句；

　　　　break;

　　case 取值2：

　　　　执行语句；

　　　　break;

　　……

　　default：

　　　　执行语句；

　　　　break;

　　}

switch语句特点：

1. switch语句选择的类型只有4种：byte，short，int，char
2. case之间与default没有顺序。先执行第一个case,没有匹配的case 才执行default。
3. 结束switch语句的两种情况：遇到break。或者，执行到语句结束。
4. 如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运行可以执行的语句，直到遇到break或者switch结尾结束。

if和switch语句很像，

具体什么场景下，应用哪个语句呢？

1.如果判断的具体数值不多，而是符合byte，short，int，char，这四种类型。

虽然两个语句都可以使用，建议使用switch语句，效率稍高。

2.其他情况：对区间判断，对结果为Boolean类型判断，使用if，if的使用范围更广。

• 2.6.3循环结构

代表语句：while,do while,for

1）while语句格式：（先判断条件，只有条件满足才执行循环体）

while(条件表达式)

{

　　执行语句：

}

2）do while语句格式：（先执行循环体，再判断条件，条件满足，再执行循环体。）

简单一句：do while特点是条件无论是否满足，循环体至少被执行一次。

do

{

　　执行语句；

}

while(条件表达式)

3）for 格式：

for(初始化表达式；循环条件表达式；循环后的操作表达式)

{

　　执行语句；

}

注:1.for里面连个表达式运行的顺序，初始化表达式只读一次。判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复这个过程，直到条件不满足为止。

2.while和for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中释放，而while使用的变量在循环结束后海可以继续使用。

3.最简单无限循环格式：while(true),for（;;）【条件表达式默认为true】，无限循环存在的原因是并不知道循环多少次，而是根据某些条件来控制循环。

4.变量有自己的作用域。对于for来讲，如果将用于控制循环的增量，定义在for语句中。那么该变量只在for语句内有效。for语句执行完毕，该变量在内存中被释放。

5.for和while可以进行互换，如果需要定义循环增量，用for更为合适。

总结：什么时候使用循环结构？

当要对某些语句执行很多次时，就使用循环结构。

for语句练习（累加&计数器）

（1）累加思想：原理：通过变量记录住循环操作后的结果。通过循环的形式，进行累加的动作。

（2）计数器思想：通过一个变量记录住数据的状态变化，也许通过循环完成。

语句嵌套形式：语句中还有语句。

循环嵌套：循环中还有循环。（毕老师形象说法：大圈套小圈。）

System.out.println();　　　　//只有一个功能就是换行。

对于打印长方形：外循环控制行数。内循环控制的是每一行的列数。也就是一行中元素的个数。

不是规律的规律：图形尖朝上，可以改变条件。让条件随着外循环变化。

　　　　　　　　图形尖朝下，可以改变初始化值，让初始化值随着外循环变化。

九九乘法表：空格用\t(制表符)

• 2.6.4其他流程控制语句

　　break（跳出），continue（继续）

　　break语句应用范围：选择结构和循环结构。

　　continue语句：应用于循环结构。

注：

1. 1. 这两个语句离开应用范围，存在时没有意义的。
   2. 这两个语句单独存在下面都不可以有语句，因为执行不到。(重点)
   3. continue语句是结束本次循环继续下次循环。
   4. 标号的出现，可以让着两个语句作用于指定范围。（例：w:for　q:for   break w/continue w）

2.7函数

• 2.7.1函数的定义

  • 什么是函数？
    • 函数就是定义在类中的具有特定功能的一段独立小程序。函数也称方法。
  • 函数的格式：
    • 修饰符 返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，……）

{

　　　　执行语句；

　　　　return返回值；

}

• • 返回值类型：函数运行后的结果的数据类型。
  • 参数类型：是形式参数的数据类型。
  • 形式参数：是一个变量，用于储存调用函数时传递给函数的实际参数。
  • 实际参数：传递给形式参数的具体数值。
  • return：用于结束函数。
  • 返回值：该值会返回给调用者。

• 2.7.2函数的特点

  • 定义函数可以将功能代码进行封装。
  • 便于对该功能进行复用。
  • 函数只有被调用才会执行。
  • 函数的出现提高了代码的复用性。
  • 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。
  • 注意：函数中只能调用函数，不可以在函数内部定义函数。
  • 定义函数时，函数的结果应该返回给调用者处理。

• 2.7.3函数的应用

  • 如何定义一个函数呢？（两个明确）
    • 既然函数是一个独立的功能，呢么该功能的运算结果是什么要先明确。
    • 在明确定义该功能的过程中是否需要未知的内容参与运算。
  • 其实这两个功能就是在明确函数的定义
    • 是在明确函数的返回值类型
    • 明确函数的参数列表（参数的类型和参数的个数）
  • 示例：
    • 需求：定义一个功能，可以实现两个整数的加法运算。
    • 分析：
      • 该功能的运算结果是什么？两个数的和，也是一个整数（int）
      • 在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确定的。（两个参数int，int）
      • 代码：

int getSun(int x,int y)

{

　　return x+y;

}

• 2.7.4函数的重载

  • 重载的概念

　　　　　　在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数和参数类型不同即可。

• • 重载的特点

　　　　　　与返回值无关，只看参数列表。  注意参数是有顺序的。

• • 重载的好处

　　　　　　方便与阅读，优化了程序设计。

• • 重载示例

　　　　　　1、返回两个整数的和：int add（int x,int y）{return x+y;}

　　　　　　2、返回三个整数的和：int add(int x,int y,int z){return x+y+z;}

　　　　　　3、返回两个小数的和：double add(bouble x,double y){return x+y;}

什么时候用重载？

　　当定义的功能相同，但参与运算的未知内容不同，那么这是就定义一个函数名称以表示其功能，而通过参数列表的不同区分多个同名函数。

例如：加法运算，99乘法表。

2.8数组

2.8.1数组的定义

概念：同一种类型数据的集合。其实数组就是一个容器。

数组的好处：可以自动给数组中元素从0开始编号，方便操作这些元素。

格式1：元素类型 [] 数组名 = new 元素类型[元素个数或数组长度]

　　示例：int [] arr = new int[5]　　//arr不是int类型，为数组类型（引用数据类型）

格式2：元素类型 [] 数组名 = new 元素类型{元素，元素，元素，……}

　　示例：int [] arr = new int[]{3,5,1,7,……}

　　　　　int [] arr = new int{3,5,1,7,……}

2.8.2数组的内存分配及特点

Java程序在运行时，需要在内存中分配空间。为了提高运算效率，有对空间进行不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。

堆内存：数组和对象，通过new出来的实例都存放在堆内存中。

每一个实体都有内存地址值

实体中的变量都有默认初始化值

实体不再被使用，会在不确定的时间内被垃圾回收器回收。

方法区，本地方法区，寄存器。

2.8.3数组操作常见问题

格式3：int arr [] = new int[5]  //是对的！

arrayindexoutofboundsexception:数组角标越界异常。操作数组时，访问到了数组中不存在的角标。注：编译只检查语法。运行时异常就要修改程序了。

arr =null  ：nullpointerexception:空指针异常。当引用没有任何指向，值为空的情况，该引用还在操作该实体。

2.8.4数组常见操作

数组的操作：获取数组中的元素，通常会用到遍历。

数组中有一个属性可以直接获取数组中的元素个数。length.  使用方式：数组名称.length =

1，打印数组中的元素

2，获取数组中的最值（可以初始数组中的元素或者角标）

3，对给定数组进行排序（选择排序和冒泡排序）

　　选择排序：内循环结束一次，最值出现头角标位置上。（x+1：前后比，arr.length-1:少取最后一个元素角标的值，少比较一次）

　　冒泡排序：相邻的两个元素进行比较，如果符合条件换位。第一圈，最值出现在最后一位。(-X:让每一次比较的元素减少，-1：表面角标越界。）

　　array.sort(arr):Java中已经定义好的一种排序方式。开发中对数组进行排序，要使用该句代码。

4，位置置换功能抽取

　　发现无论什么排序，都需要对满足条件的元素进行位置置换，所以把相同的代码提取出来，封装成一个函数。

5，折半查找

　　return -1:数组角标都是从0开始，-1代表这个角标不存在，没有找到的这种情况。

　　定义功能，获取key第一次出现在数组中的位置。如果返回时-1，呢么该key代表在数组中不存在。

　　折半查找：提高效率，但是必须要保证该数组是有序的数组。

6.进制转换

　　十进制转换成二进制

StrimgBuffer sb = new StringBuffer//存储数据的容器，是一个对象

sb.append(num%2)//对象的存储数据方法

sb.reverse()//反转数据的功能

　　十进制转换成十六进制

sb.append((char)(temp-10+'A'))

num>>>4

　　查表法：

定义二进制的表：char [] chs = {'0','1'……};

定义一个临时储存器：char [] arr = new char[32];

定义一个操作数组的指针（与、查表、右移）,再打印。

2.8.5数组中的数组（二维数组[][]）

格式1：int [] [] arr = new int [3] [2];

• 定义了名称为arr的二维数组
• 二维数组中有3个一维数组
• 每个一位数组中有两个元素
• 一维数组的名称分别为：arr[0],arr[1],arr[2].
• 给第一个一维数组1脚标位赋值为78的写法是：arr[0][1];

格式2：int [] [] arr = new int [3] [];

• 二维数组中有三个一维数组
• 每一个一维数组都是默认初始化值null
• 可以对着三个一维数组分别进行初始化

arr [0] = new int [3];

arr [1] = new int [1];

arr [2] = new int [2];

格式3：int [] [] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};

System.out.println(arr.length);//打印的是二维数组的长度。

System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度。

 int sum = 0;
 for (int x = 0；x<arr.length;x++)
 {
           for(int y = o:y<arr[x].length;y++)
           {
                 sum = sum + arr[x][y];

            }
 }
 System.out.println("sum="+sum);