javaSE

jdk:java development kit   java开发工具包
jre:  java running  evironment java运行环境
jvm: java virtual machine java虚拟机

jdk包括了jre，jre包括了jvm。实现跨平台的根本原因是jvm，jvm是jdk的核心。

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。
Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。
而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，
使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，
把字节码解释成具体平台上的机器指令执行。这就是Java的能够“一次编译，到处运行”的原因。




java语言的特点：1面向对象    
               2跨平台，一次编译，处处运行  java是运行在自己的jvm上，可以直接运行此文件。
               3垃圾回收，是自动回收，不定时的，其他语言没有这种机制。



1、安装jdk
2、配置环境变量
 计算机右键-->属性-->高级系统设置--->环境变量
path：  C:\Program Files\Java\jdk1.7.0_79\bin
classpath：  C:\Program Files\Java\jdk1.7.0_79\lib
java之父：高斯林。

3、如何写java程序？
 注释：html：<!--注释-->
   java:格式：

  1、//单行注释
 2、/*

  多行注释
*/

3、文档注释
 /**
文档注释的内容

*/
4、类名的命名规范：①首字母大写②如果是多个单词话，遵循驼峰式命名结构
格式：
 public class HelloWorldNumber{//public 公共的 class类 HelloWorld是类名

  public static void main(String[] args){//static静态的 void没有返回值类型 //main方法，主方法（是java程序运行的入口）,如果一个类没有main方法的话，这个类不能单独运行  String[] args是形参
   System.out.println("helloworld");
}
}

注：ln是换行的作用
帮助文档：api application Interface 应用接口
 
进制的转换：
0代表八进制 0x代表十六进制。




二进制：只有0，1，逢2进1

 转换到十进制：
十进制--->二进制
5--->0101  ---->1*2(2)+1*2(0)=5
9--->01001--->
八进制：从0--7，逢8进1
63(8)---->10进制  6*8(1)+3*8(0)=51
十进制--->八进制

16进制：0-9，a,b,c,d,e,f,逢16进1.
十进制--->16进制
16进制--->10进制

包装类：

byte-->Byte
short-->Short
int-->Integer
long-->Long
-------
float--->Float
double-->Double
char-->Character
booleean-->Boolean


5、数据的类型（数据类型在java程序中是以十进制存在的）
  实际生活中：
整数，小数，分数，函数，字符，字符串，布尔
在java中：
整数（4种）：
byte：整数，一个字节=8位，占一个字节。表示的数的范围是-128到127 。{整数默认是int}（加入内容时格式byte空格+量=（）；）
（两个byte做运算的时候默认为或自动提升为用int字节）
-2(7)-->2(7)-1

short:短整型，占2个字节，16位。表示的数的范围是:-2(15)--->2(15)-1

int：integer整数 ，占4个字节，32位。表示的范围：-2(31)---->2(31)-1

long:长整型，占8个字节，64位。范围：-2(63)--->2(63)-1


小数（2种）：{java计算中默认为double}
float:单精度 占4个字节，32位。
double:双精度  占8个字节，64位。

字符：
char :单个的字母，汉字，符号。在内存中占2个字节，16位。字符型变量（char=）
boolean：只有两个值，一个true，一个是false。
以上这8种数据类型就是java中的基本数据类型。

java中数据类型：两大类：一个是基本数据类型，一个是引用数据类型。基本数据类型只有8种，byte,short,int,long,float,double,char,boolean.
引用数据类型：字符串，数组，类（普通类，抽象类，接口），对象 String。



2、标识符（由字母 数字 下划线_ $）



