java基础笔记

一、Java三个平台：（面试题）
 J2EE：(企业版)企业级应用程序开发；
 J2ME：(微缩版) 嵌入式开发；
 J2SE：(标准版) 用于桌面应用程序开发；

二、java语言的特点：（面试题）
 面向对象的、安全性、可移植性、 并发性、跨平台性；
      GC（面试题）:垃圾回收机制， java会自动回收长时间不被使用的某些对象内存空间；

三、开发工具：（不允许用中文版本）
 Eclipse(免费、绿色版)、Myeclipse 8.5以上版本（收费、集成了很多插件)；

Class:类，具有相同特点的一类事物；
类的声明：
访问修饰符 class关键词 类名{
  定义的属性或者方法
}

public class 类名{

}

四、Java文件的执行过程：
Java文件必须是.java结尾的文件，通过javac.exe中javac命令通过
编译器进行编译成.class文件， 再通过java.exe中java命令通过
JVM的解析器进行解析执行；

五、Java语法规则：
Java语言区分大小写：
类名：必须开头字母大写，其他字母小写；后面每个单词开始开头字母大写；
注释：解释说明或者让部分代码不被执行；
(1)单行注释： //
(2)多行注释：
 ①
    /  
 
    一般放在方法上方或者类名上方，解释说明该类或者方法的作用；
     /
 ② /
    只用于解释说明或者代码注释
     /

 

Java文件格式：
 （1）java文件必须以.java为后缀
 （2）文件名必须跟public修饰的类名相同。
  一个java文件中可以写多个class类，但是注意：一个java文件中只允许写一个public修饰的类；
 每一个类都会被编译为一个.class文件;
 （3）主函数必须写在public修饰的类中；
 

java 标示符命名规则：(只能由$  下划线_ 数字 字母组成，不能以数字开头)
  （1）类名：开头字母大写，后面每个英文单词第一个字母大写其他都小写；
  （2）字段或者属性名：必须开头字母小写，第二个引文单词开头字母大写，其他小写；
      注意：方法名、类名、常量等字段不允许使用关键词；
     goto不是关键词，是java中的保留字；

变量和赋值操作：
局部变量和全局变量：
  全局变量；声明在类中，每个方法都可以使用
  局部变量：
         局部变流量、声明在方法中，或者方法的参数，只能当前方法使用；
  方法中声明的局部变量，必须赋初始值；或者有赋值的操作；

八种基本数据类型：（面试题）
   数据类型：八种基本数据类型（必须记住）
   (1) 字节型byte-8（2）字符型char-16
   (3)短整型short-16  （4）整型int-32 （5）长整型 long -64
  （6）单精度浮点型 float-32 (7) 双精度浮点型double-64
  （8）布尔类型 boolean  true或者false
  注意：String 字符串不是基本数据类型中的（笔试题）
引用数据类型：除了以上八种基本数据类型以外都是引用数据类型；
   引用数据类型在内存中存放的是指向内容的地址；

基本数据类型之间的转换：（=号表示赋值操作，要求两边数据类型必须一致；）
   基本数据类型中数据转换方式：
   (1)隐式转换：即程序自动将某个类型转换为另一种类型， 不需要程序员手动转换；
   (2)强制转换：（类型）数据或者字段
     浮点型之间： double->float　
     整型：  long->int->short->byte
             特殊情况： 例如： short i=10;  byte b=101;
     浮点型->整型(注意：小数点会被全部舍去，取整)
       字符类型：
           long/int/short/byte->char 强制转换
           double/float->char 需要强转
           char->short/byte 需要强转 (char 定义并赋初始值时int/short 不需要强转)

常量：
  通过final 声明，声明在类中；必须赋初始值，并且不可以再次赋值；
   常量命名时字段名必须所有字母大写(规则)；
  例如：PI 圆周率；

运算符和表达式：
+号：
  两边是数值类型才进行加法运算；
  注意： 整型之间+法运算时，会往位数长的类型进行隐式转换；
        例如：   int i=10;
      long j=100;
           int s_1=(int)i+j;（i+j返回long类型）
  拼接字符串： 注意：如果数值也在字符串中，此时注意是否要改变优先级；
   例如： String str_1='A'+"abc"+"ABC"+100+10;//AabcABC10010
 
        String str_2=100+10+'a'+"abc"+"ABC";//207abcABC
 （以下运算符必须是数值之间）
  -号：做减法运算； *号乘法运算；
  /除法运算（分母不能为0） % 取余数
  >>  << 位移运算符（忽略）
  笔试题： 2如何最快速的得到8
   System.out.println(2<<2);
