java的一些基本概念
关键字
关键字：是被java语言赋予特定含义的单词
特点：组成关键字的字母全部小写
goto和const作为保留字存在，目前并不使用（jdk1.7中）
保留字：在jdk新版中可能提升为关键字
关键字
用于定义数据类型的关键字：class interface[接口] byte short int long float double char boolean void
用于定义数据类型值的关键字：true false null
用于定义流程控制的关键字：if else switch case default while do for break continue return
用于定义访问权限修饰符的关键字：public protected private
用于定义类，函数，变量修饰符的关键字：abstract final static synchronized[同步]
用于定义类与类之间关系的关键字：extends implements
用于定义建立实例与引用实例，判断实例的关键字：new this super instanceof [实例]
用于异常处理的关键字：try catch finally throw throws
用于包的关键字：packge import
其他修饰符关键字：native[本地] strictfp[精确浮点] transient[短暂的,用于无需序列化] volatile[易变的，保证单次读/写的原子性] assert[宣称]
标识符
标识符就是给类，接口，方法，变量等起名字时使用的字符序列
组成规则：英文字母，数字字符，美元符$和下划线_（只有这几种，不能出现#￥之类的）
Tips：不能以数字开头，不能是java的关键字，严格区分大小写，不能出现空格。
常见命名规则：见名知意
包：其实就是文件夹，用于把相同的类名进行区分（全部小写）
单级：xxx
多级：cn.xxx
类或者接口：
一个单词：单词的首字母必须大写
多个单词：每个单词的首字母必须大写[驼峰原则]
方法或者变量：
一个单词：单词的首字母必须小写
多个单词：从第二个单词开始，每个单词的首字母大写[驼峰原则]
常量：
一个单词：全部大写
多个单词：每个字母都大写，用_隔开
常量
在程序执行的过程中其值不可以发生改变
分类：
1.字面值常量
字符串常量：用双引号括起来的内容
整数常量：所有整数
小数常量：所有小数
字符常量：用单引号括起来的单个字符
布尔常量：较为特有，只有false和true
空常量：null
2.自定义常量（final int x=10;）
整数常量提供了4种表现形式：
二进制（binary）：由0，1组成，以0b开头，或者结尾+B
八进制(octal)：由0，1，…7组成，以0开头，或者结尾+O
十进制(decimal)：由0，1，…9组成，默认是十进制,或者结尾+D
十六进制(hex)：由0，1，…，9，a，b，c，d，e，f（大小写均可），以0x开头,或者结尾+H
1byte=8bit 1个字节=8位
1k=1024byte
1m=1024k
1g=1024m
1t=1024g
进制越大，表现形式越短。
二、八、十、十六进制间转换：
二进制转换为八进制：把二进制的数据，从右开始，每三位一组合，最左边不够的时候补0。然后分别计算出对应的十进制数值，最后把每个十进制的数据组合起来就是一个八进制数据。
二进制转换为十六进制：十六进制就是每4位组合。
二进制转换为十进制：8421码。8421码是中国大陆的叫法，8421码是BCD码中最常用的一种。在这种编码方式中每一位二值代码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的十进制数码。
变量
在程序执行的过程中，在一定范围内其值可以发生改变的量。本质上来说，变量其实是内存中的一小块区域，使用变量名来访问这块区域。因此，每个变量使用前必须要先申请（声明），然后必须进行赋值（填充内容）才能使用。
变量可以用来不断的存放同一类型的常量，并且可以重复使用。
定义格式(固定的)：
数据类型 变量名=初始化值；
Java是强类型语言，对于每一种数据类型都定义了明确的具体数据类型，由内存总分配了不同大小的内存空间。
作用域：变量定义在那一级大括号中，哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量。
没有初始化值不能直接使用，只要在使用前给值即可，不一定非要在定义的时候给值，推荐在定义的时候给值。
eg： 数据类型 变量名；
变量名=初始化值；
一行建议只定义一个变量，可以定义多个，但是不建议。
数据类型：
1.基本数据类型：4类8种
数值型：
⑴整数型
byte 1字节 -2^7^
2^7^ -128127short 2字节 -2^15^
2^15^-1 -3276832767int 4字节 -2^31^
2^31^-1 -2,147,483,6482,147,483,647 默认为intlong 8字节 -2^63^~2^63^-1 19位数 长的整数型变量后缀使用L或l，建议使用L。因为l会和1分不清
⑵浮点类型
float 4字节 -3.403 E^38^
3.403E^38^ （2^-127^2^128^） 单精度浮点数用F或f，建议使用Fdouble 8字节 -1.798E^308^
1.798E^308^ （2^-1023^2^1024^） 默认为 double字符型：char 2字节 （可以存储中文汉字）
布尔型：boolean 1字节
2.引用数据类型：
类：class
接口：interface
数组：[]
一般来说，我们在运算的时候，要求运算的数据类型必须一致。boolean类型不能转换为其他数据类型
默认转换，隐式转换（从小到大的转换）：
byte,short,char→int→long→float→double 出现后面的数据类型，结果必须为最后面的数据类型
byte,short,char相互之间不转换，他们一旦参与运算首先要转换成int数据类型
long是8字节，float是4字节，可以转换是因为它们的底层的存储结构不同；float表示的数据范围比long 的范围要大。
强制转换，显示转换（从大到小的转换）：
格式：目标数据类型 变量=（目标数据类型） （被转换的数据）；
不要随意使用强制转换，因为它隐含了精度损失的问题。其结果是数据的补码在计算机内被截断后的值。
byte的范围是-128~127，当（byte）128，其实输出的是-128。（byte）129输出的是-127
128：10000000
-128：10000000（这里的1既是符号位，也是数值位）
变量相加，会首先看类型问题，最终把结果赋值的时候也会考虑类型问题。
常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才会报错。
eg：
1.一个字符，结果就是一个字符。
2.一个字符+一个整数：参考ASCII表，结果为int整数型
‘0’ 48 ‘A’ 65 ‘a’ 97
3.字符串+一个字符+整数：第一个+是连接符。字符串+整数
4.一个字符+整数+字符串：第一个+是加号，ASCII表运算成整数类型。整数+字符串
规则：第一个东西和第二个东西先进行运算并输出，在计算第三个，第四个。
局部变量和成员变量的区别：
1.在类中的位置不同：
局部变量：在方法定义中或者方法声明上。
成员变量:在类中方法外。
2.在内存中的位置不同：
局部变量：在栈内存
成员变量：在堆内存
3.生命周期不同：
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
成员变量：随着对象的创建而存在，随着对象的消失而消失
4.初始化值不同：
局部变量：没有默认初始化值，必须定义，赋值然后才能使用
成员变量：有默认的初始化值
注意事项：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
运算符
运算：对常量和变量进行操作的过程称为运算
运算符:对常量和变量进行操作的符号称为运算符
操作数：参与运算的数据称为操作数
表达式：用运算符把常量或变量连接起来符合java语法的句子可以称为表达式
1.算术运算符： +，-，*，/，%，++，–
+的用法：a.加法 b.正号 c.字符串连接符
整数相除只能得到整数，若要得到小数，需要把操作的数据中的任意一个数据变为浮点数类型。
/获取的是除法操作的商，%获取的是除法操作的余数。
++自增1，–自减1。就是对变量进行自增或者自减。只能对变量
单独使用：放在操作数前或者操作数后效果一样（常用）
参与运算使用：放在操作数的前面++a，先自增或自减再参与运算（赋值）。放在操作数的后面a++，先参与运算（赋值）再自增或自减。
2.赋值运算符
基本的赋值运算符：=
把=右边的数据赋值给左边（左边必须是变量）
扩展的赋值运算符：+=，-=，*=，/=，%=
+=把左边和右边做加法，然后赋值给左边。（左边必须是变量）
s +=1;不是等价于s = s+1;而是等价于s = （s的数据类型）（s+1）； 扩展的赋值运算符其实隐含了一个强制类型转换。
3.比较运算符（关系运算符）
==，！=，<,>,<=,>=,instanceof(检查是否是类的对象)
无论操作是简单还是复杂，比较运算符的结果都是boolean型，要么是true，要么是false。
“==”不能写成”=”
4.逻辑运算符
&与（AND） ()&() 有false则false
|或（OR） ()|() 有true则true
^异或（XOR） ()^() 相同为false，不同为true
！非（NOT） !() 非false则true，非true则false，偶数个不改变本身。
&&短路与（AND） ()&&()
||短路或（OR） ()||()
逻辑运算符用于连接布尔型表达式，不能写3<x<6,而应该是x>3&x<6。
&和&&的区别（|和||同理）：最终结果一样
单&时，左边无论真假，右边都会进行运算。
双&时，若左边为真，右边参与运算，若左边为假，右边不参与运算（不执行）。
开发中常用的逻辑运算符：&&，||，！
5.位运算符
&位与运算 有0则0
|位或运算 有1则1
^位异或运算 相同为0，不同为1
~按位取反运算符 0变1，1变0 （在计算机中，所有参与运算的都是补码）
<<左移 左边最高位丢弃，右边补齐0 把<<左边的数据乘以2的移动次幂
>>右移 最高位是0，左边补齐0；最高位是1，左边补齐1 把>>右边的数据除以2的移动次幂
>>>无符号右移 无论最高位是0还是1，左边都补齐0
要做位运算，首先要把数据转换为二进制。
&和|：两边是boolean型，代表逻辑与/或短路 两边是数据类型，代表的是位运算。
^的特点：一个数据对另一个数据位异或两次，该数本身不变。（应用：数据加密，异或后发给你，你在异或一下就得到原数据）
eg：实现两个整数变量的交换：a b
使用第三方变量（开发中用）
c=a a=b b=c
使用位异或实现(面试用)
左边aba，右边a^b： a=a^b b=a^b a=a^b
用变量相加的做法
a=a+b b=a-b a=a-b
一句话搞定
b=(a+b)-(a=b)
6.三目运算符
（关系表达式）？表达式1：表达式2
关系表达式结果为true，则结果为表达式1，为false，则结果为表达式2.
（单目运算符：~3 双目运算符：3+4 ）
数组
存储同一数据类型的多个元素的容器。
定义格式：（2种）
数据类型[] 数组名; 定义一个该数据类型的数组（数组名）变量
数据类型 数组名[]; 定义一个该数据类型的（数组名）数组变量
建议使用第一种，因为其他语言（如C#）正在淘汰第二种。
数组的初始化：java中的数组必须先初始化，然后才能使用。
初始化就是为数组中的每个元素分配内存空间，并为每个元素赋值。
初始化方式：（2种）
- 动态初始化：初始化时只指定数组的长度，由系统为数组分配初始值。
格式： 数据类型[] 数组名= new 数据类型[数组长度];
eg： int[] arr = new int [4];
int：说明数组中元素的数据类型是int类型
[]：说明这是一个数组
arr：数组的名称
new：为数组分配内存空间
int：说明数组中元素的数据类型是int类型
[4]：说明这是一个长度为4的数组，数组中元素的个数为4
这时候直接打印输出arr的值 就是arr的内存地址值。
数组中的每个元素都是有编号的，并且是从0开始，最大编号是数组的长度-1。
用数组名和编号的组合就可以获取数组中的指定编号的元素，这个编号叫索引。
通过数组名访问数据的格式是：数组名 [索引]
arr[0]、arr[1]、arr[2]、arr[3]没有赋值时，均为默认值。
- 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式： 数据类型[] 数组名 = new 数据类型[]{元素1，元素2，…}；
eg: int[] arr = new int[]{1,2,3};
简化写法int[] arr={1,2,3};
arr的输出值就是arr的地址值。
注意 不要同时动态和静态进行初始化。
数组操作的两个常见小问题：
1.数组索引越界异常（ArrayIndexOutOfBoundsException）：你访问了不存在的索引。
2.空指针异常(NullPointerException)：数组已经不再指向堆内存了，而你还用数组名去访问元素。引用类型的常量：空常量 null
eg：arr=null；
数组常见方法
- 数组遍历：依次输出数组中的每一个元素。
1 | public static void printArray(int[] arr){ |
- 数组获取最值：获取数组中的最大值、最小值。
1 | public static int getMax(int[] arr) { |
- 数组元素逆序：元素对调。
1 | public static void reverse(int[] arr) { |
数组查表法：根据键盘录入索引，查找对应元素。
数组元素查找：查找指定元素第一次在数组中出现的索引。如果找不到数据，我们一般返回一个负数即可，一般是-1。
数组排序和二分查找。
二维数组：元素为一维数组的数组。
格式1：
列是一样的用: 数据类型[] [] 数组名=new 数据类型[m] [n];
m表示这个二维数组有多少个一维数组。
n表示每一个一维数组的元素个数。
以下两个格式也可以但是不推荐：
数据类型 数组名[] []=new 数据类型[m] [n];
数据类型[] 数组名[]=new 数据类型[m] [n];
int x,y; 定义了一个x，一个y的int型数据。
int[] x,y[]; 定义了一个x的一维数组和一个y的二维数组。
格式2：
列是变化的用: 数据类型[] [] 数组名=new 数据类型[m] [];
m表示这个二维数组有m个一维数组
一维数组的元素个数可以动态给出。
格式3：
静态初始化： 数据类型[][] 数组名=new 数据类型[][]{{ 元素1，元素2，.... }, { 元素1，元素2，.... }, { 元素1，元素2，.... }};
简化版：数据类型[][] 数组名={{元素1，元素2，....}, {元素1，元素2，....}, {元素1，元素2，....}};
二维数组的遍历：
外循环控制的是二维数组的长度，也就是一维数组的个数。
内循环控制的是一维数组的长度。
1 | for(int x = 0;x<arr.length;x++) |
方法
方法就是完成特定功能的代码块。（在很多语言里面都有函数的定义，函数在java中被称为方法）
格式：
1 | 修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2，...）｛ |
修饰符： public static
返回值类型：就是返回结果的数据类型。
方法名：符合命名规则即可，方便我们调用。
参数：
实际参数：就是实际参与运算时填入的参数。
形式参数:就是方法定义上的，用于接收实际参数。
形式参数的类型有2种：基本类型和引用类型。
基本类型（4类8种）中形式参数的改变不影响实际参数。
引用类型（类、接口、数组）中形式参数的改变直接影响实际参数。
如果一个方法的形式参数是一个类类型（引用类型），实际参数需要的是这个类的对象。
参数类型：参数的数据类型
参数名：变量名
方法体语句：完成功能的代码。
return：结束方法，用于返回结果。
返回值：就是功能的结果，由return带给调用者。
要写一个方法，必须明确两个东西：
A：返回值类型：结果的数据类型
B：参数列表：要传递的参数及参数类型。
方法的执行特点：不调用，不执行。
调用：
A：单独调用，一般来说没有意义，所以不推荐
B：输出调用，但是不够好，因为可能需要针对结果进行进一步的操作。
C：赋值调用，推荐方案。
方法的注意事项：
1.方法不调用，不执行。
2. 方法与方法之间是平级关系，不能嵌套定义。
3.方法定义的时候参数之间用逗号隔开。
4.方法调用的时候不用再传递数据类型。
5. 如果方法有明确的返回值，一定要有return带回一个值。
void类型返回值的方法调用：无返回结果，只有单独调用一种。
方法的重载：方法的功能相同，参数列表不同的情况，为了见名知意，java允许它们起一样的名字。jvm会根据不同的参数调用不同的功能。
方法重载的特点：与返回值类型无关，只看方法名和参数列表。在调用时，虚拟机通过参数列表的不同（参数个数、类型不同）来区分同名方法。
//一个方法不能访问另一个方法中的局部变量。
类
单独开一个文章总结。
包
其实就是文件夹。
作用：把相同的类名放到不同的包中；对类进行分类管理。
1.可以按照功能分（增加、删除、修改、查找）
2.可以按照模块分（推荐）
包的定义： package 包名；
多级包用.分开即可
注意事项：
package语句必须是程序的第一条可执行（可被虚拟机识别）的代码。package语句在一个java文件中只能有一个。如果没有package，默认表示无包名
带包的编译和运行：
手动式：
a.编写一个java文件
b.通过javac命令编译该java文件
c.在文件夹中的当前目录下手动创建包名
d.把b步骤的class文件放到c步骤的最底层包
e.回到和包根目录在同一目录的地方，然后带包运行
java cn.xxx.类名自动式：
a. javac编译的时候带上-d即可（eg：
javac -d . 类名.java）b.通过java命令执行。和手动式一样
不同包下类之间的访问，每次都需要加包的全路径，会很麻烦，所以java提供了导包功能。
导包格式：import 包名；
注意：
这种方式导入是到类的名称import cn.xxx.类名；虽然可以写import cn.xxx.代表导入这个cn.xxx包下的所有类，但是不建议。建议我们用谁导入谁。
package(只能有一个)->import(可以有多个)->class(可以有多个，以后建议是一个，使结构清晰)
权限修饰符：
public:同一个类中；同一个包下子类，无关类；不同包下该类是那个包的类的子类；不同包下无关类
protected:同一个类中；同一个包下子类，无关类；不同包下该类是那个包的类的子类
默认：同一个类中；同一个包下子类，无关类
private:同一个类中
总结：如果想都访问，用public；如果想访问不同包的子类，用protected（pretected是用来修饰子类的）；如果只想同一个包内访问用默认，不加；如果只想在本类中访问，用private。
修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
类及其组成可以用的修饰符：
类：默认，public；final，abstract 经常使用的是public
成员变量：四种权限修饰符均可；final,static 经常使用的是private
构造方法：四种权限修饰符均可；其他不可 经常使用的是public
成员方法：四种权限修饰符均可；final,static,abstract 经常使用的是public
注：自己写项目时的类名不要和常用的API的类名相同。
复制代码的时候，很容易把那个类所在的包也导入过来，容易出现不能理解的问题。