byte short int long float double boolean char 分别为12484812
\t具有转义字符的作用，相当于换行
system.out.print()不换行 system.out.println()换行 \n也具有换行的意思
十进制10 八进制010 十六进制0x10 二进制0b10-----他们都以这些开头
在任何时候数据类型的字面量或者数据默认被当作int处理，如果希望该数据类型字面量被当做long类型来处理，需要在字面量后面加l或者L
要算到二进制，需要用到1 2 4 8 16 32 64 128
强制类型转换：byte b=（byte）300 因为300默认为int类型
当一个数赋值给char类型变量的时候会自动转换成char字符型，最终的结果是一个字符型
当byte short char做混合运算的时候，各自先转换成int再做运算
多种数据类型做混合运算的时候，最终结果类型是最大容量对应的类型
当++出现在变量后面，先赋值再运算。当++出现在变量前面，先运算再赋值
运算符有：算术运算符 关系运算符 逻辑运算符 短路与和短路或 赋值运算符 三目运算符 字符串连接运算符
控制语句分为 选择语句 循环语句 转向语句三大类。
选择语句：if(布尔表达式){ }语句 switch语句
循环语句：for（求和：先循环，再判断求余，然后在for外面定义一个变量，然后利用+=来实现 嵌套循环：外面是循环多少次）
要在外面先定义一个变量 while（这里是boolean类型） 循环体至少循环0--n次
do{循环体}..while(布尔表达式); 执行原理：先去执行循环体，再去判断布尔表达式的结果。循环体至少循环一次
转向语句：break一个单词成为java一行语句。break用在switch语句和循环语句(for while do..while)当中，需要用判断来终止，用来终止语句的执行。
continue要和break对比着学习，起跳跃的作用
return
方法：方法就是减少代码的复用性----public static void sum(int a,int b) { }。
方法怎么定义：[public static]--修饰符列表，可有可无 (void)返回值类型--可以是基本数据类型或者引用数据类型 方法名(参数列表){ 方法体 }。
注意：如果返回值不是void，那么在方法体执行结束的时候必须使用”return“，如果没有return编译器会报错，只要有”return“关键字的执行，当前方法必然结束。=========================
方法名命名规范：前面单词全部小写，后面出现单词首字母要大写。
参数列表中的每一个参数都是局部变量。形参的个数是0个到n个。
如何调用方法：类名.方法名(实际参数列表); 什么时候可以省略类名--在本类调用的时候可以省略类名，跨类调用的时候不能省类名。建议都加类名.
不止main方法才能去调用其他的方法。
break和return的区别：return直接终止离他最近的方法。
方法执行内存：1.栈内存--在方法被调用的时候，该方法需要的内存空间在栈中分配。栈数据结构(stack)---先进后出，后进先出原则。处于栈顶最活跃
2.方法区--将硬盘上的xxx.class字节码装到JVM，方法区中存储是代码片段。
3.堆内存
方法的重载：
什么时候需要考虑方法重载(overload)--在同一类当中，如果功能1和功能2是相似的，那么可以考虑将他们的方法名一致。
什么时候代码会发生重载：
条件1：在同一类当中 条件2：方法名相同 条件3：参数列表不同(参数的个数、类型、顺序不同算不同)
方法重载和返回值类型和修饰符列表不一样
代码的封装：public class s {
public static void p() {
System.out.println();
}
public static void p(byte b) {
System.out.println(b);
}
public static void p(short s) {
System.out.println(s);
}
public static void p(int i) {
System.out.println(i);
}
public static void p(long l) {
System.out.println(l);
}
public static void p(float f) {
System.out.println(f);
}
public static void p(double d) {
System.out.println(d);
}
public static void p(boolean b) {
System.out.println(b);
}
}
直接调用：public class 方法重载 {
public static void main(String[] args) {
s.p();
s.p(10);
s.p(10.0);
s.p(true);
s.p('人');
s.p(3.14);
}
}
方法递归：
方法自己调用自己那是方法递归。
面向对象和面向过程的区别：
1.面向对象就是实现世界分割成不同的单元，然后每一个单元都实现成对象，然后驱动一下让个个对象之间协作起来形成一个系统。耦合度低，扩展力强
类和对象的区别：
1.类实际上是不存在的，是一个抽象的概念
2.对象是一个实际存在的个体
类=属性+方法
属性来源于：状态(名词) 方法来源于：动作(动词)
方法体中声明的变量是局部变量，方法体以外声明的变量是成员变量
堆内存储存的变量是实例变量
如何访问实例变量---引用.实例变量名
程序在什么时候会出现空指针异常呢：当对象的变量名为空的时候。
构造方法：
构造方法是一个比较特殊的方法，可以完成对象的创建，以及实例变量的初始化。
当一个类没有提供任何构造方法，系统会默认提供一个无参数的构造方法。当你定义一个有参构造方法，系统将不会提供无参构造
构造方法的语法结构：
修饰符列表 构造方法名 (形式参数列表){
构造方法体；
通常在构造方法体中给属性赋值，完成属性的初始化。
}
注意：1.修饰符列表统一是public而不是public static 2.构造方法名和类名必须一致 3.构造方法没有返回值类型。
构造方法如何调用---new 构造方法名(实际参数列表)
构造方法支持方法重载
对于实例变量来说，只要你在构造方法中没有手动给赋值，统一都会默认赋值。
封装有什么作用：
1.保证内部结构的安全
2.屏蔽复杂，暴露简单
怎么进行封装：
1.属性私有化(使用private关键字进行修饰)
2.对外提供简单操作入口---通过get和set
带有static和没有static如何调用：
带有static---直接用类名.方法名
没有static--需要new对象，通过引用.的方式去访问，同时也叫实例方法
关键字static---翻译为静态的：
所有static关键字都是类相关的，类级别的。
所有static关键字都是采用”类名.“的方式去访问。
static修饰的方法：静态方法
static修饰的变量：静态变量
什么时候使用静态变量：---比如像中国的国籍
加static是静态变量，静态变量在类加载时初始化，不需要new对象，静态变量的空间就开出来了，静态变量储存在方法区。
方法体内访问的是实例变量用实例方法；。
静态代码块：
使用关键字static可以定义静态代码块，类加载的时候开始执行静态代码块。静态代码块在mian方法执行之前执行，按照自上而下执行
静态代码块有什么作用：1.静态代码块没有那么常用 2.记录的日志可以放到静态代码块
实例代码块：
实例代码块只要是构造方法执行，必然在构造方法执行之前自动执行
this关键字：
1.一个对象一个this
2.this是一个变量，是一个引用，this保存在当前对象的地址，存储在堆内存。
3.this只能用在实例方法中，不能用在静态方法中
this大部分都是省略，那this什么时候不能省略：
this区分局部变量和实例变量，一般用在get和set方法还有构造方法
this()的用法：
如果要用无参取调用有参，在无参里用this(),挂号里边写东西
什么是继承？有什么作用？
继承---extends
凡是采用is a能描述的都可以继承。
继承后，子类的对象可以调用父类的方法。
子类中在没有继承任何类，默认继承Object，object里有一个tostring()方法
子类继承父类，除构造方法不能继承之外，剩下都可以继承，但是私有的属性无法在子类中直接访问，可以通过get和set间接来访问。
基础作用：继承可以减少拥挤，如果子类跟父类有相同的属性，那么在子类可以省略不写，也可以不用写set和get方法。
重要作用：
方法覆盖：--Override或Overwite都可以
什么时候会考虑方法覆盖呢--子类继承父类之后，当继承过来的方法无法满足当前的业务时，子类有权利对这个方法进行重写，有必要进行方法覆盖。
构成方法覆盖的条件：
1.两个类必须有继承关系
2.重写之后的方法和之前的方法具有相同的返回值类型、相同的方法名、相同的形式参数列表
3.访问权限不能更低，可以更高。
4.重写之后的方法不能比之前的方法抛出更多的异常，可以更少
构成方法覆盖的注意事项：
1.方法覆盖只针对方法与属性无关
2.私有方法无法覆盖
3.构造方法无法继承，所以构造方法也无法覆盖
4.方法覆盖只针对实例方法，静态方法覆盖没有意义
tostring()的方法时将对象转换成字符串的形式。
多态：
父类型的引用允许指向子类型的对象。
多态的基础语法：
1.向上转型：子类---父类（自动类型转换），animal a1=new cat();
2.向下转型：父类---子类（强制类型转换），子类独有的方法，当父类没有的方法可以进行向下转型，if(c instanceof cat){cat c1 = (cat)c;}
无论是向上还是向下两者必须存在继承关系。
super概述：
super和this对比着学习。
1.super能出现在实例方法和构造方法
2.super不能用在静态方法
3.构造方法默认会有一个super()去调用另一个的无参构造，两者存在继承关系。
4.this和super不能共存
5.当父类和子类中有相同的属性，super.不能省略。
IDEA的快捷键：
main方法：psvm system.out.println():sout 删除一行：ctrl+y 任何新增/新建/添加的快捷键是：alt+insert
窗口变大变小：alt+1
final关键字：
1.final修饰的类无法继承
2.final修饰的方法无法覆盖，可以被重写
3.final修饰的局部变量无法再次赋值
4.final修饰引用引用也无法再次赋值
5.final修饰的实例变量一定要自己手动赋值，也可以通过无参构造赋值。final修饰的实例变量一般添加static修饰。
抽象类：
1.抽象类不能创建对象，所以抽象类是用来被子类继承的
2.类和类之间具有共同特征，将这些共同特征提取出来就形成抽象类。
3.类到对象是实例化，对象到类是抽象。
4.抽象类属于引用数据类型。
5.抽象类语法：修饰符列表 abstract class 类名{ 类体 }
6.抽象类有构造方法，这个构造方法是提供子类使用的
7.抽象方法是没有实现的方法，没有方法体的方法-----public abstract void ok();
8.抽象类中不一定要有抽象方法，抽象方法一定出现在抽象类里。
非抽象类：
1.一个非抽象的类继承抽象类，必须将抽象类中的抽象方法重写/覆盖/实现了。*****
接口基础语法：
1.接口时一种引用数据类型
2.接口语法：修饰符列表 interface 接口名{ } 注意：没有class。
3.接口可以多继承。
4.接口里面只包含两部分，一是常量 二是抽象方法
5.接口中的方法不能有方法体。
6.接口中的常量public static final可以省略。
7.类和类之间叫继承，类和接口叫实现。 实现的关键字---implements
8.当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现/覆盖/重写。*****
9.一个类可以同时实现多个接口，
接口在开发的作用：-----通过餐馆的例子来说明。顾客、菜单、厨师
1.注意：接口在开发中的作用，类似于多态在开发中的作用。
2.多态：面向抽象编程，不要面向具体编程。
3.以后凡是能够使用has a 来表示，统一以属性的方式存在。
4.任何接口都有实现者和调用者
5.is a----表示继承关系 has a------表示关联，通常以属性的形式存在 like a-----通常是类实现接口
抽象类和接口的区别：
1.抽象类中有构造方法/接口中没有构造方法
2.接口和接口支持多继承/类和类之间只能单继承
3.一个类可以实现多个接口/一个抽象类只能继承一个类
4.接口中只允许出现常量和抽象方法
包机制：
包名命名规范：公司域名倒序+项目名+模块名+功能名
Object类当中有哪些常用的方法：
1.去源码中找
2.去查阅java类库的帮助文档
3.protected object clone()--负责对象克隆的
4.boolean equals (object obj)--判断两个对象是否相等
5.protected void finalize()--垃圾回收器负责调用的方法
6.String toString()--将对象转换成字符串形式，以后一般都要重写。
7.int hashCode()--获取对象哈希值的一个方法
8.string类已经重写了equals 方法，要比较string的时候要用equals来比较，不能用双等号。
内部类：---在类的内部又定义了一个新的类。
1.new 接口名( ){ }
一维数组：
1.数组是一个容器，可以容纳多个元素。
2.数组可以存储基本数据类型，也可以存储引用数据类型。
3.数组是引用数据类型，所以数组对象存储在堆内存。
4.数字一旦创建，在Java规定，长度不可变。
5.数组的分类：一维数组、二维数组、三维数组、多维数组……
6.所有的数组对象都有lenght属性，用来获取数组中的个数。
优点：查询/查找某个下标上的元素时效率极高，因为每个元素的内存地址空间存储上都是连续的。
缺点：为了保证每个数组中每个元素的内存地址是连续的，所以在数组上随机删除或者增加元素的时候，
效率较低，因为随机增删会涉及到后面元素统一向前或向后的位移的操作。
如何初始化一个一维数组：
1.静态初始化语法格式：int[ ] array={100，200};
2.动态初始化语法格式：int[ ] array=new int[5];---这里的5表示数组的元素个数。
3.扩容数组(System.arraycopy( ))--就是重新建立一个大数组，然后把小数组拷贝进去。数组扩容效率较低。
4.第一源--src、第二源的起点、第三目标--dest、第四目标的起点、第五拷贝的长度。
二位数组：---int[][] a= {{11,22,33},{22}}有两个中挂号
1.二维数组是特殊的一维数组，特殊在这个一维数组当中的每一个元素是一个一维数组。
2.a[1][1]----第一个1表示的是第几个一维数组，第二个1表示的是一维数组里的第几个数。
3.如果要遍历二维数组就得for循环两次。
Arrays工具类：
1.Arrays.sort( )---这个方法可以遍历从小到大得排序。
2.所有方法都是静态的，直接用类名调用。
3.二分法查找的方法---Arrays.binarySearch。
冒泡排序算法：
1.需要一个空得箱子来存放，然后在交换值。
二分法查找：
1.只适合用在有序得排列方式上。---首尾下标除于2
string字符串：
一.储存原理：
1.双引号括起来的字符串是不可变的。
2.存储在方法区。
3.==比较的是内存地址。
4.要比较对象用equals。
5.string(byte[ ] bytes ,int offset, int lenght)
6.String s=new String("");
7.String s="";
8.String s=new String(char数组);
9.String s=new String(char数组,起始下标,长度);
10.char charAt(int 数字)---查找第几个词---char c="100".charAt(1)；
11.int compareTo(string anotherString)----前后比较：int i="abc".compareTo("abc"); 前小后大为-1，前大后小为1。
12.boolean contains(CharSequence s)---半段前面字符串是否包含后面的字符串。
13.boolean endsWith(string suffix)----判断当前字符串是否以某个字符串结尾
14.boolean equalsIgnoreCase(string anotherString)---判断两个字符串是否相等，忽略大小写。
15.byte[ ] getBytes( )--将字符串对象换成字节数组。
16.int indexOf(string str)--判断某个子字符串在当前字符串中第一次出现的索引。也就是下标
17.boolean isEmpty()---判断某个字符串是否为空。
18.string replace(CharSequence target, (CharSequence replacement)
19.string[ ] split(string regex)---分隔符进行摘分，还需要循环
20.boolean startsWith(string prefix)----判断当前字符串是否以某个字符串开始
21.string substring(int beginIndex)---截取字符串
22.char[ ] toCharArray( )---将字符串换成char数组
23.string toLowerCase( )---转换为小写
24.string toUpperCase( )---转换为大写
25.string trim( )--去除字符串前后空白
26.valuesOf---将非字符串转换成字符串，属于静态方法
StringBuffer进行字符串拼接：
1.以后拼接字符串统一用StringBuffer.append( )方法
2.StringBuilder与StringBuffer有啥区别呢：StringBuffer线程比较安全。
8种包装类：
1.java.lang.Byte 2.java.lang.Short 3.java.lang.Integer 4.java.lang.Long
5.java.lang.Floot 6.java.lang.Double 7.java.lang.Blooean 8.java.lang.Character
9.基本数据类型转为引用数据类型是装箱
10.引用数据类型转为基本数据类型是拆箱
Integer的构造方法可以传整数也可以传引用数据类型。
通过访问包装类的常量，来获取最大值和最小值：System.out.println(Integer.MIN_VALUE);
自动装箱和自动拆箱：---Integer
1.【-128——127】将所有的包装对象提前创建好，放到一个方法区的"整数型常量池"当中，目的是这个区间就不用再new对象了。直接从常量池中取出来。
2.static int parseInt(String s)---静态方法，传参string，返回int
java对日期的处理：
1.SimpleDateFormat---专门负责日期格式化的，yyyy是年，MM是月，dd是日，HH是时，ss是秒，SSS是毫秒。然后去调用format()方法。
2.有字符串如何转为date日期：调用parse()方法
3.long begin=System.currentTimeMillis()---求系统从1970-1-1 00：00：00到当前系统时间的毫秒数。返回一个long
高精度BigDecimal---用于财务软件开发当中。
随机数--创建Raandom对象，调用nextInt( )方法
int i=r.nextInt(101)产生0-100的随机数。
枚举：---enum里面有SUCCESS,FAIL。然后再返回给其他的类用
1.如果boolean来解决不了可以通过枚举来实现。
2.枚举是一种引用数据类型。
异常：
1.提醒程序员进行修改，让程序更加的健壮。
2.java语言中异常是以类和对象的形式存在-----NumberFormatException
3.类是模板，对象是实际存在的个体。比如钱包丢了是类，我的钱包丢了是对象。
UML和starUML工具：---可以使用UML图来描述继承结构。
1.UML属于一种统一建模语言，一种画图的软件，不是只有Java才能用的。只要是面向编程的语言都可以用
2.UML图中可以描述类和类之间的关系，程序执行的流程，对象的状态等。
编译时异常(受检、受控异常)和运行时异常(未受检、受控异常)区别：
1.编译时异常发生的概率比较高，相反较低。
2.对异常的处理方式：第一种方式--throws关键字(异常上抛)。第二种方式--使用try. .catch(异常捕捉)。
3.如果多个方法调用，要一直往上抛，可以直接抛异常的父类。
4.catch后面的小挂号中的类型可以是具体的异常类型，也可以是该异常类型的父类。
5.catch可以写多个，从上到下，必须遵守从小到大。
异常对象的常用方法：
1.exception.getMessage( )
2.exception.printStackTrace()
3.退出JVMfinally语句不执行。
4.方法体中的代码必须遵循自上而下顺序依次逐行执行。
final、finally、finalize有何区别：
1.final是一个关键字表示最终的。final修饰的类无法继承，final修饰的方法无法覆盖，final修饰的变量不能重新赋值。
2.finally也是一个关键字，和try联用，使用在异常处理机制中，finally语句块的代码一定会执行的。
3.finalize是object类中的一个方法，作为方法名出现，所以他是标识符。
如何自定义异常：
1.编写一个类继承Exception或者RuntimeException；
2.提供两个构造方法，一个无参的，一个带有string的参数。
3.throw这个是手动抛出异常。
4.重写之后的方法不能比重写之前的方法抛出更多的异常，可以更少，也可以抛出运行异常。
集合的概述：
1.数组其实就是一个集合。集合实际上就是一个容器，可以容纳其他数据。
2.集合不能直接存储基本数据类型，另外集合也不能直接存储对象，集合当中存储的都是Java对象的内存地址。
3.Java中每个不同的集合会对应不同的数据结构，数据结构有：数组、二叉树、链表、哈希表、图等等。
new Arraylist()----创建一个集合，底层是数组。 new LinkedList()----创建一个集合对象，底层是链表
new TreeSet()----创建一个集合对象，底层是二叉树。
java集合分为两大类：
1.一类是单方式存储元素：这一类集合超级父接口是----Java.util.Collection;
2.另一类是键值对儿存储元素：这一类集合超级父接口是---java.util.Map
3.Iterator是集合Collection的迭代器，Collection继承Iterable，然后去调用Iterator()的方法
4.List集合存储元素特点：有序可重复。
5.Set集合存储元素特点：无序不可重复。
6.Map集合和Collection没有关系
7.Map集合以key和value的这种键值对的方式储存元素。
8.key和value都是存储java对象的内存地址
9.HashMap和Hashtable都继承Map
Collection可以存储什么元素：没有使用泛型之前collection可以存储object的所有类型。
Collection中常用接口方法：
1.boolean add(object e)----添加元素
2.int size()----获取集合中元素的个数
3.void clear()---清除collection中集合的所有元素
4.boolean contains(object o)---判断当前集合是否包含元素o，会自动调用equals
5.boolean remove(object o)---删除集合中的某个元素，只要值是一样就会调equals方法，删除集合中的元素，要用迭代器的remove，不能用集合对象。
6.boolean isEmpty( )----判断该集合中元素的个数是否为空
7.Object[ ] toArray( )----调用这个方法可以把字符串转换成数组
8.Iterator( )---迭代器就是集合遍历所有元素，返回值也是Iterator。里面有两个方法：1.boolean hasNext( )---如仍有元素可以迭代，那就返回true。
2.Object next( )----返回迭代的下一个元素。 使用while循环来用比较好
List接口常用的方法：
1.E get(int index)
2.E remove(int index)
3.E set(int index--指下标,E element)
4.int indexof(Object o)---获取指定对象第一次出现的索引。
5.可以用for循环，然后用get方法获取元素的下标。
Arraylist集合：
1.底层是一个Object[ ]数组
2.默认初始化容量是10
3.Arraylist集合的扩容是原扩容的1.5倍。
4.10的二进制右移一位就是除于2
5.向数组末尾添加元素，效率很高，不受影响。
6.面试问题：这么多集合中，你用哪个集合最多？
答：ArrayList集合，因为向数组末尾添加元素，不受影响，另外我们查找某个元素的操作比较多。
数据结构：
一：单链表：
1.对于链表数据结构来说：基本的单元是节点Node，对于单链表来说，任何一个节点Node中有两个属性：
第一：存储数据。第二：下一个节点的内存地址。
2.链表优点：随机增删元素效率高。----使用LinkedList---底层调用了双链表
3.链表缺点：查询效率较低，每一次查找元素的时候都需要从头节点开始往下遍历。
4.末尾添加元素ArrayList用的比LinkedList还多。
二：双链表：
1.双链表上基本的单元节点还是Node
2.有上节点、下节点、储存数据。
3.头节点和尾节点内存地址一样。
4.最初这个链表中没有任何元素，first和last引用都是null。
如何变成线程安全：Collections.synchronizedList(变量名)
泛型机制：
一：好处：
1.集合中储存的元素类型统一了。
2.从集合中取出的元素类型是泛型的类型，不需要进行大量的“向下转型”。
二：缺点：
1.导致集合中存储的元素缺乏多样性。
Map常用方法：
1.Map和Collection没有继承关系
2.Map集合以key和value的方式存储数据：键值对
3.void clear( )----清空集合
4.boolean containskey(object key)----判断map集合中是否包含key
5.boolean containsvalue(object value)----判断map集合中是否包含value
6.v get(object key)----通过key获得value
7.boolean isempty( )判断map集合中元素个数是否为0
8.set<k> keyset( )-----获取map集合中所有的key
9.v put(k key,v value)----向map集合中添加键值对
10.v remove(object key)----通过key删除键值对
11.int size( )---获取map集合中键值对的个数
12.collection<v> values( )获取map集合中所有的value，返回一个collecction
13.set<map.entry<k,v>> entryset( )-----将map集合转到set集合---******
