Java基础编程 （尚硅谷）

Java基础是学习JavaEE、大数据、Android开发的基石！

学东西的：3w（what、why、how）是什么？、为什么？、怎么用？

.
.
.

Eclipse中的快捷键：

 * 1.补全代码的声明：alt + /
 * 2.快速修复: ctrl + 1  
 * 3.批量导包：ctrl + shift + o
 * 4.使用单行注释：ctrl + /
 * 5.使用多行注释： ctrl + shift + /   
 * 6.取消多行注释：ctrl + shift + \
 * 7.复制指定行的代码：ctrl + alt + down 或 ctrl + alt + up
 * 8.删除指定行的代码：ctrl + d
 * 9.上下移动代码：alt + up  或 alt + down
 * 10.切换到下一行代码空位：shift + enter
 * 11.切换到上一行代码空位：ctrl + shift + enter
 * 12.如何查看源码：ctrl + 选中指定的结构   或  ctrl + shift + t
 * 13.退回到前一个编辑的页面：alt + left 
 * 14.进入到下一个编辑的页面(针对于上面那条来说的)：alt + right
 * 15.光标选中指定的类，查看继承树结构：ctrl + t
 * 16.复制代码： ctrl + c
 * 17.撤销： ctrl + z
 * 18.反撤销： ctrl + y
 * 19.剪切：ctrl + x 
 * 20.粘贴：ctrl + v
 * 21.保存： ctrl + s
 * 22.全选：ctrl + a
 * 23.格式化代码： ctrl + shift + f
 * 24.选中数行，整体往后移动：tab
 * 25.选中数行，整体往前移动：shift + tab
 * 26.在当前类中，显示类结构，并支持搜索指定的方法、属性等：ctrl + o
 * 27.批量修改指定的变量名、方法名、类名等：alt + shift + r
 * 28.选中的结构的大小写的切换：变成大写： ctrl + shift + x
 * 29.选中的结构的大小写的切换：变成小写：ctrl + shift + y
 * 30.调出生成getter/setter/构造器等结构： alt + shift + s
 * 31.显示当前选择资源(工程 or 文件)的属性：alt + enter
 * 32.快速查找：参照选中的Word快速定位到下一个 ：ctrl + k
 * 
 * 33.关闭当前窗口：ctrl + w
 * 34.关闭所有的窗口：ctrl + shift + w
 * 35.查看指定的结构使用过的地方：ctrl + alt + g
 * 36.查找与替换：ctrl + f
 * 37.最大化当前的View：ctrl + m
 * 38.直接定位到当前行的首位：home
 * 39.直接定位到当前行的末位：end

.
.
.

1.1软件开发介绍

1.软件开发
软件，即一系列按照特定顺序组织的计算机数据和指令的集合。有系统软件和应用软件之分。

2.人机交互方式
（1）图形化界面（GUI）：这种方式简单直观，使用者易于接受，容易上手操作。
（2）命令行方式（CLI）：需要一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记住一些命令。

常用的DOS(CMD)命令：
dir：列出当前目录下的文件及文件夹
md：创建目录
rd：删除目录
cd：进入指定目录
cd…（两个点）：退回到上一级目录
cd\：退回到根目录
del：删除文件
exit：推出dos命令行
补充：
echo（在文件夹中添加文件） 格式：echo giao>1.txt
echo：命令
giao：内容
1.txt：文件名（其中txt是文件格式）

常用快捷键
← →：移动光标
↑ ↓：掉阅历史操作命令
Delete和Backspace：删除字符

.
.
.
.
.

.
.

JAVA严格区分大小写

path环境变量的配置

1.为什么配置path环境变量？
	path环境变量：Windows操作系统执行命令时所要搜索的路径
2.为什么要配置path
	希望java的开发工具（java.exe，javac.exe）在任何的文件路径下都可以执行成功
	不止是Java开发工具  只要是 .exe 的运行文件需要它在任何文件路径下执行成功都要配置path

java语言的特点：

1.面向对象性：
	两个要素：类、对象
	三个特征：封装、继承、多态
2.健壮性：
	(1)去除了C语言中的指针
	(2)自动的垃圾回收机制 → 仍然会出现内存溢出、内存泄漏问题
3.跨平台性：writ once,run anywhere：一次编译，到处运行（功劳归功于：JVM                ）

一.HelloJava

1.开发体验
步骤：

（1）.将 Java 代码编写到扩展名为.java的文件中。
（2）.通过 javac 命令对该 java 文件进行编译。
（3）.通过 java 命令对生成的 class 文件进行运行。

Java文件 → javac.exe(编译) → .class文件 （一个或多个）→ java.exe(运行) → 结果

2.在一个java源文件中可以声明多个class。但是，只能最多有一个类声明为public而且要求声明为public的类名必须与源文件名相同。