++; i++ 表示该字段先参与运算或者是操作，然后自身加一；i=i+1; i+=1;
    ++i;表示该字段先自身加一然后参与运算或者操作；
    
--;
   i--;表示该字段先参与运算或者是操作，然后自身减一；i=i-1;i-=1；
   --i;表示该字段先自身减一然后参与运算或者操作；
   注意：
 short i=10; i=i+1;(错误，没有强制转换)
            i+=1；(正确)

逻辑运算符和位运算符：（笔试题，&& || & | 区别）
 逻辑运算符&& ||（也叫做短路运算符）
   &&逻辑运算符与，两边必须返回boolean类型，两边同时为true 结果才为true
      &位运算符与
   ||逻辑运算符或，两边表达式如果有一个为true，此时结果返回true；
     |位运算符或
&：表示普通与，所有的判断条件都要依次执行；
&&：若干个条件，如果前面的条件返回false,那么后面不再判断，就是false;
|：表示普通h或，所有的判断条件都要依次执行；
||：若干个条件，如果前面的条件返回true,那么后面不再判断，就是true;
位运算：&表示位与运算，|表示位或计算
！号表示取否：
 例如：
 boolean f_2=!((j=4)<10)||(j=100)<5;//!号表示取否
        System.out.println(f_2);
> >=  <= < != ==
 

条件判断语句：
if(返回boolean类型的表达式){
   如果满足上面条件，此时会执行该语句段；

}else{
  前面所有条件都不满足，执行该语句段；
}

if(条件){}
else if(条件){}
else if(条件){}
else{}

if(条件){

}

流程判断语句：
 只能判断的数据类型有：byte short int char
 switch(字段){
          case 字段：
       操作；
   break;
  case 字段：
       操作；
   break;
         ..
   default:
  操作;
   break;
       }

循环语句：
  for循环和while循环：
 for循环：
         第一种：
    int i=0;
   for(;i<=9;){
   
    System.out.println(i);
    i++;
   }
  
   第二种：
  
   for(int j=0;j<=9;j++){
    if(j>5){
     break;//退出整个循环
    }
    System.out.println(j);
   
   }
    第三种：
   int a=0;
   for(;a<=9;a++){
    System.out.println(a); 
   }
  
  
   第四种：
   for(int b=0 ,c=0;c<5&&b<3;c=c+2,b++){
    System.out.println(c+":"+b);
   }
  
  while循环：
 while(条件){循环体}
 do{循环体}while(条件);不论是否符合条件都至少执行一次循环体；

  continue和break用法(笔试题)
    break只能用在switch中，或者循环中；
    continue:只能使用在for或者while循环中，表示跳出当前循环，继续下次循环

java.lang是java的基本核心包，使用lang中的类或者接口等，不需要引入包；

String类：
  String字符串特点是：不可变、有一个默认存储的字符串池；
  例如： String str=“abc”； abc默认存储在字符串池中；一个对象
        String str_2=new String("abc");  abc默认在字符串池中，此时new 会重新分配一个内存地址，因此此时new String("abc") 创建了两个对象；
String类中常用方法，length()/indexOf(...)/lastIndexOf(...)/split("")/trim()/toString()/concat("")/compareTo("")
      toLowerCase()/toUpperCase()/charAt(int index)/substring(...)/replace("","")/equals("")

 

包装类：
 即基本数据类型所对应的类；

 byte：Byte
 char：Character

 short:Short
 int:Integer
 long:Long

 float:Float
 double:Double

 boolean:Boolean

 

基本数据类型中常用方法：parse... 例如： Integer.parseInt(""); //参数必须是纯数字的字符串
           Double.parseDouble("");
           Short.parseShort(“”);
           Long.valueOf("")；
==比较和equals方法比较：
  ==即比较内容也比较内存地址；
 例如：String str="aaa"; String str_2=new String("aaa");
 str==str_2 返回false；因为内存地址不同；

equals方法比较只比较对象内容；
 例如：
 str.equals(str_2); true
equals方法比较时特殊情况：
    注意：  Integer i=10;
 String str="10";
 System.out.println( str.equals(i.toString()));//true
        System.out.println( str.equals(i));//false

 