标识符用在给变量，常量，方法（函数），类，数组，对象命名。
标识符命名规范：
  （1）只能出现，大小写字母，数字，_,$ (%？\#@不可以的)
  （2）是不能以数字开头的  3wei（错）
  （3）最好的命名是有含义的，见名识意  
   (4)常用的命名规范：
         定义类名：类名首字母大写，多个单词的话，所有的单词首字母大写；
        定义变量：单个单词，全部小写。如果是多个单词，后面的单词首字母大写
        定义常量：单个单词的话，所有的字母大写；多个单词的话，单词与单词之间用下划线连接并且全部大写。      STUDENT_NUMBER   PI
   定义变量：
   格式：
   数据类型 变量名=值;

例子：定义一个变量保存班级人数
        byte studentNumber=40;
3、运算
  （1）算术运算符
    ：+，-，*，/,%，++，--
    6/4=只要商 1
    %：模，（取余）3%7=3
    ++:自增1
    --:自减1
++，--分为前++和后++，前--和后--
a++;
++a;
  单独使用的时候，效果一致；使变量a自增1.
  参与运算:前++的话，先增后用；后++，先用后加。
 (2)逻辑运算符
  与或非 & | ! &&  ||  ^(异或)
  条件1 & 条件2 ：不管条件1为true还是false，条件2都要判断。
(1>3)并且(3>2) true false false false
  条件1 | 条件2 :不管条件1为true还是false，条件2都要判断。
  !条件1  !true=false   !false=true
 条件1 && 条件2：结果一致（短路与）当条件1为false的时候，条件2被短路。


（注意：被短路的条件将不再进行执行，输出内容为上一指令的内容，没短路的进行程序运算）


(1<3)&&(3<2)
 条件1 || 条件2：结果是一致（短路或）当条件1为true的时候，条件2就被短路。
(1>3)||(3<2)

  条件1 ^ 条件2

 异或：不同为true，相同为false
 true^false  =true
 false^true  =true
true^true  =false
false^false  =false

同或：相同为true，不同为false。

关键字：java大神们提前定义好的一些单词。这些单词是有特殊含义。
例如：public class static void out  print。。。。。
保留字：虽然现在还没有正式启用，但是预定了，也是有特殊含义的。我们也不能使用，例如：

标识符：定义用户的变量名。

常量：值是固定的，不能改变的。常量只能被赋值一次，之后不能改变。

声明方式：    final+数据类型+变量名 =一个值；   
 
强制转换格式：（加入你要变成的类型）（这里加入计算式）注意：后边最好加入括号，除了单个之外，想给个计算式变为一个类型要加括号

声明float类型的变量：格式float 变量名 值f/F
（因为系统默认是double类型  因为是float所以不想是double在值后边加个f 不分大小写）
例子：float=4.3f/F同样的即使电脑默认的是double，在写double的时候也可以写成   double=7.8d/D
数据类型转换：
小转大是自动转换   大转小是强制转换
自动转换：byte shaort int long float double (大的字节可以容纳小的，晓得字节不能容纳大的，容纳不了的需要进行强制转换。)
输入字符串用：String。拼接字符串用：+   同样写在System.out.ptintln（       ）可以用+把两个System的内容作为拼接，若果内部有数字，按照从左到右运算法则（）内有数字可以
先和值，若果在字符串之后相加，若果想在后边还要和值则需要加括号
赋值运算符：= +=  -= *= /= (可以隐藏包含的强制运算)例子：s+=1代表s=s+1.
位移运算符：(转换成二进制才可以移动，转换成0101010的形式进行移动，移动的是个十百千的位置，可以想象成是位置的移动，移动在个十百千位置上)
<101 左移两位   >>右移（尖冲那个方向就向哪边移动1：向左移动的时候【以2进制为例】这个数就乘以2的几次幂，移动多少城多少。向右移动时用这个数除以2的几次幂
并且对他取整。例如1/8取整为0.所以结果为0）
三元运算符：    写法：       比较？值：值      （除了可以比较值也可以比较字符）
if的嵌套：
在大括号中if语句中只有单句的时候大括号可以省略。（不建议省略）

                                                                                另一个类
import java.util.Scanner;(导包)(注意S大写 import与java之间有空格)（在借助所有的类中可以用import java.util.*;)
Scanner
格式：创建Scanner类型的一个变量（对象）
SCanner in=new  Scanner（System.in）;
例子：String cc=  in.next();         （一般类用int来表示）int i=in.nextint（）；
   (输出信息)
