一.标识符和关键字
1.1:标识符
概念：Java对各种变量，方法和类等要素命名时使用的字符序列称为标识符
规则：1.标识符由字母，下划线，美元符或数字组成
2.标识符应由字母，下划线，美元符开头
3.Java标识符大小写敏感，长度没有限制
约定：Java标识符要见名知意，且不能与关键字重名
这里有一道自己实习找工作遇到的一道笔试题：
T1:在java中，下列标识符不合法的有（ ）
A:new B:$Usdollars C:1234 D:car.taxi E:Hello Word
1.2:关键字
概念：Java中一些赋以特定含义，拥有特殊用途的字符串叫做关键字，所有的Java关键字都是小写英文
问题：既然Java关键字都是小写英文，如果将关键字大写，在严格区分大小写的Java中会不会报错呢？答案是否定的，关键字大写后不再被当作关键字。
关键字的分类：
用于控制访问相关4个：public(公共的)、protected(受保护的，同一个包中的其它类及子类可以访问。)、 缺省的、 private(私有的，本类可以访问)
修饰符与包及类之间的关系以及访问关系：
| public | protected | 缺省 | private | |
|---|---|---|---|---|
| 本类 | 可以 | 可以 | 可以 | 可以 |
| 同包子类 | 可以 | 可以 | 可以 | 不可以 |
| 同包非子类 | 可以 | 可以 | 可以 | 不可以 |
| 不同包子类 | 可以 | 可以 | 不可以 | 不可以 |
| 不同包且非子类 | 可以 | 不可以 | 不可以 | 不可以 |
类、接口、抽象类相关、实例化对象相关6个:abstract（抽象的）class（定义类）、interface（定义接口）implements（实现）、extends（继承）new（创建新对象）
程序控制相关12个：if（如果）、else（否则） 、instanceof（判断一个对象是否是某个类的实例）switch（开关）、case（switch语句的一个条件）、break（跳出循环/跳出switch语句块）、default（switch语句的默认分支，当所有的case都不满足条件时会执行）for（for循环语句）、do（循环语句，循环体至少会被执行一次）、while（当.....时）、continue（结束本次循环，继续下一次循环）return（返回...，用于跳出方法）、
修饰方法，变量方法相关8个：static（静态的）、final（最终的不可被改变的）、const（const是Java预留关键字，用于后期扩展用，用法跟final相似，不常用）native（表示方法用非java代码实现）synchronized（线程同步的）transient（修饰不要序列化的字段）volatile（标记字段可能会被多个线程同时访问）strictfp（严格的/精准的）
异常处理相关5个：try（捕获异常）、catch（处理异常）、finally（有无异常都会执行）throw（抛出一个异常对象）、throws（声明一个方法可能抛出异常）
包相关2个：import（引入包）package（定义包）
数据类型相关8个：8种基本数据类型：byte、short、int、long、float、double、char、boolean
变量引用相关3个：super（调用父类的方法/构造函数/成员变量）this（表示调用当前实例的成员变量或方法/调用另一个重载的构造函数）void（没有返回值）
其他相关2个：assert（断言条件是否满足，满足则继续向下执行，不满足则抛出异常终止执行）、enum(枚举类型)
保留字：goto const false true。
关于关键字的笔试面试题倒是很少遇到，但是某些关键字的用处其实遇到次数挺多的：比如：static修饰的变量方法有什么，volatile的作用，final,finally,finallze的区别。
二.基本数据类型
2.1:常量
Java的常量值用不同的数据类型字符串表示，
比如：整数型：123 字符常量 'a' 逻辑常量：true false 字符串常量："Hello World!"
2.2变量
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
Java中每一个变量都属于特定的数据类型，在使用前必须申明变量类型：
int i = 1;
float f = 12.3f 注意float a = (float)1.3;或者float a = 1.3f;（f或F都可以不区分大小写）
double d=1.3 注意和单精度浮点数float区分
String name ="关注每天学Java公众号";
2.2.1变量的分类
1.按声明位置划分
局部变量：在方法或者语句块内部定义的变量
成员变量：在方法的外部，类的内部定义的变量
2.所属数据类型划分
基本数据类型变量
引用数据类型变量
2.2.2 局部变量和成员变量
public class Test{
public int i;//成员变量
public void method(){
int j;//局部变量 局部变量不允许使用访问修饰符修饰
}
}
2.3 基本数据类型的转换
boolean类型不可转换为其他的数据类型
整形，字符型，浮点型的数据在混合运算中相互转换要准守如下规则
容量小的类型自动转换为容量大的数据类型：
byte,char,short > int > long > float > double
byte,char,short不会相互转换，他们在计算式先转换成int类型
容量大的类型转换成容量晓得类型要加上强制转换符，可能会造成精度降低或者溢出
public class TestConvert {
public static void main(String arg[]) {
int i1 = 123;
int i2 = 456;
double d1 = (i1+i2)*1.2;//系统将转换为double型运算 因为小的类型会自动转换为大的数据类型 1.2 默认是double类型
float f1 = (float)((i1+i2)*1.2);//需要加强制转换符 (i1+i2)*1.2是double类型，如果用float接受 需要使用强制转换因为 double类型大于float
byte b1 = 67;
byte b2 = 89;
byte b3 = (byte)(b1+b2);//系统将转换为int型运算，需要强制转换符
System.out.println(b3);
double d2 = 1e200;
float f2 = (float)d2;//会产生溢出
System.out.println(f2);
float f3 = 1.23f;//必须加f
long l1 = 123;
long l2 = 30000000000L;//必须加l
float f = l1+l2+f3;//系统将转换为float型计算
long l = (long)f;//强制转换会舍去小数部分（不是四舍五入）
}
}
三.运算符与表达式
3.1Java运算符分类：
算术运算符：+ - * / % ++ --;
关系运算符：> < <= >= == !=
逻辑运算符：! & | ^ && ||
位运算符：& | ^ ~ >> << >>>
赋值运算符：=
扩展赋值运算符：+= -= /= *=
字符串连接运算符：+
扩展点：
1.位运算速度执行快：说一个例子：在Java集合框架中，我们会看到很多位运算（位运算以二进制位基础计算，我们思维通常是使用十进制，所以刚开始会很不适应）：
static final int MAXIMUM_CAPACITY = 1 << 30;//最大容量2的30次方
<< 按位左移运算符。左操作数按位左移右操作数指定的位数。
>> 按位右移运算符。左操作数按位右移右操作数指定的位数。
static final int hash(Object key) {
int h;
// 使用（hashCode的值）以及（hashCode的值无符号右移16位）做异或操作
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
^如果相对应位值相同，则结果为0，否则为1
>>>按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。
static int indexFor(int h, int length) {
return h & (length-1); //位运算取模
}
& 如果相对应位都是1，则结果为1，否则为0
~ 按位取反运算符翻转操作数的每一位，即0变成1，1变成0。
| 如果相对应位都是0，则结果为0，否则为1
HashMap有很多优秀的语句值得我们去学习，笔者实力有限，并不能做到运用到实际项目中，所以只是展示下部分源码，有兴趣的小伙伴可以去看一下。
2.& ^ | 是逻辑运算符也是位运算符，具体的场景要具体分析：
在当做逻辑运算符时
&(与): 只要有一边为fale, 那么就是false
|(或): 只要有一边为true, 那么就是true
^(异或): 只要是相同的boolean值, 那么就是false, 不相同才是true
3.++ -- 不是原子计算
四.流程控制语句
语句：
条件语句
if //如果条件为true则执行
if...else //如果if条件为true执行if语句，否则执行else语句
if...else if //同上
if...else if...else if...else //有一条执行就不会再判断后续天剑
switch
swtich()变量类型只能是int、short、char、byte和enum类型。当进行case判断时，JVM会自动从上到小扫描，寻找匹配的case。
注意：在我笔试的经历中，遇到一个这样题：
int i = 2;
switch(i){
case 0:
System.out.println("0");
case 1:
System.out.println("1");
case 2:
System.out.println("2");
case 3:
System.out.println("3");break;
default:
System.out.println("default");
}
当时我回答的是2.实际上是2，3。我忽略了break的作用；
switch case执行时，一定会先进行匹配，匹配成功返回当前case的值，再根据是否有break，判断是否继续输出，或是跳出判断。
还需注意的是case后面只能是常量，可以是运算表达式，但一定要符合正确的类型。不能是变量，即便变量在之前进行了赋值，JVM依然会报错。
循环语句
for
while
do while
看一道for循环的笔试题：
public class Test{
static boolean foo(String c){
System.out.println(c)
return true;
}
public static void main(String[] args){
int i=0;
for(foo("A");foo("B")&&(i<2);foo("c")){
i++;
foo("D")
}
}
}
输出结果是什么？
ABDCBDCB
解释：
for第一个分号前赋初值
第一个分号后条件判断
第三个是增量
先调用A，判断B并且i=0 进入循环 i=1,调用D，增量调用C，在判断B并且I=1，进入循环 I=2 调用D，调用增加C，
最后判断B 但I=2不满足I<2条件，跳出FOR循环，程序结束while我觉得没什么可以说的，满足while里面的条件就会执行方法体
do while先执行语句然后再判断
这里再说说：
break 语句 终止某个语句块的执行，在循环语句体系中，可以强制退出循环
Continue 语句 用于终止某次循环过程
五.数组
定义
dataType [ ] arrayVar;
dataType arrayVar [ ];
说明：首先dataType它可以是基本数据类型比如 int array [ ];也可以是引用类型 比如Object [ ];
我们码代码的时候一般这样用：
dataType [ ] array = new dataType [arraySize] ;
其实上述代码做了两件事：
1、 dataType [ ] array声明了一个数组变量；
2 、使用new dataType[ arraySize] 创建了一个数组
当然除了上述方式，还有一种就是
dataType [ ] array={ vslue0, value1, value2, value3, .........value array.length-1}
数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 array.length-1。{
public static void main(String[] args) {
// 数组大小
int size = 10;
// 定义数组
double[] array = new double[size];
array[0] = 5.6;
array[1] = 4.5;
array[2] = 3.3;
array[3] = 13.2;
array[4] = 4.0;
array[5] = 34.33;
array[6] = 34.0;
array[7] = 45.45;
array[8] = 99.993;
array[9] = 11123;
// 计算所有元素的总和
double total = 0;
for (int i = 0; i < size; i++) {
total += array[i];
}
System.out.println("总和为： " + total);
}
}上面的都是一维数组，当然有一维就有多维， 多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组，
int array[ ][ ] = new int[2][3];
说明:上边代码是同样的两件事
int array [ ][ ] 是定义了一个二维数组变量 ，
new int[2][3] 是创建二维数组开辟存储空间//其中[2][3]中的2的意思可以理解为一维数组的长度3拥有3个元素，[3]可以理解为每一个元素中的一维数组的长度为4拥有4个元素。比如二维数组中第一个元素中索引为1的元素可以用 array[1][1]来表示。
下面来动态的定义一个二维数组
String s[][] = new String[2][];
s[0] = new String[2];//第0个元素指向new String[2];创建的数组 数字2说明第0个元素中的一维数组长度为3
s[1] = new String[3];//第1个元素指向new String[3];创建的数组 数字3说明地一个元素中的一维数组长度为4
s[0][0] = new String("I");//为二维数组的第0个元素赋值
s[0][1] = new String("LOVE");
s[1][0] = new String("YOU");
s[1][1] = new String("SO");
s[1][2] = new String("MUCH");说到数组这块常常会有 IndexOutOfBoundsException(数组越界异常) 可以说是Java代码中最常见的异常之一，还有一个是NullPointerException(空指针异常)后边详细介绍。
六.方法
方法是什么？
方法是语句的集合，它可以实现一个功能，比如println()方法他可以实现打印输出。
在java世界里方法是包含在类或对象中，方法创建于程序中，在其他地方被引用。
定义一个方法
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
比如;
public int addNumber(int a, int b){
int x=0;
x=a+b;
retutn x;
}
透过方法的定义我们归纳一下方法的定义规则：
1、命名规则,方法名一般以小写字母开头，后边的单词首字母大写，也可以用下划线链接，例如add_number
2、return后边跟的值的类型必须与返回值类型相同，除了void，因为void是无返回值的。
解析方法：
- 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
- 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
- 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
- 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 方法体：方法体包含具体的语句，定义该方法的功能如 int x=0; x=a+b;。
方法的调用：
当程序调用一个方法时，程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。
在java中一般支持两种方式的调用，一种是有返回值的方法作为值来使用例如：
int love=addNumber(519, 1);
另一种是返回值为void型的方法，例如 ：
System.out.print("欢迎关注每天学java！");
main方法：
学java可能最熟悉的就是main方法了。main 方法是被 JVM调用的，除此之外，main 方法和其它方法没什么区别。
main 方法的头部是不变的，如下所示，带修饰符 public 和 static,返回 void 类型值，方法名字是 main,此外带个一个 String[] 类型参数。String[] 表 明参数是字符串数组。
public class TestMax {
/** 主方法 */
public static void main(String[] args) {
int i = 5;
int j = 2;
int k = max(i, j);
System.out.println( i + " 和 " + j + " 比较，最大值是：" + k);
}
/** 返回两个整数变量较大的值 */
public static int max(int num1, int num2) {
return num1>num2? num1:num2;
}
}
方法的重载：
在main方法中我们定义了max(int num1, int num2)方法，那要是需要比较浮点数的大小呢，对，就是定义一个返回值为浮点型的max方法
/** 返回两个浮点数变量较大的值 */
public static float max(float num1, float num2) {
return num1>num2? num1:num2;
}
如果你调用max方法时传递的是int型参数，则 int型参数的max方法就会被调用；
如果传递的是float型参数，则float类型的max方法体会被调用，这叫做方法重载；
那么就上边的例子而言也就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表。Java编译器根据方法签名判断哪个方法应该被调用。
构造方法：
class Student {
int id;//学号
String name;//姓名
int age;//年龄
Student(String n) {//拥有一个参数的构造方法
name = n;
}
Student(int i, String n) {//拥有二个参数的构造方法
id = i;
name = n;
}
Student(int i, String n, int a) {//拥有三个参数的构造方法
id = i;
name = n;
age = a;
}
public void show() {//普通方法
System.out.println(id + " " + name + " " + age);
}
public static void main(String args[]) {
Student s1 = new Student("A@news");//创建一个我
Student s2 = new Student(250, "陈龙", 12);//创建一个陈龙
s1.show();//对象调用方法
s2.show();
}
}注意：在这个学生类中既有构造方法又有普通方法还有main方法，那么我们来对比一下他们的差异，从而来归纳特点：
| Java的构造方法 | Java的普通方法 |
|---|---|
| 构造器用于初始化对象的状态(数据) | 方法用于暴露对象的行为 |
| 构造方法不能有返回类型 | 方法一般都有返回值类型 |
| 构造方法的调用是隐式的 new studen("A@news") | 方法要显式调用 s1.show(); |
| 如果没有指定任何构造函数，java编译器提供一个默认构造函数 | 在任何情况下编译器都不会提供默认的方法调用 |
| 构造函数名称必须与类名称相同 | 方法名称可以或可以不与类名称相同(见名知义)。 |