==比较时，基本数据类型特别：以int和Integer为例：
        int a1=10;
        Integer a2=10;
        System.out.println("第1组："+(a1==a2));//true
       
       
        int b1=10;
        Integer b2=new Integer("10");
        System.out.println("第2组："+(b1==b2));//true
       
        //特殊情况（ ）
        Integer c1=10;
        Integer c2=new Integer("10");
        System.out.println("第3组："+(c1==c2));//false
       
        Integer d1=10;
        Integer d2=10;
        System.out.println("第4组："+(d1==d2));//true
       
        //特殊情况( )
        Integer e1=128;
        Integer e2=128;
        System.out.println("第5组："+(e1==e2));//fasle 注意：<127 true

什么是NULL？
 null就是空，什么都没有，跟“” ‘’ 不同；
 注意 :Integer i=null;//正确； Integer 如果声明在全局变量中；Integer i;此时i默认为null而不是0
 例如：
  Integer i=null;//√
  int j=null；//×
  Integer i=new int[10];//×
  int j=new Integer[2];//×

 
 
一维数组的定义和使用：
   数组即一组存放数据的集合，可以存放多个相同数据类型的对象；
      默认下标从0开始；
      注意：数组长度不可变；
   数组必须先定义再分配空间，然后在使用；

  例如：（1）
     int [] items=new int[5];
    String[] items2=new String[2];
         (2)
           int[] items=null;
    items=new int[10];
         (3)String[] items={"DFE","SDF","A"};
  注意：Integer[] items=new Integer[4];//此时items中元素默认值为null而不是0
        int[] items=new int[2];//此时items中元素默认值为0；

 数组的遍历：
    （1）增强for循环：
       String items[] ={"A","D","S"};
       for(String a:items){
       System.out.println(a);
    }
    (2)for循环遍历
      String items[] ={"A","D","S"};
       for(int i=0;i<items.length;i++){
       System.out.println(items[i]);
    }

面试题：数组有leng属性，String字符串有length()方法；

数组的赋值：
(1) System.arraycopy(被复制数组, 被复制数组元素起始下标, 目标数组，目标数组起始下标, 被复制元素个数);
   //该方法会将目标数组每个元素覆盖，目标数组长度不变

(2)Arrays.copyOf(被复制数组，赋值元素个数)和Arrays.copyOfRange(被复制数组，起始下标，截止下标)
  
String items[]=Arrays.copyOf({"A","B","C"}, 2);//表示从指定数组中赋值几个元素，从下标0开始复制
  
String items[]=Arrays.copyOfRange{"A","B","C"},2, 3);//从指定数组中赋值元素，从某个位置到某个位置

String中split("")将字符串按照子字符串拆分数组：
例如：（这里\表示转义字符，但由于|特殊，只能写\\转义）
 String res="ABC|sdfd|sdf|e3e3434";
 String[] resArray=res.split("\\|");//\ 表示转义字符，但是由于|特殊，只能\\转义

两个数值互换：
 （1）数组两个值互换
   String testArray[]={"a","b","c"};
  String tag="";
 tag=testArray[0];
 testArray[0]=testArray[2];
 testArray[2]=tag;
   
 (2)不通过第三方字段，进行互换两个int变量的值；
    int a=10;
    int b=20;
    b=a+b;
    a=b-a;//a=20
    b=b-a;//b=10

 

 

 

面向对象内容：
 
  面向对象和面向过程区别（面试笔试题）：
  面向对象：将复杂的问题简单化，划分为多个对象，将每个对象实现，即可完成复杂的问题；
    强调的是处理问题的方法；
  面向过程：将一个问题按照步骤依次完成， 面向过程强调的是处理问题的步骤；
 
  对象：可以将任何事物都认为是对象。 程序中体现在类、方法、属性、我们可以将他们看做对象来处理；
 
面向对象的三个特性（面试笔试题）：
 继承、多态、封装

 多态：（一个事务可以有多种形态）体现在方法的重载、重写、以及对象的实例化；
 封装：（隐藏细节）体现在变量的私有化（只能通过get或者set方法访问），以及方法、和类通过不同访问修饰符的修饰限制访问的范围；包对类或者接口的组织；

面向对象的三个过程：
 面向对象分析（OOA）、面向对象设计（OOD）、面向对象编程（什么是OOP？）