System.out.
(如何在内容中写入整数或者小数)例子：String cc=  in.next(）将String改为基本数据类型  cc=  in.nextint/next+基本类型（）
switch结构（只能判断相等情况不能判断大小情况）
   switch（判断的变量）{                  值1  值2的类型；char。int。short。从jdk 1.7版本之后支持String 枚举
   case 值1：
   //语句
   break；
   case 值2：
   //语句
   break;
   .....
   default：
   break;

} （这个类的意思代表当case1  和case2都不成立的时候才执行default）

default：当case都不成立的时候default才执行，在同一case是从上往下依次进行比较。
default：跟他在Switch类中的顺序没有关系，先比较case最后比较default，并且当default后边
break的时候，会将此后的依次执行，一旦有一个case满足，那default就不在执行。）
break作用：结束switch在switch中的判断直接结束。
如何获取字符串中的字符

循环：当需要多次重复操作时候。

1.while（判断条件）{

//重复的操作

}

2do--while循环
格式：
do{

}while（）;          （先d0后执行while 无论是真是假都会执行一次，若果while是假的将不会再进行循环）（循环体是指{内的内容}如果成立将发生循环）

迭代：每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。

1.for循环
格式：
    for（变量的初始化；循环条件（不能省略 省略了就变成了死循环，这两个结构是等价的 死循环的原因是没有判断条件）；变量的迭代）{循环体

}变量的迭代（使整个计算式趋向于迭代）
变量：
局部变量：在某个方法中，或者某个结构中
水仙花数：三位数等于个个位上数字的立方和。
循环的嵌套：
九九乘法表：
外层代表行内层代表列 。
break:用在switch的结构和其他循环体中，结束在switch和循环（指的是结束break所在的switch和循环结构）
continue:只能用在循环中，作用是结束满足条件的本次循环之后再继续进行循环，直到达到条件的要求。显示内容是不满足条件的选择条件。



数组：一组相同数的整体（集合），分配在空间的堆内存中，地址是连续的。
java中把计算机分为：栈（局部变量（在某个方法内或者形参都属于局部变量））更新速度快；堆（全局变量（在类中属于全局变量））。

直接打印数组名，在数组中代表数组的空间地址。

数组的声明：
格式：数据类型[]数组名;或者是数据类型 数组名[] （例子int x[]={};x是引用名称，是自己起的）
数组的初始化：   
静态初始化：
    格式： 数组名={21,21,21,21,1} -----------》只能连用
    格式： 数组名=new 数据的类型[]{13,24,23}                                                                                      
动态初始化：
    格式：数组名=new 数据类型[长度]
    在后面的程序中，将值存入数组。
  两种格式：int[] xx,j;两个值都是数组
           int xx[],j;xx是数组 j是变量
数组必须指定长度


数组的数据存入：格式：数组名[]=；由0开始，例子：第二位赋值为 x[1]=  ;

数组的下标：下标从0开始，

数组的长度：数组名.length      （数组.length=5;）数组的长度为5

格式：数组名[这里编写下标]=值


数组中数据打印输出：
格式：System.out.println(数组名[下标]);没有值得默认为0


数组中默认值：int byte short long 数组所在位置没有值得时候默认为0
             float数组所在位置没有值得时候默认为0.0f
             double数组所在位置没有值得时候默认为0.0
             booleaan数组所在位置没有值得时候默认为false
数组名存的是在堆中开辟的空间的首地址
数组的遍历：1普通的for循环
            格式：for（变量的初始化;循环条件;变量迭代）{System.out.println(变量);

                             }

}

           2增强for循环 for（double x:xx）(x代表数组中存储的任何一个数值)     （区别;增强for循环不会产生下标越界。）
           两者相比：普通for循环可能引起ArryIndexOtOfBoundsException（下标越界）。
。

数组中的数据查询：（查找数组中的某一个数值），数组名在栈中，创建的空间在堆中
数组中的数据修改：（修改数组的值）
数组中容易报的错误（常有的错误）
冒泡排序:相邻两个数进行比较 如果第一个数大于第二个数那么两个数互相调换（外层控制次数内层控制）
注意：动态静态不能一起用。一定要注意。
二维数组
int[] brr,crr    (这样的写法后边的全是数组)
int brr[] crr    (这样的写法后边crr为变量)
默认值和一维数组是一样的
二维数组
二维数组的声明              （第一个[]想象成行,第二个想象成列[]只能先定义行。）
格式：数据类型[][] 数组名;
      数据类型 数组名[][];
静态初始化：
格式：
 数组类型[][] 数组名={                  }

-------------------------------------------------------------------------------------------------------------------------------------------------------------
方法：java是以类为单位
方法的格式：修饰符 返回值【void空的返回值】 方法名(形参列表){}                     形参之间用逗号隔开。
类
变量
方法：分为
   静态方法；普通方法（非静态方法）；构造方法（构造器，构造子）；main方法。
   main：public void main(String()args)
   public:公共的，权限修饰符