3.程序的入口是main()方法。格式是固定的。

4.输出语句：
（1）System.out.println(); （先输出，后换行）
（2）System.out.print(); （输出不换行）

5.每一个执行语句都以 ； 结束。

6.编译的过程：编译以后，会生成一个或多个字节码文件（.class）字节码文件的文件名与java源文件中的类名相同。（写的代码有几个类就有几个字节码文件）

.
.
.

二.文档注释

1.单行注释 : //
2.多行注释 : /* */

3.文档注释 : /** 注释内容可以被JDK提供的 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。 */

操作指令：
		javadoc -d mydoc -author -version HelloWorld.java

.
.
.

标识符号的使用

	1.标识符：凡是自己可以起名字的地方都叫标识符。
	 		比如：类名、变量名、方法名、接口名、包名...
	 
	 2.标识符的命名规则：
	 		由26个英文字母大小写，0~9， _ 或 $ 组成。
	 		数字不可以开头。
	 		不可以使用关键字和保留字，但能包含关键字和保留字。
	 		Java中严格区分大小写，长度无限制。
	 		标识符不能包含空格！
	 			
	 3.Java中的名称命名规范：
	 		包名：多单词组成时所有字母都小写：xxxzzzyyy
	 		类名：接口名：多单词组成时，所有单词的首字母大写：XxxZzzYyy(大驼峰命名法)
	 		变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxZzzYzz(小驼峰命名法)
	 		常量名：所有字母都大写。多单词时每个单词用下划线链接起来：XXX_ZZZ_YYY
	 			
	 4.注意:
	 		(1)：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。	
	 		(2)：Java采用 Unicode 字符集，因此标识符也可以使用汉字声明，但是不建议使用。

	5.转义字符：
			(1)\b		退格符
			(2)\n		换行符
			(3)\r		回车符
			(4)\t		制表符
			(5)\"		双引号
			(6)\'		单引号
			(7)\\		反斜线

.
.
.
.
.

三：变量与运算符

注：在java中整型常量默认类型为 int 型
注：在java中整浮点型常量默认类型为double型

变量

变量的概念：
	 			- 内存中的一个存储区域。
	 			- 该区域的数据可以在同一类型范围内不断变化。
	  			- 变量是程序中最基本的储存单位。包含 变量类型、变量名的储存的值。
	  			
	  	变量的使用：
	  			- java定义变量的格式：数据类型 变量名 = 变量值；
	  			
	  	变量的作用：
	  			- 用在内存中保持数据。
	  			
	  	使用变量注意：
	  			- Java中每个变量必须先声明，后使用。
	  			- 使用变量名来访问这块区域的数据。
	  			- 变量的作用域：其定义所在的一对{}内。
	  			- 变量只有在其作用域才有效。
	  			- 同一个作用域内，不能定义名字相同的变量。
	  			
	  	Java定义的数据类型
	  			一、 变量按照数据类型来分：
	  					1. 基本数据类型（primitve type）：
	  							- 数值型：
	  									注：1MB = 1024KB ; 1KB = 1024B ; B = byte(字节)  ？ bit； 
	  										bit是计算机中最小的存储单位，byte是计算机中基本的存储单位；
	  										
	  									整数类型（byte（1字节=8bit；取值：-128 ~ 127）,short（2字节 ；取值：-2^15 ~ 2^15-1）,int（4字节 ；取值：-2^31 ~ 2^31-1）,long（8字节 ；取值：-2^63 ~ 2^63-1））：
	  											(1)表示整数；
	  											(2)一般Java程序中变量常用int型，除非不足以表示较大的数用long；
	  											(3)声明long型的变量，变量值后必须要加 "L" ;
	  											
	  									浮点类型（float,double）
	  											(1)表示带小数点的数值；
	  											(2)因为double的精度是float的两倍。通常采用此类型。
	  											(3)声明float型的变量，变量值后必须要加 "F" ;
	  											(3)两个浮点型表示数的范围大小比 整型中的Long还大 ，而内存比Long小；
	  							- 字符型（char）
	  											(1)char变量值只能写一个字符
	  											(2)Unicode值可以用来表示字符型变量值
	  											(3)转义字符：
	  													char g3 = '\t';
														System.out.print("hello"+g3);
														System.out.println("java!");
														输出：hello		java！
	  							
	  							- 布尔型（boolean）
	  							 					只能取两个值：true  false
	  												常常在条件判断、循环结构中
	  					
	  					2.引用数据类型（reference type）:
	  							- 类（class）  字符串在class里面
	  							- 接口（interface）
	  							- 数组（[]）
	  							
	  			二、变量在类中声明的位置： （扩展：面向对象才说的内容）
	  					在方法体外，类体内声明的变量成为：成员变量。
	  					在方法体内，声明的变量成为：局部变量。
	  			
	  					1.成员变量：
	  						- 实例变量（不以static修饰）
	  						- 类变量（以static修饰）
	  						
	  					2.局部变量：
	  						- 形参（方法、构造器中定义的变量）
	  						- 方法局部变量（在方法内定义）
	  						- 代码块局部变量（在代码块内定义）
	  						
	  						
	  					注意：二者在初始化值方面的异同：
	  						- 同：都有生命周期
	  						- 异：局部变量除形参外，需显示初始化