类的声明：
   访问修饰符 class 类名{
  
   }
   其中：
   public 是修饰符，表示公共的，谁都可以使用该class
   private 是访问修饰符，表示私有的，只能声明方法和属性，表示该方法属性，只能
   当前类使用，其他类访问不到；
  
   先记住规则：
     static声明的方法中不允许直接使用非static声明的变量或者方法；
   
    属性：
      (1)全局属性：即全局变量或者成员变量或者类变量,声明在类中，当前类多个方法都可以使用
      (2)局部属性也叫做局部变量：声明在①方法体中-必须赋初始值②方法的参数-方法被调用时，外部进行赋值，供当前方法使用；
     
    方法声明：
     (1)无返回值的方法：
     访问修饰符 [static] void  方法名(参数){
    
     }
    
     （2）有返回值：
     访问修饰符 [static] 返回值类型  方法名(参数){
    
      return 返回的具体数据值；
     }
     注意：void和return是互斥的；
     
  return/continue/break区别(笔试题)：
      return:跳出整个方法体，表示当前方法有返回值；
      continue:只能用在循环中，表示跳出当前循环体，继续下面循环；
      break:只能用在循环或者流程判断语句中switch中，表示退出整个循环体

 

 对象的实例化：
 new 表示实例化对象，只有类才可以被实例化，表示通过这个类创建一个对象，
      该对象是这个类的一个具体个体实例；例如：张三，是人类中一个具体实例；
  例如：
  Person person1=new Person();//实例化，表示由这个类，创建一个对象，这个对象是这个类的具体实例；
   person1.name="张三";
   person1.age=23;
   person1.address="河北省";
  
   Person person2=new Person();
   person2.name="张三";
   person2.age=23;
   person2.address="河北省";
  
   System.out.println(person1.equals(person2));//false
   System.out.println(person1==person2);//false

 
  上面两个person对象，虽然有相同的属性，方法，被同一个类Person实例化出来，但是没有可比性，不论
  ==还是equals都是false；
 

值传递和引用传递：
 引用传递传递的是对象的引用即地址，可以修改该对象中属性或者该对象；
 值传递：只传入了对象的数据值，而不是引用；因此通过方法无法修改该字段值；
 例如：
     public static void test1(Integer j){
   j=100;
     }

     int i=10;
     test1(i);//值传递，此时i值仍为10；

构造方法的使用和定义：
 构造方法即在实例化时就被执行的方法，有以下特点：
　　　
 （1）构造方法名必须跟类名相同；任何一个类都有一个隐式的无参构造方法；
 （2）构造方法被实例化时被执行， 不能使用void、return、默认public修饰的；
 （3）不能使用static、abstract、final、native等关键词修饰
 注意：多个构造方法可以通过参数个数、类型区分，　写无参构造方法时，必须将无参的写出来；
构造方法的使用：　常用于初始化成员变量；

static 只能声明属性和方法，声明的属性是静态属性，声明方法是静态方法；
    （1）声明的静态方法，可以直接有类名打点调用；
    （2）static 中不允许使用super和this
    （3）static 声明声明的字段，只能被实例化一次；表示该属性被声明static时，就已经被分配了内  存空间；(后面将静态初始化块是再验证)
    （4）static 声明的属性，被同一个类的不同实例共享；

初始化块和静态初始化块：
 初始化块： 类被初始化，即new时被执行，比构造方法早； 声明变量也是局部变量；
 静态初始化块： 类被使用就一定会被执行，永远被执行一次；比初始化块执行还早；
 {
   初始化块；
  }
  static{
   静态初始化块；
  }

包：即文件夹，也就是文件的一种组织形式；程序中叫做package；
   如果某个类在bochy/test中此时程序描述为：
   package bochy.test;
   public class T{

   }
  如果程序需要使用非java.lang包下或者其他包中的类或者接口；此时需要import 引入包中的类或者接口；
 

方法的重载overloading：
  即放生在同一个类中，方法名相同、参数个数或者参数类型不同；
  方法重载目的是让同一个方法，具有不同的功能和操作，使方法具有多种处理方式和更大的拓展性；
  例如：String中的indexOf方法， 它就有多种形态；

继承extends：java中支持单继承，即一个子类只能有唯一的一个父类；
子类继承父类中非私有的方法和属性；final声明的类无法被继承（例如：String）；
构造方法也无法被继承；
实例化子类时，先实例化父类，即父类构造方法先执行，然后再实例化子类，子类构造方法再执行；

