1、关键字：其实就是某种语言赋予了特殊含义的单词。
保留字：其实就是还没有赋予特殊含义，但是准备日后要使用过的单词。
2、标示符：其实就是在程序中自定义的名词。比如类名，变量名，函数名。包含 0-9、a-z、$、_ ；
注意：1）数字不可以开头。
2）不可以使用关键字。
3、常量：是在程序中的不会变化的数据。
4、变量：其实就是内存中的一个存储空间，用于存储常量数据。
作用：方便于运算。因为有些数据不确定。所以确定该数据的名词和存储空间。
特点：变量空间可以重复使用。
什么时候定义变量？只要是数据不确定的时候，就定义变量。
变量空间的开辟需要什么要素呢？
1）这个空间要存储什么数据？数据类型。
2）这个空间叫什么名字啊？变量名称。
3）这个空间的第一次的数据是什么？ 变量的初始化值。
（1）变量的作用域：作用域从变量定义的位置开始，到该变量所在的那对大括号结束；
（2）生命周期：变量从定义的位置开始就在内存中活了；变量到达它所在的作用域的时候就在内存中消失了；
5、数据类型：
1）基本数据类型：byte、short、int、long、float、double、char、boolean
2）引用数据类型: 数组、类、接口。
级别从低到高为：byte,char,short(这三个平级)-->int-->float-->long-->double
自动类型转换：从低级别到高级别，系统自动转的；
强制类型转换：什么情况下使用?把一个高级别的数赋给一个别该数的级别低的变量；
1）算术运算符。+ - * / % %:任何整数模2不是0就是1，所以只要改变被模数就可以实现开关运算。+:连接符。++,--
2）赋值运算符。= += -= *= /= %=
3）比较运算符。特点：该运算符的特点是：运算完的结果，要么是true，要么是false。
4）逻辑运算符。& | ^ ! && || 特点：逻辑运算符除了 ! 外都是用于连接两个boolean类型表达式
& : 只有两边都为true结果是true。否则就是false。
| :只要两边都为false结果是false，否则就是true
^ :异或：和或有点不一样。两边结果一样，就为false；两边结果不一样，就为true。
& 和 &&区别：& ：无论左边结果是什么，右边都参与运算。
&&:短路与，如果左边为false，那么右边不参数与运算。
| 和|| 区别：|：两边都运算。
||：短路或，如果左边为true，那么右边不参与运算。
5）位运算符:用于操作二进制位的运算符。& | ^ << >> >>>(无符号右移)
switch细节：
1）break是可以省略的，如果省略了就一直执行到遇到break为止；
2）switch 后面的小括号中的变量应该是byte,char,short,int四种类型中的一种；
3）default可以写在switch结构中的任意位置；如果将default语句放在了第一行，则不管expression与case中的value是否匹配，程序会从default开始执行直到第一个break出现。
while和for可以进行互换。区别在于：如果需要定义变量控制循环次数。建议使用for。因为for循环完毕，变量在内存中释放。
break:作用于switch ，和循环语句，用于跳出，或者称为结束。break语句单独存在时，下面不要定义其他语句，因为执行不到，编译会失败。当循环嵌套时，break只
跳出当前所在循环。要跳出嵌套中的外部循环，只要给循环起名字即可，这个名字称之为标号。
continue:只作用于循环结构，继续循环用的。作用：结束本次循环，继续下次循环。该语句单独存在时，下面不可以定义语句，执行不到。
1、数组：用于存储同一类型数据的一个容器。好处：可以对该容器中的数据进行编号，从0开始。数组用于封装数据，就是一个具体的实体。
1）声明数组
语法： 数据类型[ ] 数组名； 或者 数据类型 数组名[ ]；
2）分配空间：简单地说，就是指定数组中最多可存储多少个元素
语法： 数组名 = new 数据类型 [ 数组长度 ]；
其中，数组长度就是数组中能存放元素的个数，
3）赋值：分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的。
在 Java 中还提供了另外一种直接创建数组的方式，它将声明数组、分配空间和赋值合并完成。如：
int[] scores = {11,12,13,14}; 等价于 int[] scores = new int[]{11,12,13,14};
4） 数组名.length 用于获取数组的长度；
5） 使用 Arrays 类操作 Java 中的数组：
Arrays.sort(数组名) 对数组进行升序排序；Arrays.toString(数组名)：将数组转换为字符串
重载的定义是：在一个类中，如果出现了两个或者两个以上的同名函数，只要它们的参数的个数，或者参数的类型不同，即可称之为该函数重载了。
判断方法重载的依据：
1、 必须是在同一个类中
2、 方法名相同
3、 方法参数的个数、顺序或类型不同
4、 与方法的修饰符或返回值没有关系
java分了5片内存。
1：寄存器。2：本地方法区。3：方法区。4：栈。5：堆。
栈：存储的都是局部变量 ( 函数中定义的变量，函数上的参数，语句中的变量 )；
只要数据运算完成所在的区域结束，该数据就会被释放。
堆：用于存储数组和对象，也就是实体。啥是实体啊？就是用于封装多个数据的。
1：每一个实体都有内存首地址值。
2：堆内存中的变量都有默认初始化值。因为数据类型不同，值也不一样。
3：垃圾回收机制。
类的特点：是具有相同属性和方法的一组对象的集合。类是对象的类型。
通过 类名 对象名 = new 类名(); 可以创建类的对象
1、成员变量和局部变量
（1）作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
（2）初始值不同
Java会给成员变量一个初始值，却不会给局部变量一个初始值；
2、构造函数
（1）一般的 new 一个新对象时，系统是执行一个构造方法，如果class中没有定义构造方法，系统自动生成无参的构造方法；
（2）当没有指定构造方法时，系统会自动添加一个无参构造方法；而当class中定义了构造方法，不管是有参的还是无参的，系统都不会在生成构造方法。
3、static静态变量
使用 static 可以修饰变量、方法和代码块。Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。
静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问~~
4、static静态方法
1）静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员；
如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。
2）静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。
3）在普通成员方法中，则可以直接访问同类的非静态变量和静态变量；
5、static静态代码块
在类的声明中，可以包含多个初始化块，当类的实例化时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。
需要特别注意：静态初始化块只在类加载时执行，且只执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。
6、toString()方法
toString是Object类的方法，所有类都从Object类继承。
（1）如果你定义的类没有覆盖toString方法，则对象在调用toString方法时用的是Object类toString方法，返回的是“类名@hashcode"。如果是byte[] 类型的话，则是“[B@hashcode”
System.out.println(obj)在参数是一个对象时，会默认调用该对象的toString方法。
（2）String类和StringBuffer类都覆盖了toString方法，都是返回字符串。所以带不带toString效果是一样的。
String s1 = "hello"; StringBuffer s2 = new StringBuffer(s1); s2.append(" world"); System.out.println(s2.toString()); System.out.println(s2); 结果： hello worldhello world
【PS : getBytes() vs new String()】
（1）String的getBytes()方法是得到一个系统默认的编码格式的字节数组。
（2）通过String.getBytes(String decode)方法来得到byte[]，通过new String()将byte[]数组还原。
String str = "570FF26603A91CC3"; byte[] bStr = str.getBytes(); System.out.println(new String(bStr));结果：570FF26603A91CC3
分析：bStr = [53, 55, 48, 70, 70, 50, 54, 54, 48, 51, 65, 57, 49, 67, 67, 51] ascii码的十进制显示。
【PS: hex编码】
Hex就是16进制，本质上是将字节数组转化为16进制，然后用字符串的形式表现出来，我们知道16进制的取值范围就是在0-f之间，这样就可以将无法显示的字节数组数据显示出来。
原理：一个8bit的数据，也就是（xxxx xxxx）,每4个bit可以转化为一个16进制表示，也就是8个bit会转化为（00-ff）之间的16进制数字。
hex编码 ：指将数据编码16进制字符串；hex解码：指16进制字符串解码为数据。
public static void main(String[] args) { /************* getBytes() new String() toString() hex ****************/ String str = "570FF26603A91CC3"; byte[] bStr = str.getBytes(); String Bhex = bcd2str(bStr);// hex编码 byte[] hex2b = hexStringToBytes(Bhex);// hex解码 String b2s = new String(hex2b); System.out.println("Bhex = " + Bhex); System.out.println("hex2s = " + b2s); } public static byte[] hexStringToBytes(String hexString) { if (hexString == null || hexString.equals("")) { return null; } hexString = hexString.toUpperCase(); int length = hexString.length() / 2; char[] hexChars = hexString.toCharArray(); byte[] d = new byte[length]; for (int i = 0; i < length; i++) { int pos = i * 2; d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1])); } return d; } private static byte charToByte(char c) { return (byte) "0123456789ABCDEF".indexOf(c); } public static String bcd2str(byte[] bcds) { char[] ascii = "0123456789abcdef".toCharArray(); byte[] temp = new byte[bcds.length * 2]; for (int i = 0; i < bcds.length; i++) { temp[i * 2] = (byte) ((bcds[i] >> 4) & 0x0f); temp[i * 2 + 1] = (byte) (bcds[i] & 0x0f); } StringBuffer res = new StringBuffer(); for (int i = 0; i < temp.length; i++) { res.append(ascii[temp[i]]); } return res.toString().toUpperCase(); }
类的封装：类的封装使用户通过类的作者指定的方法修改类的数据成员，而不使用户直接操作数据成员，这叫做类的封装。封装是为了隐藏属性，通过方法给属性赋值。
1、包的作用：管理Java文件；解决同名文件冲突
注：必须放在Java源程序的第一行，必须小写。
2、访问控制符
3、this
this关键字代表当前对象
this.属性 操作当前对象的属性
this.方法 调用当前对象的方法
封装对象的属性时，经常用this关键字
4、内部类
内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
作用是：
1）内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类；
2）内部类的方法可以直接访问外部类的所有数据，包括私有的数据；
3）内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便。
内部类可分为以下几种：
（1）成员内部类：
A、 外部类是不能直接使用内部类的成员和方法
B、如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字。
（2）静态内部类：
静态内部类是 static 修饰的内部类，这种内部类的特点是：
A、静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
B、 如果外部类的静态成员与内部类的成员名称相同，可通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过“成员名”直接调用外部类的静态成员
C、 创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();
（3）方法内部类
方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
（4）匿名内部类
继承是类与类之间的关系，是一种is a的关系。子类拥有父类的所有属性和方法，private修饰的无效。
1、重写：如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。
语法规则：a.返回值类型 b.方法名 c.参数类型及个数，都要与父类继承的方法相同，才叫方法的重写。
2、继承的初始化顺序：
1）初始化父类再初始子类
2）先执行初始化对象中属性，再执行构造方法中的初始化
3、final中文的意思就是最终的意思；它可以修饰类，方法，属性和变量； final修饰类，则该类不能被继承； final修饰方法，则该方法不能被重写或覆盖； final修饰属性，则该属性在类的初始化时必须有值；或者，在构造方法赋值（只能选择其一）； final修饰变量，则该变量就只能赋一次值，==常量。 4、super 1）子类的构造的过程当中必须调用其父类的构造方法。 2）如果子类的构造方法中没有调用父类的构造方法，则系统默认调用父类无参的构造方法。 3）如果显示的调用构造方法，必须在子类的构造方法的第一行。 4）如果子类构造方法中既没有显式调用父类的构造方法，而父类又没有无参的构造方法，则编译出错。（如果自定义一个有参的构造方法，系统就不会帮我们自动生成一个无参的构造方法） 5、object类 1）在Object类里面定义toString()方法的是返回的对象的哈希code码（对象地址字符串） 2）当我们new一个类的时候，得到的对象叫做 类的对象（对象的属性值的信息，或者说这个对象数据信息）；如果这个对象调用getClass()方法，得到的是 类对象（类对象描述的是类的代码信息）