Java基础

一、基础语法

1.二进制

（1）概述
计算机中的数据都是以二进制数字存储的。二进制，即逢二进一，只有0和1两个值。比如十进制的10在计算机内保存为二进制的1010.
（2）计算机中信息的存储单位
位（Bit）:表示一个二进制数字0或1，是计算机存储处理信息的最基本的单位。
字节（Byte）：一个字节由8个位组成。它表示作为一个完整处理单位的8个二进制数码。
（3）补码
事实上，计算机内的二进制数值是以补码形式表示的。
正数的补码：一个正数的补码和原码的形式是相同的。
负数的补码：将该数的绝对值的二进制形式，按位取反再加1。
补码详解：https://blog.csdn.net/zl10086111/article/details/80907428
二进制补码数值的最高位是符号位：该位位0，表示数值为正数；该位为1，表示数值为负数。以10和-10为例：

原码	补码
00001010	00001010
10001010	11110110

使用补码，可以将符号位和其他位进行统一处理；同时，减法也可以按加法来处理。另外，两个用补码表示的数相加时，如果最高位有进位，则进位被舍弃。
比如2-2，
2-2=2+（-2）=【00000010】+【10000010】
【00000010】+【11111110】=【00000000】
（4）十进制和二进制之间的转换
二进制转成十进制
按权相加：把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。例：1011.01=8+0+2+1+0+0.25=11.25
十进制转成二进制：
正数部分：“除2取余，逆序排列”法
小数部分：“乘2取整，顺序排列”法

整数	小数
12	0.625
2 12-----0	x2—1.25—1
2 6-----0	x2—0.5—0
2 3-----1	x2—1.0—1
2 1-----1	0.101
二进制位：1100

（5）二进制与十六进制之间的转换
二进制表示法太冗长，所以在程序中一般喜欢使用十六进制。
十六进制：基数为16.逢十六进1.它用abcdef表示0-9之上的值。Java中的十六进制要以0x或0X开头。
十六进制转换成二进制只需要将每个十六进制数字替换为相对应的四个二进制即可。

二进制	十六进制
0000	0
0001	1
0010	2
0011	3
0100	4
0101	5
0110	6
0111	7
1000	8
1001	9
1010	A
1011	B
1100	C
1101	D
1110	E
1111	F

（6）八进制
八进制：基数为八；Java中的八进制要以0开头。如：0123
八进制转换成二进制：只需要将每个八进制数字替换为相对应的三个二进制位即可。

二进制	八进制
000	0
001	1
010	2
011	3
100	4
101	5
110	6
111	7

2.变量

概述：变量就是系统为程序分配的一块内存单元，用来存储各种类型的数据。由于该存储单元中的数据可以发生改变，因此得名为‘变量’。
（1）变量分类
a、按所属的数据类型划分
基本数据类型变量
引用数据类型变量
b、按被声明的位置划分
局部变量：方法或语句块内部定义的变量
成员变量：方法外部、类的内部定义的变量
特别注意：类的外面不能有变量的声明

3.数据类型

由于变量记录的数据内容大小不同，导致所需的存储单元大小不同，在Java语言中使用数据类型的加以描述。
（1）数据类型分类
8种基本数据类型：byte short int long float double char boolean
引用数据类型：类 接口 数组

类型	占用内存	值范围	默认值
int	4字节	-2 147 483 648 ~ 2 147 483 647（稍大于 20 亿dou）	0
short	2字节	-32 768 ~ 32 76	0
long	8字节	-9 223 372 036 854 775 808L ~ 9 223 372 036 8	0
byte	1字节	-128~127	0
float	4字节	–	0.0f
double	8字节	—	0.0d
boolean	1字节	true或false	false
char	2字节	‘ \u0000 - u\ffff ’	‘\u0000 ’

4.标识符

Java对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。规则如下：
a.由字母、数字、下划线和美元符号$组成
b.不能以数字开头
c.区分大小
d.长度无限制
e.不能时Java种的保留关键字
标识符命名习惯：见名知意

5.类型转换

Boolean类型不能转换成任何其他数据类型。
（1）自动类型转换：容量小的类型自动转换成容量大的数据类型
byte short int->float->long->double
byte,short,int不会相互转换，他们三者在计算时会转换成int类型。
（2）强制类型转换：容量大的类型转换成容量小的数据类型时，要加上强制转换符。有可能造成精度降低或数据溢出，使用时要小心。

6.方法

概述：方法用于封装一段特定的逻辑功能。方法的主要要素有：权限修饰符、方法名、参数列表和返回值。
（1）格式：
权限修饰符 返回值类型声明 方法名称（参数列表）{方法种封装的逻辑功能；返回值；}
（2）权限修饰符详解：

（3）返回值详解：
方法调用结束后可以返回一个数据，称之为返回值。方法在声明时必须指定返回值的类型。通过return语句返回，return语句的作用在于结束方法且将数据返回。
（4）参数列表详解
方法的参数列表：在调用时传递给方法，需要被方法处理的数据；在方法定义时，需要声明该方法所需要的参数变量；在方法调用时，会将实际参数值传递个体方法的参数变量，必须保证传递参数的类型和个数符合方法的声明。

7.运算符

（1）算术运算符

运算符	描述	示例	结果
+	加	10+10	20
-	减	3-2	1
*	乘	2*3	6
/	除	6/2	3
%	取模（求余）	10%3	1
++	自增（前后）
–	自减（前后）

（2）赋值运算符
赋值运算符作用是将一个值赋给一个变量，运算顺序从右向左。