注意：所有类的父类是Object；即Object类是所有类的基类（父类）；

使用继承的好处：
（1）子类中继承了父类的方法或者属性，此时是子类变得更简单，节省代码量；同时子类具有了父类相同
     的功能操作；
（2）可以对已有程序进行拓展，例如：子类可以重写父类中方法，对父类中已不满足目前需求的方法进行扩展；
     子类也可以声明一些方法，弥补父类中已有方法的不足之处；
使用继承缺点：
  如果过多的使用了继承，会使程序变得更加复杂臃肿，不便于维护；
  使父类暴露了细节，打破了封装的特性（即隐藏细节）；
  父类被修改，会影响子类方法相关方法；

重写overwrite：发生在继承中，子类中重写父类的方法；
     方法名，返回类型、参数个数、类型必须完全相同；

重写和重载区别（面试笔试题）
重写（覆盖）：发生在继承中，子类继承父类重写父类方法，方法名必须相同，参数个数、类型，返回值必须都相同；
重载：发生在同一个类中，方法名相同，参数个数，顺序不同；

笔试题：子类继承父类，然后父类子类中分别有无参构造方法、初始化块、静态块；问执行顺序？
 父类静态初始化块
 子类静态初始化块
 父类初始化块
 父类构造方法被执行
 子类初始化块
 子类无参构造方法

this和super区别（笔试题）：
两者都不能用在static方法中；
this：表示当前类对象，常用于（1）区分参数与全局变量同名 （2） 用于调用当前类中方法或者属性使用
super:只能用在子类中，表示父类对象；特殊情况：子类构造方法中调用父类构造方法时，必须写在第一行；

访问修饰符（笔试面试题）：
public：任何包下面的类都可以访问；
protected：相同包下可以访问，不同包中，子类可以访问（子类继承过来的）；
private：只有当前类可以访问到；
default（不写访问修饰符）：只有相同包下可以访问；
final：声明的类不可以被继承；

重写equals方法和toString（）方法（笔试题面试题）

抽象类：
   类是描述某些操作的，但是有时我们并不确定某个操作如何实现，但是这个方法依然需要存在，
   那么此时可以将类和方法声明为abstract；
  抽象类使用abstract声明class、 可以有非抽象方法，也可以没有抽象方法，
  抽象方法没有方法体，只是对方法的声明；
  抽象类不能被实例化，只能通过子类继承，重写所有抽象方法；
  抽象方法中属性可以不赋初始值；

接口：
 Interface 是一种特殊的抽象类；
 
 接口中的方法都是抽象方法，省略abstract关键词，方法默认都是
 声明的变量都是常量，必须赋初始值，省略final；
 接口不能被实例化；只能通过类来实现implements接口中所有抽象方法；
 一个实现类可以实现多个接口，此时必须重写所有接口中抽象方法；
 一个接口可以继承多个接口；
使用接口的好处：
 使用接口，可以降低程序之间的耦合度，即实现程序的高内聚低耦合；接口可以弥补java不能多继承的缺点；

接口和抽象类区别（笔试题面试题）？