权限修饰符：public；private（自己能用）;protectede(受保护的);default(默认的，什么都不用写就可以）.【几乎用public；private】。
static:静态的（关键字）
不写static就是非静态的。
void：无返回值类型（void代表空返回值，有无返回值看自己的写法）
main：方法名
（String()args）:形参列表，输入的参数。
定义一个非静态的方法（相当于定义一个普通方法）：
public 返回值类型 方法名(形参列表){方法体}
注意：形参列表可以有可以没有，如果有形参列表的话，这个方法叫做有参列表。
      如果没有形参列表的话，这个方法叫做无参列表。
     注意：：：—————————————————————— 方法和方法是平级的关系，不能相互嵌套。
      静态方法类名调用可以省略类名。



调用的顺序：先运行main方法自身所有的之后再寻找另一方法从他内部开始运行，然后再寻找在main方法中的调用他的。

求和类的方法：public static double 名字（double a,double b）{}
几个参数形参列表长度就为几
return:返回，用在方法中有返回值的时候。
格式：return 变量名;（谁调用你就把值给谁）。
属性：能用值表示出每个都拥有的属性。
注意：
      （2）静态方法只能访问到静态方法或者变量。
      （3）只能放在方法体的最后。
      （4）谁调用就在谁那里输出。
      （5）在lang包下的类不需要导包

-------------------------------------------------------------------------------------------------------------------------------------------------------------                                        

                                                                   面向对象
面向对象：
人------->类
狗------->类
猫------->类



类：共有的特征和行为。一个类可以有多个对象。一个java文件中只运行一个class文件。而且这个public类与文件是重名的。但是可以含有普通的class（class+类名
普通的class是没有public在前面的class。
每个class都会被编译成一个xxx.class的文件。
局部变量没赋值之前是不可以使用的。
全局变量是有初始值的。引用数据类型默认为（null）
                     基本数据类型默认为（int 0   float  0.0f  double 0.0 boolean false）



对象：万物皆对象。你操作谁谁就是你的对象，对象是某个类中的具体的一个，或者指明的。把客观世界的这一事实映射到面向对象的程序设计中.

行为:在java中体现为->方法。
特征：----->属性---->变量


把大象放冰箱分几步：1 开门 2放进去 3关门
面向过程：
面向对象：


2封装一个类--->Student
3写类。

静态方法中的main方法，它作为程序运行的入口点，在每个程序中有且只能有一个。
静态的方法随着类的产生而产生的。


调用方式：类名.方法名（）;（一般情况下类名会被运用Student s=new Student();的形式被赋值，也可以写作  s.方法名（）；）
静态的属性叫做类属性；
调用方式： 类名.属性=值;Math.abs（）；
注意：非静态的方法必须通过对象来调用。 非静态的方法可以访问静态方法和非静态方法。
方法的重载：两同一不同。
两同：同一个类中方法名相同。
一不同：形参的类型和数量。跟返回值类型无关。
-------------------------------------------------------------------------------------------------------------------------------------------------------------
构造器方法名与类名相同。构造器没有返回值，但是不可以写void。
构造器的作用：1  new 对象。
             2  给属性赋值。

无参构造方法：当你没有定义构造器的时候系统会默认提供一个无参构造方法。
有参构造方法：自己定义，参数要用类中的属性。当你定义了有参方法后不提供无参方法了在。
无参构造器：public 类名（）{}
有参构造器：public 类名（String n）{}（构造器内不能出现返回值类型，因为返回的就是个对象）

局部变量：存在于方法中的变量，语句中的都是。
全局变量：存在于类中的变量。
普通变量又叫实例变量。

构造器是会重载的（也叫over load）
局部变量和全局变量：为了区别局部变量和全局变量，需要用到关键字this。
属性==成员变量==全局变量
（this.name=name）（在局部变量和全局变量重名的时候用，this修饰的是全局变量。并且指的是当前类的对象
在main方法中不能使用this关键字，因为this是代表了对象，跟静态无关，所以在静态方法中不能使用静态）
普通方法不能调用构造器，构造器中可以调用普通方法。
构造器可以调用构造器：通过this关键字。
this（）;代表当前类的无参构造器，构造器调用构造器只能放在第一行，
必须放在无参构造器的第一行。（无参也可以调用有参，不过属性值被写死，无法改变，除非改动代码）
-------------------------------------------------------------------------------------------------------------------------------------------------------------
面向对象的三大特性：继承 封装 多态。


封装：为了保密提供一系列的接口。
在java中的。一个类只做一件事，main方法是用来测试的
1属性用private修饰，
2提供public方法（接口）
命名的时候要见名识意。set/get用来给属性赋值和取值的。而且能对你的值进行控制。；
格式：setName(String name){};
getName(){return name;}
定义一个方法将所有的属性都调用到一个方法中。
tostring（）;
格式：public String ToString(){}

-------------------------------------------------------------------------------------------------------------------------------------------------------------
继承：扩展
好处：1使得原本没有关系的两个类产生了关系。
     2减少了很多重复代码。提高了代码的复用性
弊端：打破了封装，不利于隐藏。
普通方法：子类对象调用普通方法的时候，若子类中有和父类中一样的方法，调用的时候调用子类的，（就近原则）
若子类中没有该方法就调用父类。
在子类重写中，子类的修饰词必须比父类的修饰权限要大，或者相等。
-----------------------------------------------继承研究的是对象与对象之间的关系，与静态无关，能访问，但是静态的属性和行为不参与继承。
super代表当前的父类（写在哪就代表谁的父类）。super（）代表父类的构造器。
在都调用构造器的时候，this与super不能同时存在。在子类中都会调用第一行
多个相互继承的时候从最老的父类开始依次执行，输入


1，当父类中只有有参构造器的时候，系统就不会提供无参构造器，而对子类来说，子类只会调用无参构造器，父类的无参找不着了，所以报错。

当父类中只有有参构造器的时候子类构造器中，需要在子类构造器中手动调用父类的有参构造器。
子类不能继承父类的构造器只能通过super来调用。

子类构造器一定调用父类的构造器。
类一定有构造器。
子类构造器默认调用父亲的无参构造器。
super（）代表调用父类构造器，必须写在子类构造器的第一行。
注意：如果父类构造器没有无参数构造器，在子类中必须声明，明确指出调用父类的有参构造器。
编程建议：所有的类都提供无参构造器，以免减少继承时候的麻烦。
关键字：extends   格式：public class Student extends Axx{}
把student称为子类，把Axx称为父类。
方法的重写：子类的方法名，返回值，形参列表都一样，只有方法体不同。
重写发生在子类和父类之间，再有继承的情况下。当父类的方法不能满足子类的需求时需要重写子类。
在java中，只能继承一个类，一个类只能有一个父类。
java值支持单继承，原因避免产生方法调用的不确定性。
抽取不同类的相同属性和行为叫做抽象。
-------------------------------------------------------------------------------------------------------------------------------------------------------------
多态的前提是在继承关系下
概念：父类的类型的变量指向了子类类型的对象。
if（a instanceof Dog）{}
面向对象的五大基本原则：
单一职责原则（SRP）：一个类去实现一个功能，而不去做太多的功能实现。
开放封闭原则（OCP）：对扩展是开放的，对更改是封闭的。
里氏替换原则（LSP）：子类可以替换父类并且出现在父类能够出现的任何地方
依赖倒置原则（DIP）：最上层的模块通常都要依赖下面的子模块来实现，也称为高层依赖低层！
                     所以DIP原则就是要逆转这种依赖关系，让高层模块不要依赖低层模块，所以称之为依赖倒置原则！
接口隔离原则（ISP）：用多个专门的接口比使用单个接口要好的多！

抽象方法：在不同的类与类之间抽取共同的属性和行为，格式；public void eat（）；
关键字：abstract,格式:public abstract void eat（）；abstract也可以放在public前边。
类与类之间区分也用abstract。格式abstract public class Animal   abstract也可以放在public前边。
抽象类不能创建对象。
抽象类有没有构造器？？？？有，是为了让子类去创建对象。构造器不能继承，所谓的抽象只体现在方法。
抽象方法：没有方法体
         2用abstract修饰。
         3强制子类重写。

如果不想重写父类的抽象方法，可以在子类中加入abstract;
构造器是用来创建对象的。
抽象类可以有普通方法。
抽象类可不可以全部是普通方法？可以有。

-------------------------------------------------------------------------------------------------------------------------------------------------------------
接口：（是最抽象的）1方法全部是抽象方法。
                   2规范
                   3属性：是常量不可以是变量。
关键字：interface（接口）
接口中默认的全部是抽象方法。所以在定义方法的时候不用写abstract。
定义一个常量的方法：public static final int A=10（在数据类型前加入final）静态方法可以直接通过自己的类调用。直接写类名。方法名（）；
方法默认的修饰符：public abstract（只是在接口中）
属性的默认修饰符： public static final（只是在接口中）
在接口中定义的常量要大写。

-------------------------------------------------------------------------------------------------------------------------------------------------------------

代码块：一堆大括号之间的内容部分，称为代码块。

静态代码块：用static修饰的代码块。
结构：
static{


}
构造代码块：（动态块）(全局代码块)
结构：
{
}
构造方法（构造器）：

静态是和类绑定一一起，在main方法中没写也会在main方法中显示执行。
代码块执行顺序：静态代码块-->构造代码块-->无参构造器。
静态代码块只在程序中执行一次，每次运行无参构造器的时候都先运行一次构造代码块。（无论有参还是无参都是构造代码块先执行）
构造方法是在进行创建对象的时候才开始学习的。

多个构造代码块在一起的时候有顺序，从前往后执行。
-------------------------------------------------------------------------------------------------------------------------------------------------------------

单例模式：只有一个对象。当一个模块被多个模块使用的
那这个共用模块的模块设置为单例模式（电脑中的回收站）
instance：实例（也是对象）
构造器私有化：给别人提供一个静态对象：(public static Persong p=new Person)
双等比较的是在堆中的位置
三大步骤：
饿汉式单例模式     
         1构造器私有化（private （）{}）
         2声明一个私有的静态对象（private static final Person x=new Person（）；）
         3提供一个公共方法将对象返回（public static Person getduixiang(){return p;}）   

懒汉式单例模式：  

         1构造器私有化（private （）{}）
         2声明一个私有的静态对象（private static  Person x=null；）
         3提供一个公共方法将对象返回（public static Person getduixiang(){+一个if条件语句堆null进行判断然后return p;}）

单例模式： 饿汉式
          懒汉式
          注册机模式
常用的开发模式23种。
饿汉式是在单例类的实例在JVM启动时就创建好了，懒汉式则是在第一次访问单例类的实例时才去创建，
即可以把饿汉式看成是预加载，懒汉式则为延迟加载；
饿汉式的单例类实例由于是在JVM启动时创建的，所以不用考虑多线程问题，懒汉式则需要进行同步
-------------------------------------------------------------------------------------------------------------------------------------------------------------

简单工厂模式：（不属于23种的任何一种）为了减少后期代码的维护量.

-------------------------------------------------------------------------------------------------------------------------------------------------------------
一个接口中有3个方法,只需要用一个该怎么办:在两个类之间加入一个适配器,让所有人调用这个类,在实际工作中可以减少代码的复写率.



                                                                       异常



1异常：程序不能正常或者正确的执行，遇到了意外。（Exception异常）
2用户造成太大的损失，所以需要对异常进行处理。
3异常体系：                                                
                                                            Throwable
                                               ----------------------------------
                                               !                                !
                                             Error(错误）               Exception（异常）
                                                                       ！              ！
                                                               RuntimeException   CheckedException
                                                                    运行异常         变异异常
                                        
                                         Error：程序员不用处理。通常指的是程序的中重大问题。
                                              比如内存溢出，网络中断，断电等。
                                        
                                       Exception:程序员需要处理。由于程序员的粗心产生的异常，
                                                所以需要处理

4异常的处理：try catch  finally  throw  throws
格式1：
try不可以单独存在。如果没有catch就直接用finally。
try{

//try块:放可能会出问题的代码。


}catch（异常类型 对象）{

//处理异常：给用户（程序员一些提问）

}
执行顺序：当try中代码正确的时候，catch块就不执行，
         当try中有问题的，从产生问题的行开始直接进入catch块，
         捕获异常，并打印异常信息和产生异常的位置。

try块中可以出现return，并且必须放在try块或者catch的最后一行
  注意：可以在后边写多个catch。一个try可以有多个catch，并且每个catch是有顺序的，只有一个finally。
        可以出现关键字return但是不影响finally
        先写小的不包含其他catch的内容的catch，依次向下写。
try中可以嵌套try但是不建议这么做，因为降低执行效率.




catch中可以有三种写法：1 System.out.。。。。   
                      2 e.getMessage(只告诉你有错误信息)
                      3 e.printStackTrace();（告诉你信息和具体错误存在的位置，是常用的报错方法）

格式2：
try{

}catch（）{


}finally{
处理程序之后必须要做什么写在finally中。
例子：切断电源/流IO 关闭流。

}

不管程序有没有错，都要执行finally块。
final，finally区别:
final:1修饰类，类不能被继承。
      2修饰的变量 变量变成了常量，
      3修饰方法的时候方法不能被重写。
finalize()
          当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

throw new Exception();
throws Exception（用在方法名后面告诉使用者有抛异常）
格式：throws 异常类型
      throw 异常对象

String:字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为 String 对象是不可变的.代表的是一个字符串。
StringBulider:一个可变的字符序列
StringBuffer:线程安全的可变字符序列

 我们明明就是改变了String型的变量s的，为什么说是没有改变呢? 其实这是一种欺骗，JVM是这样解析这段代码的：首先创建对象s，赋予一个abcd，然后再创建一个新的对象s用来　　
执行第二行代码，也就是说我们之前对象s并没有变化，所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，
而原来的对象就会变为垃圾被ＧＣ回收掉，可想而知这样执行效率会有多底。

而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，
这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

抛异常的处理：1继续向下抛异常
             2用try/catch处理                                                   

-------------------------------------------------------------------------------------------------------------------------------------------------------------
                                                                                     内部类



内部类:一个类内部的类：
外部类:在内部类外部的类：
局部内部类：在外部类的方法体中，局部内部类在访问外部的局部变量的时候，这个局部变量要用final修饰。
匿名内部类：当一个类只用一次的时候就叫做匿名内部类
匿名对象：当只用一次的时候可以考虑用匿名方法。
格式：：new 接口类型（）{

  重写接口中的方法，}
格式2：new 抽象类（【形参】））{
  重写抽象类的方法}
-------------------------------------------------------------------------------------------------------------------------------------------------------------API(-);


               public    protected     default      private

本类            yes         yes         yes           yes

同一个包中类    yes         yes         yes           no

不同包的子类    yes         yes         no            no
 
不同包的类      yes         no          no            no

Arrays:数组操作类
Random：随机类,用来产生随机数。
Math：数学方法解决
Date:
Calendar:(Calendar c=Calendar.getInstance();)

SimpleDateFomat:    创建当前系统的日期
                    Date dd=new Date();
                    设置格式
                    SimpleDateFormat sdf=
                    new SimpleDateFormat("yyyy\\MM\\dd HH:ss")
                    格式化：
                    String str =sdf.format(dd);
                    打印
                    Syso(Str);
-------------------------------------------------------------------------------------------------------------------------------------------------------------
为什么出现集合类？
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，
就要对对象进行存储，集合就是存储对象最常用的一种方式。

数组和集合类同是容器，有何不同？
数组虽然也可以存储对象，但是长度是固定的，集合长度是可变的，
数组中可以存储任意数据类型，集合只能存储对象。


集合类的特点

集合只用于存储对象，集合长度是可变的，集合可以查出不同类型的对象。
                  

区别：
collection：
collections：

                                                                      集合：

集合分为两大类，单值集合：list set  collection iterator和他的子类
               双值集合：Map和他的子类
collection：集合，装各种数据的容器。

包装类：自动拆箱自动装箱。可以直接将类型默认为integer类型，不用每个都接收，可以直接对象.（参数）；
ArrayList：底层是以数组的方式存储，可以重复存放相同对象。查找，增加，删除效率高
迭代器必须掌握。

存放形式不同所以分了很多种接口

                                                 collection

                                                      |
                                             ------------------
                                             |                |
                                            List(接口)       Set（接口）

ArryayList:数组，下标，有序，可以重复
Collection：集合，装各种数据的容器。
List有序的（下标的），可以重复的。
Set:无序的，不能重复的。
浅复制（浅克隆）：
深复制（深克隆）：
LinkedList:链接列表  列表  双向列表
peek:查看但不移除；
poll：移除并返回该对象
先进来的的数据会被压倒栈底，后进来的位置永远是1
-------------------------------------------------------------------------------------------------------------------------------------------------------------
        collectio
           |
          set
       ----------
     |              |
  HashSet        TreeSet
Hashset：为了满足set存储数据的特点（不能重复）
不能重复:指的是属性值不能完全一样。
要是属性值完全一样的时候，我们就不能让他继续存进去。
此时用HashSet来实现上面的效果，需要在自定义的类中重写hashcode（）&&equals()方法。          
这两个方法在后期开发过程中，不用自己写，会自动生成。
Treeset:无序不能重复，类型要匹配，
Treeset：他的底层是红黑树（二叉树）              注意：红黑树是为了实现自然排序。
需求：自定义类的对象存进Treeset要进行排序。
1,：自定义的类实现接口。
2:重写compareTo()
方式2：comparetor：自定义排序
Treeset(Comparator  x)
stack:表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。
在运用过程中，search所找的位置从最后放的位置算起为1，最早放的是最后一个数
import java.util.Stack;
public class Lianxi4 {
public static void main(String[] args) {
    
    Stack x=new Stack();
    x.push(12);
    x.push(14);
    x.push(56);
    boolean z=x.empty();
    System.out.println(z);
    Object h=x.peek();
    System.out.println(h);
    /*h=x.pop();
    System.out.println(x);*/
    int j=x.search(12);
    System.out.println(j);
}
}

Map:将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值

          Map
-----------------------
|                     |
hashMap             TreeMap


面试题：hashMap和hashTabe的区别
Hashtable 是同步的，安全，效率低。
HashMap此实现是不同步的，不安全，但是效率高。三大框架把线程安全问题已经给解决了，只要你做B/S就不用担心安全问题。
键不能重复，重复的话就把原来的覆盖了。覆盖之后之前的就没有了。


如果把自定义的类的对象作为HanshMap的键的时候，为了实现不能重复的效果，需要在自定义的类中重写Hashcode（）和equals（）方法。
若果把自定义的类对象作为TreeMap的键的时候，为了实现键要排序，
所以1：自定义的类要实现Compareable接口，重写compareTo（object o）方法。，
    2：自定义一个比较器，实现Comparator接口，重写
       compare（Object o1,Obeject o2）
-------------------------------------------------------------------------------------------------------------------------------------------------------------

泛型：
在集合中的泛型<>控制存入集合的类型。
泛型类:(尖括号里边写的包装类用来限制类型，并且创建对象的时候是要写你限制类型的类型,可以写多个类型在尖括号里，之间用逗号隔开 )
格式：publi class 类名<T>{

}

通配符只能作为形参传进来。泛型的上限public static void show（List<? extends Number> 1{
}
                         泛型的下线public static void show（List<?super String> 1 ）{}


（-）字节输入流：InputStream  字节输出流：OutputStream:
     字符输入流：reader       字符输出流：writer

流：读和写的区别：1刷新：字节自动刷新，字符一定要刷新（.flush）
                 2读：文件存在。写：不要求在


输入流：在java程序中，从文件中读取到内存中。
输出流：在java'程序中从内存写到文件中。

缓冲区：缓冲区在内存中。
缓冲区的目的：缓冲区是为了提高读和写的效率。

缓冲流：是操作缓冲区的流：在字节输入流；输出流。还有字符输入流和输出流前边加Buffered.
字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的；而字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件
字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。
-------------------------------------------------------------------------------------------------------------------------------------------------------------

Properties:java.util包下，集合和流整合的一个类。继承Hashtable，他是键值对形式，健和值必须是String类型。也就省去了泛型。
实际开发中配置文件：用的都是properties文件。
Properties：在这个文件中，#代表单行注释。
-------------------------------------------------------------------------------------------------------------------------------------------------------------
                                                              序列化和反序列话


把对象写入文件：改set只是改内存中，而要写入文件中必须运用store。

ObjectInputStream：读的则个过程叫做反序列话（要熟悉运用读出与写入对象）

ObjectOutputStream：写的这个过程叫做序列化。，
接口：Serializable（标志接口：里边既没有方法也没有属性的接口)
只有实现了Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常。
Java序列化就是把对象转换成字节序列，而Java反序列化就是把字节序列还原成Java对象。
-------------------------------------------------------------------------------------------------------------------------------------------------------------
反射：--->反编译   反编译不能获取方法体。
-------------------------------------------------------------------------------------------------------------------------------------------------------------
线程：将并发的每一件事情完成叫做线程。
多线程： 一个进程可以做多件事。一个进程可以启用多个线程
进程：（运行中的程序）开启了什么程序。
重点就是安全问题
与线程有关的类：
第一步：：：：创建新执行线程有两种方法，一种方法是将自定义的类声明为Tread的子类。
该子类重写Thread的run方法，run方法这里写的是你想执行的功能，写在run方法中。
第二步：：：：用start开启线程。（如果直接调用run是普通方法，调用start是多线程）。注意：在写入主线程的时候先开启子线程才会发生多线程同时进行的效果
继承的局限性：资源不能共享。并且继承过之后就不能继承别的类



创建线程的第二种方式：
Thread:
Runnable:

线程的状态：
      新建
-----------------          冻结（是写在run中的方法单位是毫秒thread.sleep）
                \            |
                 \           |
                  \      （1）stop方法
                   \开启------------------------消亡（消亡之后无法在开启，只能改写代码）
                         （2）run执行完毕  
 

冻结状态是不能不执行的，消亡状态是不在执行，阻塞是为了等待cpu的执行 、一旦线程启动，它就永远不能再重新启动。只有一个新的线程可以被启动，并且只能一次。
一个可运行的线程或死线程可以被重新启动。            


线程的生命周期：出生状态，就绪状态，运行状态，等待状态，睡眠状态，阻塞状态，死亡（消亡状态）。
或者说：新建 开启 运行 阻塞 睡眠 死亡。
用实现方式创建线程的话可以实现资源共享。
建议：实际开发用实现方式，方便以后的扩展。
线程的安全问题：（在代码中指的就是数据的安全问题）。synchronized同步
同步代码块：synchronized（对象）{}  例子银行卡操作问题。
同步方法：synchronized（在继承中同步方法不实行）
线程的优先级：最小为1最大为10（优先级越高，指cpu对你执行的概率会变高，但不一定会先执行）线程默认的优先级是5
同步的前提：
1，必须要有两个或者两个以上的线程
2，必须是多个线程使用同一个锁
3，必须保证同步中只能有一个线程在运行
 
好处：解决了多线程的安全问题
synchronized(对象)//这个对象可以为任意对象
{
    需要被同步的代码
}
继承Thread类的，我们相当于拿出三件事即三个卖票10张的任务分别分给三个窗口，
他们各做各的事各卖各的票各完成各的任务，因为MyThread继承Thread类，所以在new MyThread的时候在创建三个对象的同时创建了三个线程；

实现Runnable的， 相当于是拿出一个卖票10张得任务给三个人去共同完成，
new MyThread相当于创建一个任务，然后实例化三个Thread，创建三个线程即安排三个窗口去执行。pk2
在单线程中不会出现线程安全问题，而在多线程编程中，有可能会出现同时访问同一个资源的情况，这种资源可以是各种类型的的资源
临界资源：一个对象 一个属性 一个文件 一个数据库。
　在Java中，可以使用synchronized关键字来标记一个方法或者代码块，当某个线程调用该对象的synchronized方法或者访问synchronized代码块时，
这个线程便获得了该对象的锁，其他线程暂时无法访问这个方法，
只有等待这个方法执行完毕或者代码块执行完毕，这个线程才会释放该对象的锁，其他线程才能执行这个方法或者代码块。
-------------------------------------------------------------------------------------------------------------------------------
正则表达式：为字符设置规则，判断字符串是否满足某一种规则，如果是返回trule如果不是返回false。
正则相关的一个类：Pattern

\t：空格
\n: 换行
\r：回车
正则表达式难在格式、
正则表达式的第一个作用：匹配，检验是否满足某种格式。
           第二个作用：替换  把满足的换成另一种。
           第三个作用：切割