Java基础学习笔记

第一章：初识Java

安装和配置JDK1.8.0_xxx

1）安装：直接使用安装程序，按照安装向导安装即可
	注意：安装路径，建议安装在非c，非中文路径下，比如：D:/DevInstall/Java/jdk1.8.0_xxx
	
2）配置：在此电脑，右击-》属性-》高级系统属性，弹出页面的高级选项卡，环境变量
	在下面系统环境变量中：
	新增：变量名：JAVA_HOME 变量值：jdk的安装目录
    修改：Path环境变量，编辑环境变量，增加一个jdk的配置
        即：%JAVA_HOME%\bin;
3）验证：
	win+r快捷键打开运行小窗口，输入cmd，打开命令行窗口
	java -version
	可以看到jdk的安装版本：
		java version "1.8.0_192"
		Java(TM) SE Runtime Environment (build 1.8.0_192-b12)
		Java HotSpot(TM) 64-Bit Server VM (build 25.192-b12, mixed mode)
	输入javac，如果直接显示提示改命令的选项，即安装配置成功。
		用法: javac <options> <source files>
		其中, 可能的选项包括:
  		-g                         生成所有调试信息
  		-g:none                    不生成任何调试信息
  		-g:{lines,vars,source}     只生成某些调试信息
		。。。。。。。

代码中的注释

注释分为三类：
    1）单行注释 业务代码关键注释居多
        // 代码说明注释，或者不需要执行代码
    2) 多行注释，注释多行代码，一般都是去除某段代码，又不想删
        /* 开头，*/结尾，不需要执行代码
    3）文档注释（javaDoc注释）注释类和方法
        /** 开头，*/结尾

第二章：变量和数据类型

变量

定义：一个数据存储空间的表示      
语法：
    数据类型 变量名;
    变量名 = 变量值;
或者
    数据类型 变量名 = 变量值;
注：
    命名规则：首字母：字母（26个字母，大写小写）、下划线、$符号，不能数字开头
    其余部分：字母，数字，下划线，和 $ 符号，不能为其它符号

    重要的规则为：
        驼峰命名法：第一个单词首字母小写，其它部分单词首字母大写
        注意：第一个单词最好不要是只有一个小写字母，变量的命名要通俗易懂
        类名：首字母按照规范，首字母大写，也参照驼峰命名法
        变量的声明，不能重名，而且不能跟java中的"关键字"一致

数据类型(8种)：

字节：byte（一个字节8位）
字符：char（2个字节16位）
短整形：short（2字节16位）
整形：int（4字节32位）
浮点型：float（4个字节32位）
浮点型：double（8个字节64位）
长整型：long（8个字节64位）
布尔类型：boolean （只能是true和false）

注意：String不是基本数据类型，它是一个类（java.lang.String）

常量的定义：

语法：
    final 数类型 变量名 = 变量值;
注意：
    1）常量名通常大写
    2）不同分词使用下划线分隔
    3）只能被赋值一次，通常定义时即对其初始化
示例：
    // 定义一个常量
    final double MATH_PI = 3.14;

Scanner：

作用：接收用户输入（键盘输入）
写法：
    // 创建Scanner对象
    Scanner input = new Scanner(System.in);
注意：
    要引入Scanner类--import java.util.Scanner;
获取数据：
    输入的字符串：input.next(); // nextLine()
    输入的数字：input.nextInt();
    输入的浮点型：input.nextDouble();

类型自动转换：

    低精度向高精度会自动转换
    规则：
        规则1：如果一个操作数为double型，则整个表达式可提升为double型
    
        规则2：满足自动类型转换的条件
            两种类型要兼容
            数值类型（整型和浮点型）互相兼容
            目标类型大于源类型： 
            例如：double 型大于 int 型

## 算数运算符：  