常用类的使用：
 1、(笔试题)StringBuffer和StringBuilder
     String:不可变长度字符串；可以通过=号直接赋值
     StringBuffer:可变长度字符串，默认有16位缓冲区，通过append方法追加字符串，
     capacity方法可以获取真实长度；线程不安全；
     StringBuilder:线程安全；其他特点跟StringBuffer一样；
  注意：以后常用StringBuffer来拼动态的sql语句和动态字符串；

 2、Object是所有类的基类，注意以下内容：
     Object[] items={"a","b",1,23,'c'};
     String[] res=(String[]) items;//不能强转

 3、java.lang.Math类：
              System.out.println( Math.PI);//PI常量
  System.out.println(Math.abs(-123123.34));//绝对值
  System.out.println(Math.min(123.22,11));//两个数取最小min或者最大max值
  System.out.println( Math.ceil(123.01));//向上取double（进位）
  System.out.println(Math.floor(123.22));//向下取double （舍去）
  System.out.println(Math.round(123.551));//四舍五入取整
   获取随机数：
          Math.random();//0-1 之间小数，不包含0和1
 4、java.math.BigDecimal类：
     比double更精确；
     用于定义金额、比例、汇率等字段；金额、比例等加减乘除运算，不允许使用double，必须使用该字段；
      BigDecimal x=new BigDecimal("123.321421321321321321321313123213213");
      BigDecimal y=new BigDecimal("123.321421321321321321321313123213213");
     
   //x+y
   BigDecimal res1=x.add(y);
   //x-y
   BigDecimal res2= x.subtract(y);
  
   //x*y
   BigDecimal res3=x.multiply(y);
   //x/y
   BigDecimal res4=x.divide(new BigDecimal(2));
   System.out.println(res4);
   //向上取4位小数（进位）；
   BigDecimal res5=res4.setScale(4,BigDecimal.ROUND_UP);
   //四舍五入取3位小数
   BigDecimal res6=res4.setScale(3,BigDecimal.ROUND_HALF_UP);
   //向下舍去取4为小数（舍去）
   BigDecimal res7=res4.setScale(4,BigDecimal.ROUND_FLOOR);
    
 5、java.util.Date和java.sql.Date类：
    java.text.SimpleDateFormat类(日期格式化)：
   
   java.util.Date 常用语获取系统时间；
      常用方法：（1）new Date()
                (2)long  getTime() 返回1970年到现在为止指定日期的毫秒数
                (3) void setTime(long time);

   SimpleDateForMat日期格式化工具类：
               Date day=new Date();

    SimpleDateFormat text=new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
   //参数为设置格式化的格式
    String res=text.format(day);//format方法格式化日期
    System.out.println(res);
   
    //将指定格式的日期字符串，转为java.util.Date
    String day2="2014年12月01日 12时34分12秒";
    SimpleDateFormat text2=new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
   //此时这描述的是上面字符串的格式
    Date res2=text2.parse(day2);
    System.out.println(res2);
   
     //此时我们注意到：java.util.Date设置为指定日期时，很麻烦；
     //可以参考使用java.sql.Date
    java.sql.Date time=java.sql.Date.valueOf("2014-10-10");//格式固定的
     System.out.println(time);

 6、java.util.Random类（获取随机整数）：
     例如：
      Random ran=new Random();
      int j=ran.nextInt(32);//获取小于等于32大于等于0 之间的随机整数；
 7、java.util.Calendar类（日历类）：
    常用方法：getTime() /set(...)/get(...)/add(...) setTime(...)
 

异常：
  （笔试题）
  异常：程序在运行或者被编译过程中，产生的错误，程序人员可以预知的，通过修改程序可以避免、修复的，
       异常由JVM进行自动捕获；
  错误：系统级别的错误，例如：系统崩溃、内存溢出、JVM故障的；
       这些错误无法被程序人员预知避免，通过修改程序也无法弥补的；
 
 异常的种类（面试笔试题）：
   运行时异常：程序可以通过编译；不需要进行手动try catch或者throws 抛出异常；
   非运行时异常（编译时异常）：一旦出现异常，此时程序无法通过编译；必须通过try catch捕获，或者继续throws抛出；
   
 异常的捕获（面试笔试提）：
    异常的捕获：
      (1)通过JVM自动进行捕获处理；
      (2)通过程序人员手动try catch进行捕获；
      try{
       可能产生异常的程序
       }catch(异常类 e){
        如果捕获这种异常，此时catch是处理异常的部分
       }...finally{
           不论try是否产生异常，都执行的部分程序
       }

    （throws和throw区别-面试题）
    throws 将异常进行抛出,谁调用该方法谁处理;
       throws 方法声明时候使用；表示程序可能出现的异常，
       谁调用捕获处理；如果某个方法是最终调用的方法，此时该方法进行处理；
    throw：方法体中使用，表示抛出一个具体的异常；

 如何自定义异常？
  自定义异常：必须继承Throwable或者Exception； 调用父类构造方法，创建新的异常对象；

 说出你用过的异常类（5个）;
  分母为0、空指针、NumberFormatException（数字格式化异常）、ParseException、ArrayIndexOutOfBoundsException数组下标越界
  ClassNotFoundException、NoSuchMethodExceptio、

Throwable是所有异常类的基类；
    子类：Exception（除了RuntimeException中以外的都是非运行时异常）->RuntimeException(子类都是运行时异常);

 

Java中集合：
   集合：由java提供操作链表、哈希表等数据结构的相关类，由于处理多个对象的一个类或者接口；