基本数据类型之间的运算规则：
	 	
	 	前提：这里讨论的只是七种基本数据类型变量间的运算。不包含boolean类型
	 	
	 		1.自动类型提升：
	 			- 结论：当容量小的数据类型的变量与容量大的数据类型做运算时，结果自动提示为容量大的类型。
	 			- byte --> short --> int --> long --> float --> double
	 			
	 			- 特别：当byte、short、char这三种数据类型的变量做运算时，结果为int型 ，就算是两个byte型的做运算都是int型。
	 			- 书上的解释：java在做运算的时候，如果操作数均在 int 范围内，那么一律在 int 的空间内运算。
	 		
	 		2.强制类型转换：
	 
	 	说明：此时的容量大小指，表示数的范围的大和小。比如：float容量要大于long的容量
	 	注：对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围，
	 		那么 javac编译器 将会自动隐含的为我们补上一个 (byte) (short) (char) 。

一.编码情况 
		
		//编译成功 因为整数过小 系统把123123这个值当为int ， 就相当于int型转long型这个过程
		long L = 123123;
		System.out.println(L);
		
		//编译失败：过大的整数要加L
		//long L1 = 123123123131;
		long L1 = 123123123131L; //编译成功
		System.out.println(L1);
		
		//编译失败 浮点型float一定要加F
		float f1 = 12.3;
		System.out.println(f1);
		
		
二.编码情况2
		
		byte b = 12;
		// 这里的 1 看成一个常量，整型常量默认类型为int型
		//byte b2 = b + 1;  	//编译失败
		
		
		//这里的12.3看出一个常量，浮点型常量默认类型为double型
		//float f1 = b + 12.3;	//编译失败

.

String类型变量的使用 (它是引用数据类型)

String变量的使用
			1.String属于引用数据类型，翻译为：字符串
			2.声明 String 类型变量时，必须使用一对 "" 或者 值+"" 两种情况
			3. String 可以和 8 种基本数据类型做运算，切运算只能是链接运算，链接符号为 + （boolean 也能做链接运算）
			4.运算的结果仍然是 String 类型，前提是 + 左右两边有String类型的变量
			5.例题：
				char C = 'a';
				int num = 10;
				String str = "hello";
				System.out.println(C+num+str);	//107hello   因为：a = 97   先运算了C+num 这俩中没有String类型的所以是 97+10;
				System.out.println(str+num+C);	//hello10a   因为 先运算 str+num str为String类型的所以 str+num 的值为String类型（hello10），然后又是String类型+C 得到的也是String类型（hello10a）;

.
.
.

进制

1.关于进制

• 对于整数，有4种表示方式：

  二进制（binary）：0、1 ，满2进1.以0b或0B开头。如：0b1100
  十进制（decimal）：0-9，满10进1。
  八进制（octal）：0-7，满8进1.以数字0开头表示。如：0123
  十六进制（hex）：0-9及A-F，满16进1.以0x或0X开头表示。此处A-F不区分大小写。
  如：0x21AF+1=0X21B0

• 所有数字在计算机底层都以 二进制 的形式存在

二进制：

• Java整数常量默认是 int 类型，当用二进制定义整数时，其第32位(一共是32节，也就是存储的最后一节)是符号位；当是long类型时，二进制默认占64位(64节)，第64位(最后一节)是符号位。
• 二进制的整数有如下三种形式：

1.原码：直接将一个数值转成二进制数。最高位是符号位：最高位是0为正数，1为负数。
2.负数的反码：是对原码按位取反（里面每一位或者说是每一节的 0变成1、1变成0 ），只是最高位（符号位）确定为 1 不变。
3.负数的补码：其反码+1。
如反码为：[1][0][1][0][0][1][0][1];（类似计算机底层存储，这是8位(8bit)就是 byte 类型的）
补码就为：[1][0][1][0][0][1][1][0];

计算机以二进制 补码 的形式保存所有的整数。

1.正数的原码、反码、补码都相同
2.负数的补码是上面介绍的其反码 +1 。

.
.
.

进制转换

1.二进制 转 十进制