```java
    加+ 减- 乘* 除/ 求余% 
    + ： 加  int add = 5+2; // 7
    - ： 减  int sub = 5-2; // 3
    * ： 乘  int min = 5*2; // 10
    / ： 除  int chu = 5/2; // 2
    % ： 求余 int mod = 5%2; // 1
    加加++ 减减--
    写变量前：先变量值加减，后使用变量值
    写变量后：先使用变量值，后变量值加减
    
复合运算符：
    += -= *= /= %=
例如：num += 2; --> num = num + 2;
注意：是单个运算符，当类型不匹配不能转换等价
示例：
	short a = 4;
	a += 5; // 编译通过
	a = a + 4; // 编译不通过，类型不匹配

关系运算符：

== 等于 判断是否相等
!= 不等于 判断不相等
> 大于 判断大于
< 小于 判断小于
>= 大于等于 判断大于等于
<= 小于等于 判断小于等于
注意：> < >= <= 只适用于数值类型判断

逻辑运算符：

短路与：&& 两边表达式都为true，结果才为true，第一个表达式为false，不看第二个表达式
短路或：|| 两边表达式都为false，结果才为false，第一个表达式为true，不看第二个表达式
非：！ 取反
示例：
		int a1 = 8;
		int b1 = 9;
		System.out.println((++a1 == b1) && (++a1 != b1)); // true
		System.out.println(a1); // 10
		int a2 = 8;
		int b2 = 9;
		System.out.println((++a2 == b2) || (++a2 != b2)); // true
		System.out.println(a2); // 9

三元运算符

语法：条件表达式 ？ 表达式1 ：表达式2;
    条件表达式为true,结果为表达式1的值，否则为表达式2的值
    表达式1或者2的类型必须跟定义变量类型一致

运算符优先级

1)优先级别最低的是赋值运算符
2)可以通过()控制表达式的运算顺序，()优先级最高
3)算术运算符 > 关系运算符 > 逻辑运算符

灵活用法：当不确定优先级的时候，优先选择使用小括号()

位运算符：& 与， | 或， ^ 非（异或） ， ~ 取反

java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

位运算符作用在所有的位上，并且按位运算。假设a = 60，b = 13;

它们的二进制格式表示将如下：

A = 0011 1100
B = 0000 1101

A & B = 0000 1100
＆ 如果相对应位都是1，则结果为 1，否则为 0 （A ＆ B）得到12，即 0000 1100

A | B = 0011 1101
| 如果相对应位都是 0，则结果为 0，否则为 1 （A | B）得到61，即 0011 1101

A ^ B = 0011 0001
^ 如果相对应位值相同，则结果为 0，否则为 1 （A ^ B）得到49，即 0011 0001

~A    = 1100 0011
〜 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。 （〜A）得到-61，即1100 0011

第三章-选择结构

if基本结构（条件判断）

语法：
    if ( 条件 ) { 
        //代码块 
    }

注意：
	条件只能是boolean类型值或者表达式，true或者false，不能为其它值
	当只有一条语句时，可以省略大括号，但是不建议省略

复杂条件判断

结合运算符的优先级编写条件
    最高的优先级：( )
    最低的优先级：=
    优先级：！> 算术运算符 > 关系运算符 > && > ||
    复杂条件使用括号提高可读性

if-else分支结构

语法：
    if ( 条件 ) { 
        //代码块1  
    } else { 
        //代码块2 
    }
注意：
    else后面没有小括号，大括号不建议省略

多重if分支结构

语法：
    if (条件1) { 
        //代码块1  
    } else if (条件2){ 
        //代码块2 
    } else if (条件3){ 
        //代码块3 
    } else { 
         //代码块
    }

注意：
    1）最后else可省，根据具体的业务
    2）else和if是分开，中间有空格
    3）else if可以存在多个
    4）适用于连续的区间判断，顺序不能颠倒

if分支结构嵌套

语法：
    if（条件1) {
        if（条件2) {
            // 代码块1
        } else {
            // 代码块2
        }
    } else {
        // 代码块3
    }

注意：
    1）嵌套的层次，不能过多，一般不超过三层

扩展：
    equals用法
        equals:用于判断字符串内容是否一致，区别于 == 
            一般把确定的字符串内容，写在前面，变量写在后面（括号内）
        == ：如果是基本类型数值，直接判断值是否相等
        如果是字符串类型，判断的内容是对象

    获取随机数：
        Math.random()方法获取随机数，生成的值的范围为：[0,1)
        左闭右开 ：可以为0，永远接近1，但是不可能为1
        类型为double

switch分支结构

语法：
    switch (表达式) {
        case 常量1:
            语句;
            break;
        case 常量2:
            语句;
            break;
        …
        default:
            语句;
    }

注意：
    1）表达式支持的基本类型：int,byte,short,char，特殊类型：枚举类型，String类型
    2）每个case匹配执行结束，要加break关键字，分号结尾，作用是结束分支结构
    3）case后面的常量值，不能重复
    4）default的顺序，没有固定要求，但是一般建议写在最后，且加上break;关键字，也可以省略不写

switch和多重if的异同

相同点：
    都是用于处理多分支条件判断
不同点：
    switch:只能处理等值的条件判断
    多重if：没有switch的条件限制，一般用于连续的区间条件判断（某个值在固定的区间范围内）

第四章-循环结构

while循环

语法：
    while ( 循环条件 ) {
            
           循环操作

    }
特点：
    先进行条件判断，如果条件成立，执行循环操作，如果条件不成立，循环操作一次都不执行
注意：
    在循环体操作中，要控制循环条件变量的变更（否则死循环）
    循环体操作只有一条语句，大括号可以省略（不建议省略）

do…while循环

语法：
    do {

        循环操作

    } while ( 循环条件 );

特点：
    先执行循环体操作，后执行条件判断，不论条件是否成立，循环操作至少执行一次

注意：
    while后面要分号结尾

for循环

语法：
    for(参数初始化; 条件判断; 循环变量值变更){
        // 循环体
    }
执行顺序：
    先初始化-->条件判断-->执行循环体-->循环变量变更
    变更之后，再做条件判断，成立，执行循环体，循环变量变更，直到条件不成立
注意点：
    1、格式，代码规范，注意缩进
    2、初始化变量可以写多个，但是作用域在循环内可见，如果需要循环外获取执行的变量值，需要定义在循环外
    3、循环变量的变更也可以写在循环内部，不可以省略
    4、条件判断不能省略，否则死循环
    5、for(;;){...}这个没有语法错误，但是会死循环，相当于while(true){...}

示例：输出加法表
    // 系统输入
    Scanner input = new Scanner(System.in);
    System.out.print("请输入一个数值：");
    int num = input.nextInt();
    
    for(int i = 0, j = num; i <= num ; i++, j--){
        // 输出加法表
        System.out.println(i + " + " + j + " = " + (i+j));
    }
    
常见错误示例：
    // for循环常见写法:初始化和变量赋值是可以省略的，但是分号不能省
    int i = 0; 
    // 两个分号不能省略，等同于while(i<10)
    for (;i < 10;) {
        System.out.println(i);
        i++;
    }
    
    // 没有循环条件:语法不会报错，但是会造成死循环
    int j = 0;
    for(;;j++){
        System.out.println(j);
    }
    
    // 没有给变量重新赋值:语法正常，但是也会造成死循环
    int k = 0;
    for(;k<10;){
        System.out.println(k);
    }
    
    // for循环什么都不写：语法正常，但是也是死循环
    for(;;){
        System.out.println("测试");
    }

三种循环的异同点：

相同点：
    无论哪一种循环结构，都有4个必不可少的部分：
    初始部分、循环条件、循环体、更新循环变量
不同点：
    1、语法不同
    2、执行顺序不同
        while 循环：先判断，再执行
        do-while循环：先执行，再判断
        for循环：先判断，再执行
使用场景：
    循环次数确定的情况，通常选用for循环
    循环次数不确定的情况，通常选用while或do-while循环

第五章-多重循环和程序调试

多重循环语法：

for(循环条件1){
     //循环操作1
     for(循环条件2){
          //循环操作2
     }
}
while，或者do-while类似，循环内嵌套循环，三种循环可以相互嵌套
注意：
    循环的嵌套，一般不超过两层
    原理：外层循环循环执行一次，内层循环执行一遍

改变流程关键字

break:
    常用于switch结构和循环结构中
    break语句终止(跳出)某个循环，程序跳转到循环块外的下一条语句
    只能跳出当前所在的循环，不能跳出多重循环
continue：
    一般用于循环结构中
    continue跳出本次循环，进入下一次循环
    不能结束循环，只能跳过某个条件下的循环

程序调试

步骤：
    1）打断点
    2）debug模式运行程序
    3）f5:进入方法内部，逐步执行
    f6:单步运行（逐行执行代码），没法进入方法内部
    f8:断点与断点之间跳转运行
    4）发现问题，修改代码
    5）关闭调试程序

第六章-一维数组

什么是数组：

数组是一个变量，存储是相同数据类型的一组数据，声明数组，就是在内存中划分一串连续的空间
    注意：
        数组一经定义，大小就确定了，不可以在此基础上再增加空间（重新创建除外），即：不可以动态扩展空间

数组的基本要素：

数据类型：指定数组中存放的数据类型
标识符：数组名称
数组元素：存放在数组中的数据
下标：从0开始，最大不能大于数组的长度-1
注意：
    数组长度固定，应避免地址下标越界获取元素

如何定义和使用数组

1）声明数组
    方式1：数据类型[] 数组名; -- 推荐写法
    方式2：数据类型 数组名[];

2）分配空间 使用 new 关键字
    数组名 = new 数据类型[数组长度];
    注意：
        长度必须要定义，代表数组可以存放的元素个数

    备注：
        数组元素，根据不同的数据类型，会有不同的初始值（数组定义后，不初始化赋值，仍然可以直接访问元素，不会报错，比如：int--0，String--null...）

3）赋值
    实际是向分配的内存空间存放数据（实际是地址的引用）
    语法：
        数组名[下标] = 定义数据类型的值;

    声明数组同时赋值：
        方式1：
            数据类型[] 数组名 = {元素1，元素2....};
        方式2：
            数据类型[] 数组名 = new 数据类型[]{元素1，元素2....};

    注意：
        由于初始化值，已经确定了数组的元素个数，所以，不可以再指定长度
        边声明边赋值：必须定义在一条语句内，不能分开
            比如：
                int[] scores = new int[5];
                scores = {1,2,3,4,5};

    4）数组的使用
        数组元素赋值之后，可以重复获取，并使用

数组长度

语法：数组名.length
    注意：数组长度，使用的length数组，有别于字符串，字符串长度使用的是length()方法

示例：
    for(int i = 0; i < scores.length; i++){
        System.out.println(scores[i]);
    }

数组求最大值和最小值

原理：
    类似打擂台，借助中间表变量，依次比较，保留最大或者最小值

向数组中插入元素

原理：
	先扩容数组，再确定插入位置，从最后一个元素开始移位，移动到插入位置，插入元素值

第七章-二维数组

冒泡排序 – 升序

原理：
    每次比较相邻两数
    小的交换到前面
    每轮结束后最大的数交换到最后

口诀：
    冒泡排序速记口诀（升序）
        n 个数字来排队
        两两相比大靠后
        外层循环 n-1
        内层循环 n-1-i

示例：
        // 冒泡排序算法
        // 初始化一个数组
		int[] nums = {6, 3, 5, 2, 7, 4, 1, 9, 8};
		System.out.println("排序前：" + Arrays.toString(nums));
		// 外层控制轮次（n-1次）
		for (int i = 0; i < nums.length - 1; i++) {
			// 内层控制比较次数
			for (int j = 0; j < nums.length - 1 - i; j++) {
				// 判断，如是升序，大的值靠后，如果是降序，小的值靠后
				if(nums[j] < nums[j + 1]){
					// 两值互换
					int temp = nums[j];
					nums[j] = nums[j+1];
					nums[j+1] = temp;
				}
			}
		}
		System.out.println("排序后：" + Arrays.toString(nums));

选择排序

/**
 * 工作原理：
 * 首先在未排序的数列中找到最大（小）元素，放到排序数列的起始位置
 * 然后再从剩余未排序的元素中继续查找最大（小）元素，放到已排序数列的末尾（按照次序），依次类推
 * @author zhukang
 *
 */
public class Xuanze {

	public static void main(String[] args) {
		// 选择排序：表现最为文档的一种排序，其排序算计简单直观
		// 初始化一个数列
		int[] nums = {66, 55, 77, 11, 33, 22, 88, 44, 99};
		System.out.println("选择排序前，初始数组：" + Arrays.toString(nums));
		
		// 使用选择排序
		for (int i = 0; i < nums.length; i++) {
			// 记录每次循环起始位置，作为查找参照初识值，如果后续有更小值，记录其下标
			int minIndex = i;
			// 从未排序的数列中查找最小或者最大值
			for (int j = i; j < nums.length; j++) {
				// 两两比较，确定最小或者最大值
				if(nums[j] > nums[minIndex]){
					// 记录已找到最小值的下标，一轮结束，就是未排序数列中的最小值下标
					minIndex = j;
				}
			}
			
			// 将最小值下标对应的值，跟外层循环的起始位置，进行数据交换
			int temp = nums[i];
			nums[i] = nums[minIndex];
			nums[minIndex] = temp;
		}
		System.out.println("选择排序后，排序数组：" + Arrays.toString(nums));
	}

}

Arrays工具类的用法

boolean equals(array1,array2)
    比较array1和array2两个数组是否相等
sort(array)
    对数组array的元素进行升序排列
String toString(array)
    将一个数组array转换成一个字符串
void fill(array,val)
    把数组array所有元素都赋值为val
copyOf(array,length)
    把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
int binarySearch(array, val)
    查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

示例：
    	// 判断两个数组是否相等，必须长度和元素都相等，了解
		int[] scores1 = {78, 67, 89};
		int[] scores2 = {78, 67, 89, 0};
		System.out.println("数组是否相等：" + Arrays.equals(scores1, scores2));

		// 数组填充元素，了解
		int[] scores3 = new int[10];
		System.out.println("默认数组内容：" + Arrays.toString(scores3));
		Arrays.fill(scores3, 100);
		System.out.println("填充后数组内容：" + Arrays.toString(scores3));
		
		// 拷贝数组-扩容，排序，转字符串，掌握
		int[] scores4 = {11, 22, 33, 44, 55};
		// 拷贝前
		System.out.println("默认数组内容：" + Arrays.toString(scores4));
		// 扩容到10个长度
		int[] scores5 = Arrays.copyOf(scores4, 10);
		System.out.println("扩容后数组内容：" + Arrays.toString(scores5));
		// 缩减长度到3
		int[] scores6 = Arrays.copyOf(scores4, 3);
		System.out.println("缩减后数组内容：" + Arrays.toString(scores6));
		
		// 数组元素查找：前置条件-数组的元素必须是升序的，返回的是升序后的元素下标，如果不升序，返回的结果是不准确的，不可以作为查找判断条件
		int[] scores7 = {9, 6, 7, 4, 8, 3, 5, 1, 2};
		System.out.println("默认查找数组内容：" + Arrays.toString(scores7));
		// 要查找是否包含数字3
		// 必须先升序才可以
		Arrays.sort(scores7);
		System.out.println("默认查找数组升序内容：" + Arrays.toString(scores7));
		System.out.println("是否包含数字3，下标值:" + Arrays.binarySearch(scores7, 3));
		
		// 排序，默认是自然排序
		String[] names = {"jerry", "jack", "marry", "mark"};
		System.out.println("姓名数组内容：" + Arrays.toString(names));
		Arrays.sort(names);
		System.out.println("姓名数组排序后内容：" + Arrays.toString(names));

二维数组

语法：
    <数据类型> [ ][ ]  数组名 = new 数据类型[数组二维长度][数组一维长度];  
    或者  
    <数据类型>  数组名[ ][ ] = new 数据类型[数组二维长度][数组一维长度];  
注意：
    定义二维数组时，要定义最大维数，一维维度可以不定义，且长度不是必须一致的
    二维数组实际上是一个以一维数组做为元素的一维数组
    通过二维数组名获取长度，返回的是二维的长度，即有几个一维数组

示例：
    int [ ][ ] scores = new int[5][]; -- 正确
    int [ ][ ] scores = new int[][]; -- 错误

定义并赋值：
    int[][] scores = new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};
    或者
    int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };

遍历二维数组：
		// 外层是二维长度
		for (int i = 0; i < scores.length; i++) {
			// 内层是一维数组的真是长度
			for (int j = 0; j < scores[i].length; j++) {
				System.out.print(scores[i][j] + " ");
			}
			System.out.println();
		}
示例：
        // 按规律输出数字列表
        /**
		 * 特殊数列
		 * 1
		 * 2 6
		 * 3 7 10
		 * 4 8 11 13
		 * 5 9 12 14 15
		 */
		Scanner input = new Scanner(System.in);
		System.out.print("请输入数列的行数：");
		int line = input.nextInt();
		// 定义二维数组存放数据
		int[][] nos = new int[line][line];
		
		// 定义初始值为1，进行累加
		int num = 1;
		
		// 给二维数组赋值
		for (int i = 0; i < nos.length; i++) {
			for (int j = i; j < nos[i].length; j++) {
				nos[j][i] = num++;
			}
		}
		
		// 遍历二维数组，排除默认值0
		for (int i = 0; i < nos.length; i++) {
			for (int j = 0; j < nos[i].length; j++) {
				// 如果是0，不输出
				if(nos[i][j] == 0){
					continue;
				}
				System.out.print(nos[i][j] + " ");
			}
			System.out.println();
		}
		input.close();