Collection接口：是java中最基本的集合接口；
   常用子接口：
    List（接口）： 有序，可以重复
        常用实现类：
          ArrayList:数组实现的，add方法添加元素、get方法取元素。从集合中查询数据快，效率高，线程不安全；
          LinkedList:链表实现的， 往集合中添加、删除数据速度快，效率高，线程不安全；
          Vector:数组实现的，线程安全；效率低；
    Set（接口）：
无序的、不允许重复、只能存放一个null。通过equals方法判断hashCode值，进行区分重复；
      实现类：HashSet：无序，通过add方法存值；
       TreeSet：以树形结构存储数据，取数据时（默认升序）；
    
   
Map集合：注意不是Collection的子接口；key不允许重复；
      java.util.Map接口：以键值对进行存储数据；
       实现类：
           HashMap：键值对可以为空，线程不安全；
           HashTable:键值对不允许为空，线程安全；
遍历Map集合最快最效率的方法？（手写代码或者上级考试）
  Map<String,Object> map2=new HashMap<String,Object>();
   map2.put("abc1", "李四1");
   map2.put("abc2", "李四2");
   map2.put("abc3", "李四3");
   map2.put("abc4", "李四4");
   map2.put("abc5", "李四5");
   map2.put(null, null);
   Set<Entry<String, Object>> set2=map2.entrySet();//Entry是Map接口中的一个接口；
   Iterator<Entry<String, Object>> ite2=set2.iterator();
   while(ite2.hasNext()){
    Entry<String,Object> res=ite2.next();
    System.out.println("key:"+res.getKey()+"-value:"+res.getValue());
   }