如： 1 0 1 1 0 转 十进制
	 从右往左算:	一个值一个值的算最后加起来
	 			第一个为2的0次方（2^0）特殊：它的值要么是1要么是0
	 			以下前提对应的数是 1
	 			第二个为2的1次方（2^1） 
	 			第三个为2的1次方（2^2）
	 			第四个为2的1次方（2^3）
	 			第五个为2的1次方（2^4）
	开始算 ：1 0 1 1 0
			第一数个 0 ：值为 0
			第一数个 1 ：值为 2
			第一数个 1 ：值为 4
			第一数个 0 ：值为 0
			第一数个 1 ：值为 16
		
			相加： 0 + 2 + 4 + 0 +16 = 22
			二进制：1 0 1 1 0  转  十进制为 22；

2.十进制 转 二进制：除二取余的逆

如： 十进制 13 转二进制
	解释：拿13除以2，记下得到的余数，得到的商继续除2，继续记下余数，商再除2....
	（1）13/2=6...1 
	（2）6/2=3...0
	（3）3/2=1...1
	（4）1/2=0...1
	（5）0/2=0...0
	（6）0/2=0...0
	（N）0/2=0...0
	取每次算完的余数：10110000...
	在把得到的余数倒（逆）过来写：...0001101;
	13转二进制的值就是：1101

.
.
.

运算符

1.运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

2.运算符分为：

（1）算数运算符：+ - * / % ++ --    
		注：
			1.前++（先自增1，后运算）、后++（先运算后自增1）
			  自增自减不会改变数据类型！
			2.连接符  +  ：只能使用在String与其他数据类型（包括String自身）变量之间使用。

			 % ：取余运算
					1.结果的符号与 被模数 的符号相同 ！！！！
					2.开发中，经常使用%来判断能否被除尽的情况
					int m1 = 12;
					int n1 = 5;
					System.out.println("m1%n1="+m1%n1);   //2
					
					int m2 = -12;
					int n2 = 5;
					System.out.println("m2%n2="+m2%n2);   //-2
					
					int m3 = 12;
					int n3 = -5;
					System.out.println("m3%n3="+m3%n3);  //2
					
					int m4 = -12;
					int n4 = -5;
					System.out.println("m4%n4="+m4%n4);  //-2

（2）赋值运算符：=（赋值）	+=	-+	*=	/=	%=
		注：+= 、 -= 这些虽然是在原值上加常量 但是和 num = num + 2 （数据类型在int以下或是整数与浮点数做运算编译不通过，因为改变数据类型了）,这种方式也有不同， num+=2 这种方式不会改变 数据类型！！
		
		==:对与引用数据类型来讲，比较的是两个引用数据类型变量的地址值是否相同

（3）比较运算符（关系运算符）：== （恒等于）	！=（不等于）	>=	<=	>	<

（4）逻辑运算符： 操作都是Boolean类型的变量，结果也是Boolean类型！
	1.  &、&&（与,and）
		//区分& 与 &&
		//相同点1：& 与 &&的运算结果相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，& 会继续执行符号右边的运算，而 && 不再执行符号右边的运算
		//开发中推荐使用 &&

		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		
		if(b1 & (num1++>0)){	
			System.out.println("北京");
		}else{
			System.out.println("南京");
		}
		
		System.out.println("num1="+num1); //11			因为b1为false & 还要执行(num1++>0)
		System.out.println();
		
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		
		if(b2 && (num2++>0)){
			System.out.println("北京");
		}else{
			System.out.println("南京");
		}
		System.out.println("num1="+num2); //10			因为b1为false && 不往下执行(num1++>0)
		
 	2.   |、 ||（或,or）
		//区分：| 与 ||
		//相同点1：| 与 || 的运算结果相同
		//相同点2：相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点：当符号左边是true时，| 会继续执行符号右边的运算，而 || 不再执行符号右边的运算
		//开发中推荐使用 ||
			
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		
		if(b3 | (num3++>0)){	
			System.out.println("北京");
		}else{
			System.out.println("南京");
		}
		System.out.println("num3="+num3);  //num3=11
		System.out.println();
		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		
		if(b4 || (num4++>0)){	
			System.out.println("北京");
		}else{
			System.out.println("南京");
		}
		System.out.println("num4="+num4);  //num4=10
 	
 	3.   ！（非）
 	
 	4.   ^（逻辑异或，两个都是true或false就是false，两个不一样就true）

（5）位运算符（用比较少）：
		·位运算符：					注意：没有<<<
		
		    1. << 左移：范例：3<<2=12 --> 3*2*2=12	； 左移一位就乘2
						·二进制表示：11 向左移两位 1100 （后面用0来补）所以得到的值就是 12。如果移的多了 最大位变成1了那这个数就是负数。
							
		    2. >> 右移：范例：3>>1=1 --> 3/2=1 ； 右移一位就除2
						·二进制表示：11 向右移一位 1 （如果最大位是1，前面的值就用1来补，是0则用0来补）所以得到的值就是 1。如果最大位是1，那么补充最大的数也是1，当然这个数是负数。
							
		    3. >>&