运算符	描述	示例	结果
=	赋值	a=3	a=3
+=	加等于	a=3;b=2;a+=b;	a=5
-=	减等于
*=	乘等于
/=	除等于
%=	模等于

（3）关系运算符
关系运算符作用是比较两边的操作数，结果总是boolean类型的。

运算符	描述	示例	结果
==	相等于	3==3	true
!=	不等于	4！=3	true
<	小于
>	大于
<=	小于等于
>=	大于等于

（4）逻辑运算符
逻辑运算符用于对Boolean类型结果的表达式进行运算，运行结果总是Boolean类型。

运算符	描述	示例	结果
&	与	false&true	false
l	或	falseltrue	true
^	异或	true^false	true
!	非	!true	false
&&	短路与	false&&true	false
ll	短路或	false ll true	true

（5）三目运算符
X?Y:Z
X为Boolean类型表达式，先计算X的值，若为true，整个三目运算符的结果为表达式Y的值，否则整个运算结果为表达式Z的值。
（6）操作符优先级
表达式的运算按照运算符的优先顺序从高到低进行，同级运算符从左到右执行。

优先次序	运算符
1	.
2	++ – ! ~ instanceof
3	new(type)
4	* / %
5	+ -
6	>> >>> <<
7	< > <= >=
8	== !=
9	&
10	^
11	l
12	&&
13	ll
14	?:
15	= += *= /= %= ^=
16	&= l= <<= >>= >>>=

8.转义符

二、流程控制

执行结构

概述：任何简单或复杂的算法都可以由顺序结构、分支结构和循环结构这三种基本结构组合而成。它们的共同点是都包含一个入口和一个出口，它们的每个代码都有机会被执行，不会出现死循环。
（1）顺序结构
顺序结构是一种基本的控制结构，它按照语句出现的顺序执行操作。
（2）分支结构
分支结构又被称为选择结构，根据条件成立与否来执行操作。
a. if条件语句
if条件结构是根据条件判断之后再做处理。
if(条件语句){…}
if (条件语句){…}else{…}
if (条件语句){…}else if(条件语句){…}
if (条件语句){…}else
b. switch语句
switch(表达式){
case 取值 1: 语句块 1;break;
case 取值 n: 语句块 n;break;
default: 语句块 n+1;break;
}
switch语句有关规则：
表达式的返回值必须是下述几种类型之一：int,byte,char,short,String
case子句中的取值必须是常量，且所有case子句中的取值应是不同的； default子句是可选的；break语句用来在执行完一个case分支后使程序跳出 switch语句块；如果case后面没有写break则直接往下面执行。

（3）循环结构是一种重复结构，如果条件成立，它会重复执行某一循环体，直到出现不满足的条件为止。
循环语句分类：
a.for循环

for（初始化参数；判断条件；更新循环变量）{
循环体；
}

b. while循环
符合条件，循环继续执行；否则，循环退出。
特点：先判断，再执行

while（条件表达式）{
语句块；
}

c. do-while循环
先执行一遍循环操作，符合条件，循环继续执行；否则，循环退出。
特点：先执行，再判断。

do{
循环操作；
}while（条件表达式）；

三、数组

概述：数组是相同数据类型的多个数据的容器。这些元素按线性顺序排列。所谓线性顺序是指除第一个元素外，每一个元素都有唯一的一个前驱元素；除最后一个元素外，每一个元素都有唯一的后继元素。

1.创建格式

（1）数据类型[] 数组名称=new 数据类型[数组长度]
（2）数据类型[] 数组名称={数组内容1，数组内容2，…，数组内容n}；
（3）数组类型[] 数组名；只是创建了数组引用名，并未再内存创建数组空间。
（4）数据类型[] 数组名称 = new 数据类型[]{内容1，内容2，…，内容n};

2.下标

可以理解为数组中内容的数字序号，从0开始，对于长度为n的数组，下标的范围是0~n-1。可以通过下标的方式访问数组中的每一个元素。
注意：数组的长度在创建时就固定了。

3.数组常用算法

（1）冒泡排序
原理：
比较相邻的元素，如果第一个比第二个大，就交换他们两个；
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，在这一点，最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

//升序
    public static void sort(int[] arr){
        int temp;
        for(int i = 0 ; i < arr.length-1;i++){
            for(int j = 0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    //降序
    public static void sort1(int[] arr){
        int temp;
        for(int i = 0 ; i < arr.length-1;i++){
            for(int j = 0 ; j < arr.length-i-1;j++){
                if(arr[j]<arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

（2）二分查找
概述：二分查找也称为折半查找，它时一种效率较高的查找方法。但是，二分查找要求数组数据必须采用顺序存储结构有序排列。

	 原理：首先，假设数组中元素是按升序排列，将数组中间位置的数据与查找数据比较，如果两者相等，则查找成功；否则利用中间位置记录将数组分成前后两个子数组，如果中间数据大于查找数据，则进一步查找前子数组，否则进一步查找后子数组。重复这个过程，直到找到满足条件的数据，则表示查找成功；直到子数组不存在为止，便是查找不成功。

public static int find(int[] arr,int num){
        int maxIndex = arr.length-1;
        int minIndex = 0;
        int centerIndex = (maxIndex+minIndex)/2;
        while(true){
            if(num > arr[centerIndex]){
                minIndex = centerIndex+1;
            }else if(num < arr[centerIndex]){
                maxIndex = centerIndex-1;
            }else{
                break;
            }

            if(minIndex>maxIndex){
                centerIndex = -1;
                break;
            }
            centerIndex = (maxIndex+minIndex)/2;
        }
        return centerIndex;
    }