集合相关笔试题面试题：
   如何实现对List集合重新排序，如何实现对set集合重新排序？
   List和set区别？ ArrayList和LinkedList、Vector区别？
   HashMap和Hashtable区别？

   实现方式：
    （1）对set排序，注意：使用set重新排序只能使用TreeSet实现；
        泛型中的类里面重写Comparator以及Comparable 里面的方法；
        可以直接在Comparable 接口里面的compareTo方法直接比较；
        或者重写Comparator中compare方法定义比较规则，然后再重写Comparable中compareTo方法按照上面的比较规则比较，然后
        排序；
    （2）list重新排序，必须通过Collections（操作集合接口的类）中的sort方法排序；
        需要定义排序规则
        第一种：定义排序规则工具类，重写Comparator中compare方法；
        Comparator.sort(list,排序规则的类)； 将排序规则传入该方法，即可；
        第二种：泛型中的类里面要重写Comparator中compare方法定义比较规则，然后再重写Comparable中compareTo方法按照上面的比较规则比较， 然后通过Comparator.sort(list集合）；然后实现排序；

  
内部类的种类（笔试面试题）（手机开发用的多）：
  （1）静态内部类 (2)非静态成员内部类 （3）局部内部类 （4） 匿名内部类

Java 的Io，即java中的输入输出流；
  程序中数据的传输都是以流（可以认为是现实中的管道），进行传输的；
 
 文件操作类：java.io.File 用于 文件扫描、获取文件（文件夹）名列表、文件的创建删除、文件夹路径的创建等；
 常用方法：delete() 删除文件、exists()判断文件件或者文件路径是否存在
   getName() 获取有效的文件夹名或者文件路径名或者文件名
          isFile() 判断指定的file对象，是否指向的是一个具体的文件；
          list()获取指定路径下所有文件夹名以及文件名集合列表
          listFiles() 获创建取指定路径下所有文件名集合列表；
   mkdir() 用于创建一层文件夹；
          mkdirs()用于创建多层文件夹路径
          createNewFile()创建一个新的文件；
          getParent() 获取上一层文件路径；

 java中流的分类：
  按照流向分：输入流和输出流；
  按照数据传输格式分：字节流和字符流；
 
他们都在java.io包下面：
    输入流：
        字节流（以字节为单位进行读取）：
        InputStream：
            FileInputStream
            BufferedInputStream 字节输入缓冲流
        字符流（以字符为单位进行读取）：
         Reader
           BufferedReader
           InputStreamReader->FileReader
              
    输出流：
        字节流（以字节为单位进行读取）：
        OutputStream
           FileOutputSream
      BufferedOutputStream 字节输出缓冲流
    
        字符流（以字符为单位进行读取）
        Writer
          BufferedWriter
          OutputStreamWriter->FileWriter
  

多线程：
   进程： 指一个可执行的应用程序；（从系统角度出发）
   线程： 指一个或者多个代码段的执行(从程序角度出发)； 多个线程共同完成一个任务或者多个不同任务；

什么是死锁：
    多个线程之间， 互相占据对方的临界资源不放，此时会产生死锁问题；
  
如何解决死锁问题：
    保证多个互相冲突的线程之间，在同一时间内，只有一个被执行，其他线程等待；
    直到这个线程被执行完毕后，将资源释放，其他线程抢占资源，谁抢到谁执行；
    使用synchronized（锁），声明方法，该方法所在线程就会有拥有锁（获取临界资源机会的令牌）的机会，
    保证了多个线程中被synchronized修饰的方法，同一时间内，只允许一个线程被执行；其他线程等待其释放锁；
    释放锁以后，表示该线程释放了临界资源；
    一般synchronized 都会与wait（） notify() notifyAll（）结合使用；
    典型的例子：生产者和消费者问题（大学计算机组成原理）;

     例如：　仓库（最多放１０商品）　　消费者消费商品　　　生产者生产商品
　　　　　　　假如：仓库默认现在５件商品　此时　消费者可消费，生产者可以生产
　　　　　　　　　　（１）　如果仓库满了（１０件商品）　此时生产者不生产、消费者继续消费（供大于消费）
 　　　　　　（２）　如果仓库＜１０　＞０个，此时生产者可生产、消费者可以消费(供需平衡)
                   （3）如果仓库0个商品，此时消费者停止消费，生产者生产（需求不满足供应）
  
    思路： 仓库Class、     消费Class 、       生产Class
           total 商品数量   消费方法buy       create生产方法
                            修改仓库数量即可   修改仓库数量即可
  
 
java中如何创建一个线程？
 Thread 线程的顶级父类，该类实现了Runnable接口；
 创建一个线程类，该类必须继承 Thread或者Runnable接口中run（）方法；

Thread.sleep(毫秒数) sleep方法表示休眠， 过了就休眠时间会自动唤醒该线程，该线程会继续往下执行；
Object中wait()表示等待，如果该线程不调用notify()或者notifyAll()方法此时，此时该线程会一直等待；
         注意：notify（） notifyAll（） wait()都是Object中的方法，
  必须使用在synchronized关键词修饰的方法中；

Socket 套接字：
     开发时一般用于只用在手机客户端，或者系统服务器与手机客户端；
     手机与远程服务器数据交互：（1）webService(2)Socket
笔试题面试题：了解网络编程吗？ TCP、UDP？
       TCP :传输控制协议,可靠的；面向链接的；
       UDP：用户数据报协议，面向非链接的；

XML解析：
   XML: 可拓展文本标记语言，用语数据 存储或者以后用于项目中相关配置；
     XML文件中标记可以自定义，没有缺省（默认的）标记；
XML解析方式：
  JDK自带的解析方式：
       （笔试题）  SAX:采用事件驱动，一边加载一边解析，不灵活；解析大文件效率高；
    DOM:采用树形结构方式解析xml文件，加载完文件后在解析，灵活；

  第三方提供的解析方式： JDOM：
          DOM4j：
 

 

XML解析练习题：
  使用XML文件作为数据源（即使用xml文件存储数据），DOM解析方式进行解析，实现
 对学生信息的新增、修改、删除、查询；

 com.bochy.dao; dao中主要放访问数据源操作的接口程序；
                DAO：数据访问对象；

 com.bochy.daoImpl；dao层的实现；
 
 com.bochy.test;用于测试程序卸载该package中；
 com.bochy.control;表示控制层程序，主要实现业务逻辑；
 

 功能逻辑：
    （1）请选择业务类型：
           【A】注册【B】登录
    （2）如果选择【A】
         注册：
         请输入姓名：
           张三
         请输入年龄：
           23
         请输入用户名：
          abcd
         请输入密码：
           123
         是否确定注册：【Y】确定【B】否
         如果选择Y此时如果成功注册此时，给于提示注册成功！
    
         【Y】如果成功，此时提示信息：您已经注册成功！过3秒钟后，返回（1）；

     （3）如果选择登录【B】；
         请输入用户名：
           abcd
         请输入密码：
           123
         如果登陆成功， 此时出现如下选项：
         【1】查询个人信息【2】查询所有人员信息【3】（不允许删除自己）删除指定人员信息【4】修改指定人员信息
         【5】修改个人信息
         
         【2】【3】【4】操作必须是管理员才可以操作，否则给于提示；
        

 

 

 

练习：这周五结束；

mysql+js