java学习笔记记录

1.Java实现可移植性靠的是JVM，JVM就是一台虚拟的计算机，只要在不同的操作系统上植入不同版本的JVM，那么Java程序就可以在各个平台上移植，做到“一次编写，处处运行”；
2.Java中程序的执行步骤为：
使用javac命令将一个.java文件编译成.class文件；
使用java命令可以执行一个.class文件；
3.每次使用Java命令执行一个class时，都会启动JVM，JVM通过CLASSPATH给出的路径加载所需要的类文件，可以通过SET CLASSPATH设置类的加载路径；
PATH：是操作系统的环境属性，指的是可以执行命令的程序路径；
CLASSPATH：是所有*.class文件的执行路径，java命令执行时将利用次路径加载所需要的*.class文件；
4.Java程序主要分为两种：java application和java applet，Java applet主要是在网页中嵌入的Java程序，基本上已经不再使用了，而application是指有main方法的程序；
5.&和&&以及|和||的区别：&表示普通与，所有的判断条件都要依次执行；&&表示短路与，如果前面的条件返回了false，则后面的不再判断直接返回false；
|表示普通或，所有的判断条件都要依次执行；||表示短路或；
6.Switch(expression)中，expression是一个整数表达式，因此传递给switch和case语句的参数应该是int、short、char或byte，而对于long却不可以使用；在jdk1.7之前，String都不能作用与switch，jdk1.7以后switch支持了String判断；
7.方法重载时只看方法名称、参数类型及个数，而无须关注方法的返回值类型；
8.Java的数据类型可分为两种：基本数据类型和引用数据类型；
9.UNICODE为每个字符制定了一个唯一的数值，在任何语言、平台、程序都可以安心地使用；
10.数据类型的转换可分为下列两种：自动类型转换和强制类型转换；
11.Break强制终止当前循环；continue强制跳到循环的起始处；
12.封装性：一是指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单位中；另一层含义是指“信息隐蔽”，把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知晓，或只允许使用对象的功能，而尽可能隐蔽对象的功能实现细节；
13.继承性：首先拥有反映事物一般特性的类，然后在其基础上派生出反映特殊事物的类；
14.多态：是允许程序中出现重名现象，Java语言中含有方法重载与对象多态两种形式的多态；
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同；
对象多态：子类对象可以与父类对象进行相互的转换，而且根据其使用的子类的不同完成的功能也不同；
15.类是对象的模板，而对象是类的实例；
16.在主类中定义，并且由主方法直接调用的方法必须加上static；
17.堆内存：保存对象的真正数据，都是每一个对象的属性内容；
栈内存：保存的是一块堆内存的空间地址；
如果要开辟堆内存空间，只能依靠关键字new来进行开辟，即只要看见了关键字new，不管何种情况下，都表示要开辟新的堆内存空间；
一块堆内存空间可以同时被多个栈内存所共同指向，则每一个栈内存都可以修改同一块堆内存空间的属性值；
18.空指针异常只会在引用数据类型上产生，并且只要是进行项目的开发，都有可能会出现此类异常，而此类异常的唯一解决方法就是查找引用数据类型，并观察其是否被正确实例化；
19.构造方法的名称和类名称保持一致；构造方法不允许由返回值类型声明；由于对象实例化操作一定需要构造方法的存在，所以如果在类值中没有明确定义构造方法的话，则会自动生成一个无参、无返回值的构造方法供用户使用；如果一个类中已经明确定义了一个构造方法的话，则无实际意义的构造方法将不会自动生成，也就是说，一个类值中至少存在一个构造方法；
在一个类中对构造方法重载时，所有的重载方法按照参数的个数由多到少或者由少到多排列，都是规范的；
在每个类中的定义顺序：首先定义属性，之后定义构造方法，最后定义普通方法；
类种定义属性的默认值，只有在构造(不是构造方法，构造方法实际上严格来讲是属于整个对象构造过程的最后一步；对象的构造需要为其分配空间，之后为其设置默认值，最后留给构造方法进行其他操作)执行完毕后才可以真正赋值；
20.如果现在一定要强调所调用的方法是本类中所定义的方法，可以在方法前增加一个this；
21.匿名对象(例如：new Person.tell())：开辟了堆内存空间的实例化对象，并且只能使用一次，使用一次之后就将被GC回收；
22.简单Java类：一个类之中，只包含基本的属性，setter()、getter()方法；
简单Java类的开发原则：类名称必须可以明确地表示出一类的定义，如Person;
类种的所有属性必须使用private进行封装；类中的所有属性都必须定义相应的getter()、setter()方法；类中可以提供构造方法，为属性初始化，但是不管提供了多少个构造当发，一定要保留一个无参构造；类中不允许直接使用System.out.println()署出，所有的内容要返回给被调用处输出；
23.数组属于引用型数据；
24.使用“==”判断的是两个对象是否相等，属于数值判断，判断的是两个对象的内存地址数值，并没有判断内容；如果要判断字符串中的内容是否相等，则使用equals()进行；
25.在String类进行设计时采用了一种称为共享设计模式的概念，在每一个运行的JVM底层存在一个字符串的对象池，如果用户采用了直接赋值的方式，会将字符串的内容放入到池中，以供其他继续使用直接赋值方式的String对象使用，如果新声明的字符串内容不在池中，则会开辟一个新的，继续放到池中，以供下次使用；
使用构造方法开辟的字符串对象实际上会开辟两块空间，其中有一块空间将成为垃圾；另外，使用构造方法实例化的String类对象内容不会保存在字符串对象池值中，即不能够进行共享数据操作；
手工入池的方法：public String intern()；new String(“aaa”).intern(); intern()方法表示将开辟的字符串对象保存在对象池中；
26.String类的方法：
public char charAt(int index)：取得指定索引位置上的字符；
public char[] toCharArray()：将字符串转换为字符数组；
public byte getBytes()：将字符串变为字节数组；
public byte[] getBytes(String charsetName) 字符串转码操作；
public boolean equals(String anObject)：区分大小写的相等判断；
public boolean equalsIgnoreCase(String anotherString)：不区分大小写，比较是否相等；
public int compareTo(String anotherString)：比较两个字符串的大小；
public boolean contains(String s)：查找指定的子字符串是否存在；
public int indexOf(String str)：从头查找指定字符串的位置，找不到返回-1；
public int indexOf(String str,int fromIndex)：由指定位置向后查找字符串的位置，找不到返回-1；
public int lastIndexOf(String str)：  由后向前查找字符串的位置，找不到返回-1；
public int lastIndexOf(String str,int fromIndex)：从指定位置由后向前找；
public boolean startsWith(String prefix)：判断是否以指定的字符串开头；
public boolean startsWith(String prefix,int toffset)：从指定位置判断是否以指定字符串开头；
public boolean endsWith(String suffix)：判断是否以指定的字符串结尾；
public String replaceAll(String regex,String replacement)：全部替换；
public String replaceFirst(String regex,String replacement)：替换首个；
public String substring(int beginIndex)：从指定位置截取到结尾；
public String substring(int beginIndex,int endIndex)：截取指定范围的内容；
public String[] split(String regex)：按照指定的字符串全拆分；
public String[] split(String regex,int limit)：拆分为指定的长度；
在进行拆分的时候也会出现一些字符是无法拆分的，此时就需要使用\\(表示一个\)进行转义；
public boolean isEmpty()：判断是否为空字符串；
public int length()：取得字符串长度；
public String trim()：去掉左右空格；
public String toLowerCase()：将全部字符串转小写；
public String toUpperCase()：将全部字符串转大写；
public String intern()：入池；
public String concat(String str)：字符串连接；
27.数组没有length这个方法，有length属性；String有length()方法；
28.this关键字：表示本类属性、表示本类方法和当前对象；
建议：只要是调用类中属性的情况，都要使用“this.属性”的方式进行表示；
所有的构造方法是在对象实例化时被默认调用的，而且是在调用普通方法之前调用，所以使用“this()”调用构造方法的操作一定要放在构造方法的首行；如果一个类中存在了多个构造方法，并且这些构造方法都使用了this()互相调用，那么至少保留一个构造方法没有调用其他构造方法，以作为程序的出口；
29.String类本身属于一个特殊的操作类，而且这个类最大的特点是内容不可改变；基本数据类型本身不牵扯到内存关系，而且传递时也只是数值传递，不是内存传递；
30.对象比较：本类接收自己的引用，而后与本类当前对象(this)进行比较；为了避免NullPointerException的产生，首先应该增加一个null的判断；为了防止浪费性能的情况出现，可以增加地址数值的判断，因为相同的对象地址相同；之后进行属性的依次比较，如果属性全部相同，则返回true，否则返回false;
31.Java中主要存在四块内存空间：栈内存空间(保存所有的对象名称，更准确地说是保存了引用地堆内存空间地地址)、堆内存空间(保存每个对象的具体属性内容)、全局数据区(保存static类型的属性)、全局代码区(保存所有的方法定义)；
32.static定义的属性表示是公共属性，那么如果现在由某一个对象修改是不合适的，应该由类来进行操作，即“类名称.static属性”；static属性虽然定义在了类中，但是其可以在没有实例化对象时进行调用；
33.static方法和非static方法：static定义的方法不能调用非static的方法或属性；非static定义的方法可以调用static的属性或方法；使用static定义的属性和方法，可以在没有实例化对象的时候使用；非static定义的属性和方法，必须实例化对象之后才可以进行调用；
34.如果一个方法在主类中定义，并且由主类方法直接调用时，其前面必须有public static；
35.实际工作中，使用static关键字定义属性或方法的原因：希望在没有实例化对象时可以轻松地执行类的某些操作；现在希望表现出数据共享的概念；
36.普通代码块是定义在方法中的代码块；
构造块是定义在类中的代码块；构造块优先于构造方法执行，而且每当有一个新的实例化对象产生时，就会重复执行构造块的程序；
静态块定义在类中；静态块优先于构造块执行，而且不管有多少个实例化对象产生，静态块只会执行一次，它的主要作用是为类中的static属性初始化；
37.内部类：可以方便地访问外部类的私有操作，或者是由外部类方便地访问内部类地私有操作；
在内部类使用this表示地只是内部类的当前对象，如果想要表示出外部类的当前对象，使用“外部类.this”来表示；
Static nested class是被声明为静态的内部类，它可以不依赖于外部类实例被实例化，通常的内部类需要在外部类实例化后才能实例化；
在普通方法里面定义内部类的情况是最多的，此时如果定义的内部类要访问方法的参数或者是方法中定义的变量时，这些参数或变量一定要增加一个final关键字，否则无法调用；
38.继承：一个子类只能够继承一个父类，存在单继承局限；在一个子类继承时，实际上会继承父类中的所有操作(属性、方法)，但是需要注意的是，对于所有的非私有操作属于显示继承，而所有的私有操作属于隐式继承；私有属性也被继承下来，但却无法直接使用；在继承关系中，如果要实例化子类对象，会默认先调用父类构造，为父类中的属性初始化，之后再调用子类构造，为子类中的属性初始化，即默认情况下，子类会找到父类中的无参构造方法，对于子类的构造而言，就相当于隐含了一个super()的形式，如果此时父类没有无参构造，那么子类就必须通过super()调用指定参数的构造方法；
Super调用父类构造时一定要放在构造方法的首行上，this和super调用构造方法时不能同时出现；
39.覆写：子类定义了和父类在方法名称、返回值类型、参数类型及个数完全相同的方法时，成为方法的覆写；
40.this.方法()：先从本类查找是都存在指定的方法，如果没有找到，则调用父类操作；
super.方法()：直接由子类调用父类之中的指定方法，不再找子类；
如果父类的方法名称为private的，则子类无法覆写；
41.使用final定义的类不能有子类，即无法被其他类所继承；
使用final定义的方法不能被子类所覆写；
使用final定义的变量，就表示常量，常量在定义时必须设置默认值，并且无法修改；
单例模式：构造方法被私有化，只能够通过getInstance()方法取得Singleton类的实例化对象，这样不管外部如何操作，最终也只有一个实例化对象，在单例设计模式中一定会存在一个static方法，用于取得本类的实例化对象；
42.多态：
方法的多态性：重载和覆写；
对象的多态性：父子类对象的转换，向上转型和向下转型；
43.抽象类的最大特点是包含了抽象方法，抽象方法是只声明而未实现的方法，抽象方法定义时要使用abstract关键字完成，并且抽象方法一定要在抽象类中，抽象类要使用abstract声明；
抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
子类(如果不是抽象类)必须覆写抽象类中的全部抽象方法；
抽象类对下那个可以使用对象的向上转型方式，通过子类来进行实例化操作；
44.接口：interface；
每一个接口必须定义子类，子类使用implements关键字实现接口；
接口的子类(如果不是抽象类)必须覆写接口中所定义的全部抽象方法；
利用接口的子类，采用对象的向上转型方式，进行接口对象的实例化操作；
45.工厂设计模式：
interface Fruit{
  public void eat();
}
class Apple implements Fruit{
  public void eat(){
    System.out.println(“吃苹果”);
}
} 
class Orange implements Fruit{
  public void eat(){
  System.out.println(“吃橘子”);
}
}
class Factory{
  public static Fruit getInstance(String className){
  if(“apple”.equals(className)){
  return new Apple();
}
If(“orange”.equals(className)){
  return new Orange();
}
return null;
}
} 
public class TestDemo{
  public static void main(String[] args){
Fruit f = Factory.getInstance(“apple”);
f.eat();
}
}
46.代理设计模式：代理设计就是指一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理；
interface Network{
  public void browse();
} 
class Real implements Network{
  public void browse(){
  System.out.println(“上网浏览信息”);
}
}
class Proxy implements Network{
  private Network network;
  public Proxy(Network network){
  this.network = network;
}
public void check(){
  System.out.println(“检查用户是否合法”);
} 
public void browse(){
  this.check();
  this.network.browse();
} 
} 
public class TestDemo{
  public static void main(String[] args){
  Network net = null;
  net = new Proxy(new Real());
  net.browse();
}
}
47.抽象类和接口的区别：
抽象类：abstract class；由常量、变量、抽象方法、普通方法、构造方法组成；可以使用各种权限；一个抽象类可以实现多个接口；子类使用extends继承抽象类；模板设计模式；一个子类只能够继承一个抽象类；
接口：interface；由全局变量、抽象方法组成；只能是public权限；接口不能够继承抽象类，却可以继承多接口；子类使用implements实现接口；工厂设计模式、代理设计模式；一个子类可以实现多个接口；
抽象类和接口的对象都是利用对象多态性的向上转型，进行接口或抽象类的实例化操作；
48.Object类是所有类的父类；Object类可以接收所有类的对象；对于任意的一个简单Java类而言，理论上应该覆写Object类中的3个方法：
取得对象信息：public String toStirng()；
对象比较：public boolean equals(Object obj)；
取得哈希码：public int hashCode()；
49.包装类：包装类也使用了对象池的概念；对于包装类，由于出现了自动装箱和自动拆箱这一概念，它也就是和String类一样，存在了两类实例化类对象的操作：一种是直接赋值，另一种是通过构造方法赋值，而通过直接赋值方式实例化的包装类对象可以自动入池；
50.面向对象的三大特征：封装、继承、多态；
类与对象的关系：类是对象的模板，对象是类的实例，类只能通过对象才可以使用；
类的组成：属性和方法；
如果一个对象没有被实例化而直接使用，则使用时会出现空指向异常；
类属于引用数据类型，进行引用传递时，传递的是堆内存的使用权；
类的封装性：通过private关键字进行修饰，被封装的属性不能被外部直接调用，而只能通过setter或getter方法完成，只要是属性，则必须全部封装；
构造方法可以为类中的属性初始化，它与类名称相同，无返回值类型声明；如果在类种没有明确地定义出构造方法，则会自动生成一个无参的构造方法，在一个类中的构造方法可以重载，但是每个类都至少有一个构造方法；
String类在Java中较为特殊，它可以使用直接赋值的方式，也可以通过构造方法进行实例化，前者只产生一个实例化对象，而且此实例化对象可重用；后者将产生两个实例化对象，其中一个是垃圾空间；在String中，比较内容使用equals()方法，==比较的只是两个字符串的地址值；字符串的内容一旦声明则不可改变；
在Java中使用this关键字表示当前的对象，通过this.属性调用本类中的属性，通过this.方法()调用本类中的其他方法，还通过this()形式调用本类中的构造方法，但是调用时要求放在构造方法的首行；
使用static声明的属性和方法可以由类名称直接调用，static属性是所有对象共享的，所有对象都可以对其进行操作；
如果需要限制类对象的产生，则可以将构造方法私有化；
对象数组的使用要分为两个部分：第一步是声明数组，第二步是为数组开辟空间，开辟空间后数组中的每个元素的内容都是null；
内部类是在一个类的内部定义另外的一个类，使用内部类可以方便地访问外部类地私有操作，在方法中声明地内部类要想访问方法的参数，则参数前必须加上final关键字；
继承可以扩充已有类的功能，通过extends关键字实现，可将父类的成员继承到子类；
Java在执行子类的构造方法前会先调用父类中的无参构造方法，其目的是为了对继承自父类的成员做初始化的操作；
父类有多个构造方法时，如果要调用特定的构造方法，则可以在子类的构造方法中通过super()这个关键字来完成；
This()是在同一类内调用其他的构造方法，而super()则是从子类的构造方法调用其父类的构造方法；
使用this调用属性或方法时会先从本类中查找，如果本类中没有查找到，再从父类中查找，而使用super的话会直接从父类中查找需要的属性或方法；
This()与super()的相似之处：当构造方法有重载时，两者均会根据所给予的参数的类型与个数正确地执行相对应的构造方法，两者均必须编写在构造方法内的第一行；
通过instanceof关键字，可以判断对象属于哪个类；
51.所有的异常类型最高的继承类是Throwable，Throwable下有两个子类：Error(指的是JVM错误，这个时候的程序并没有执行，无法处理)、Exception(指的是程序中出现的错误信息，可以进行异常处理)；
52.Java的异常处理流程：
如果程序中产生了异常，那么会自动地由JVM根据异常的类型实例化一个指定异常类的对象；
如果程序中没有任何的异常处理操作，则这个异常类的实例化对象将JVM进行处理，而JVM的默认处理方式就是进行异常信息的输出，而后中段程序执行；
如果程序中存在了异常处理，会由try语句捕获产生的异常类对象；
与try之后的每一个catch进行匹配，如果匹配成功，则使用指定的catch进行处理，如果没有匹配成功，则向后面的catch继续匹配，如果没有任何的catch匹配成功，将交给JVM执行默认处理；
不管是否有异常都会执行finally程序，如果此时没有异常，执行完finally会继续执行程序中的其他代码，如果此时有异常没能够处理，那么也会执行finally，但是执行完finally后，将默认交给JVM进行异常的信息输出，并且程序中断；
53.在Java中，所有捕获范围小的异常，必须放在捕获范围大的异常前，否则程序在编译时就会出现错误提示；
54.throws关键字主要是在方法定义上使用的，表示此方法中不进行异常的处理，而交给被调用处处理；
在调用throws声明方法时，一定要使用异常处理操作进行异常的处理，这属于强制性处理；
55.throw：用户手工抛出异常类的实例化对象；
throws：用于方法的声明上，表示此方法不处理异常，而将异常交给程序被调用处处理；
56.标准格式：try…catch、finally、throws、throw一起使用；
57.在try语句中有一个return语句，那么紧跟在这个try后的finally语句的代码一定会执行，并且是在return前执行；
58.RuntimeException和Exception：
Exception：表示程序运行过程中可能出现的非正常状态；
RuntimeException：表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误；
Java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常；即Exception定义了必须处理的异常，而RuntimException定义的异常可以选择性地进行处理；
RuntimeException是Exception的子类；
常见的RuntimeException有NumberFormatException、ClassCastException、NullPointerException、ArithmeticException和ArrayIndexOutOfBoundsException；
59.断言指的是程序执行到某行后，其结果一定是预期的结果；
Assertion在软件开发中是一种常用的调试方式，很多开发语言都支持这种机制，在实际使用中，assertion就是在程序中的一条语句，它对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，系统将给出警告或退出；一般来说，assertion用于保证程序最进本、关键的正确性；assertion检查通常在开发和测试时开启，为了提高性能，在项目发布后，assertion检查通常是关闭的；
60.一个包中的类要想被其他包中的类使用，那么这个类一定要定义为public class，而不能使用class声明，因为class声明的类只能够在同一个包中使用；
public class文件名称和类名称保持一致，在一个*.java文件中只能存在一个public class定义，如果一个类想要被外部的包访问则必须定义为public；
class文件名称可以和类名称不一致，在一个*.java中可以同时存在多个class定义，并且编译完成后会形成多个*.class文件；
61.属性声明以private为主；方法声明以public为主；
62.固定的命名规范：类名称的每一个单词的开头首字母大写；变量名称的第一个单词的首字母小写且之后每个单词的首字母大写；方法名称的第一个单词的首字母小写且之后每个单词的首字母大写；常量名称的每个字母大写；包名称的所有字母小写；
63.通配符?表示任意类型；
设置泛型的上限：? Extends 类；比如? extends Number，表示只能是Number或者Number的子类Integer等； 
设置泛型的下线：? super 类；比如? super String，表示只能是String或者是String的父类；
64.枚举enum是JDK1.5之后定义的新关键字，主要是用于定义枚举类型，在java中，每一个使用enum定义的枚举类型实际上都表示一个类默认继承了Enum类；
如果在枚举类中定义了有参构造方法，则声明每一个枚举对象时都必须明确地调用此构造方法，否则将出现编译错误；
65.可变参数：在传递参数时就可以不用受到参数的个数限制，全部的参数将以数组的形式保存下来；
泛型可以使程序的操作更加安全，避免发生类转换异常；
在程序中使用类时如果没有指定泛型，则泛型将被擦除，使用Object接收参数；
66.进程是程序的一次动态执行过程，它经历了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程；进程和线程一样，都是实现并发的一个基本单位；线程是比进程更小的执行单位，线程是在进程的基础上进行的进一步划分；所谓的多线程是指一个进程在执行过程中可以产生多个线程，这些线程可以同时存在、同时运行，一个进程可能包含了多个同时执行的线程；
所有的线程一定要依附于进程才能够存在，进程一旦小时线程也一定会消失；
67.java.lang.Thread是一个负责线程操作的类，任何的类只需要继承Thread类就可以成为一个线程的主类，既然是主类就必须有它的使用方法，而线程启动的主方法是需要覆写Thread类中的run()实现的；
要想启动线程必须依靠Thread类的start()方法执行，线程启动后会默认调用run()方法；
多线程的实现一定需要操作系统支持；
Java中可以实现Runnable接口来实现多线程；
68.多线程两种实现方式以及区别：
多线程的两种实现方式，都需要一个线程的主类，而这个类可以实现Runnable接口或继承Thread类，不管使用何种方式都必须在子类中覆写run()方法，此方法为线程的主方法；
Thread类是Runnable接口的子类，使用Runnable接口可以避免单继承据先，以更加方便地实现数据共享的概念；
Runnable接口：
class MyThread implements Runnable{
  @Override
  public void run(){}
}
MyThread mt = new MyThread();
new Thread(mt).start();
Thread类：
class MyThread extends Thread{
  @Override
  public void run(){}
}
MyThread mt = new MyThread();
mt.start();
69.任何线程一般具有5种状态：
创建状态：在程序中用构造方法创建了一个线程对象后，新的线程对象便处于新建状态，此时，它已经有了相应的内存空间和其他资源，但还处于不可运行状态；
就绪状态：新建线程对象后，调用该线程的start()方法就可以启动线程；当线程启动后，即进入就绪状态；此时，线程将进入线程队列排队，等待CPU服务，这表明它已经具备了运行条件；
运行条件：当就绪状态的线程被调用并获得处理器资源时，线程就进入了运行状态；此时，自动调用该线程对象的run()方法；
堵塞状态：一个正在运行的线程在某些特殊情况下，如被人为挂起或需要执行耗时的输入输出操作时，将让出CPU并暂时中止自己的执行，进入堵塞状态；在可执行状态下，如果调用sleep()、suspend()、wait()等方法，线程都将进入堵塞状态；堵塞时，线程不能进入排队队列，只有当引起堵塞的原因被消除后，线程才可以转入就绪状态；
终止状态：线程调用stop()方法或run()方法执行结束后，线程即处于终止状态；处于终止状态的线程不具有继续运行的能力；
70.每一个JVM运行就是进程：当用户使用Java命令执行一个类时就表示启动了一个JVM进程，而主方法只是这个进程上的一个线程而已；当一个类执行完毕后，此进程会自动消失；每一个JVM进程都至少启动两个线程：main和gc；
71.同步就是指多个操作在同一个时间段内只能有一个线程进行，其他线程要等待此线程完成后才可以继续执行；
同步代码块：使用synchronized关键字定义的代码块就称为同步代码块，在进行同步的操作时必须设置一个要同步的对象，而这个对象应该理解为当前对象this；
Synchronized(同步对象){需要同步的代码块}
同步方法；
72.同步和异步区别：如果一块数据要在多个线程间进行共享，例如正在写的数据，以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取；当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程；很多情况下采用异步途径往往更有效率；
73.abstract关键字和static、native、synchronized等关键字种的任意一个都不能组合同时用来声明方法；
74.死锁：就是指两个线程都在等待彼此先完成，造成了程序的停滞状态；
多个线程访问同一资源时一定要考虑到同步问题，过多的同步会带来死锁；
75.sleep()和wait()的区别：sleep()是Thread类定义的static方法，表示线程休眠，将执行机会给其他线程，但是监控状态依然保持，到时候会自动恢复；
wait()是Object类定义的方法，表示线程等待，一直到执行了notify()或notifyAll()后才结束等待；
76.在多线程的开发中可以通过设置标志位的方式停止一个线程的运行；
77.StringBuffer类主要用于频繁修改字符串的操作，但是在任何开发中，面对字符串的操作，大部分情况下都先考虑String，只有小部分操作才考虑StringBuffer；
String的内容不可改变，而StringBuffer的内容可以改变；
78.一个类不能继承String类，String类使用final定义；
79.在每一个JVM进程中，都会存在一个运行时的操作类对象，而对象所属的类型就是Runtime类；Runtime类的构造方法被私有化了，是单例设计模式；
public long maxMemory() 取得最大可用内存量；
public long totalMemory() 取得总共可用内存量；
public long freeMemory() 取得空闲内存量；
public static Runtime getRuntime() 取得Runtime类的实例化对象；
public void gc() 运行垃圾收集器，释放垃圾空间；
GC：垃圾收集器，可以释放掉垃圾空间所占用的内存，在Java中GC有两种操作方式，一种是由JVM不定期的执行GC操作，另外一种是由用户自己手动调用Runtime类的gc()方法进行垃圾空间的释放；
80.System类，这个操作类提供一些系统的支持操作；
public static void arraycopy(…) 数组拷贝操作；
public static long currentTimeMillis() 取得当前的日期时间；
81.如果希望在一个对象收尾时执行一些收尾工作，则对象所在的类可以实现一个finalize()方法，此方法由Object类定义：protected void finalize() throws Throwable
抛出Throwable是为了在出现异常或者错误时都不会导致程序中断；在进行对象回收前，有可能代码会产生异常，或者由于JVM的一些问题产生错误，但是不管出现任何的异常或者是错误，都不会导致程序中断执行，这样写只是为了强调finalize()方法的完善性；
82.final、finally、finalize的区别：final表示终结器，用于定义不能被继承的父类，不能被覆写的方法、常量；finally是异常处理的出口；finalize()是Object类定义的一个方法，用于执行对象回收前的收尾操作；
83.日期格式化操作类：java.text.SimpleDateFormat；
public SimpleDateFormat(String pattern) 传入日期时间标记(yyyy,MM,dd,HH,mm,ss,SSS)实例化对象；
public final String format(Date date) 将日期格式化为字符串数据；
public Date parse(String source) throws ParseException 将字符串格式化为日期数据；
84.大整数操作类：java.math.BigInteger；大小数操作类：java.math.BigDecimal；
85.在使用Arrays类的equals()方法进行数组比较时，两个数组的顺序要保持一致；
普通的对象数组是不能够进行比较的，如果要比较需要比较器的支持；
86.常用比较器Comparable：不管在何种情况下，只要牵扯到对象数组排序的操作，永远都要使用比较器Comparable；
87.Comparable比较器和Comparator比较器的区别：
java.lang.Comparable是在一个类定义时默认实现好的接口，里面只有一个comparaTo()方法；
java.util.Comparator是需要单独定义一个比较的规则类，里面有两个方法：compare()和equals()；
88.常用正则匹配符号：
字符：a表示匹配字母a；\\表示匹配转义字符”\”；\t匹配转义字符”\t”； \n表示匹配转义字符”\n”；
一组字符：[abc]表示可能是字母a或b或c；[^abc]表示不是字母a、b、c中的任意一个；[a-zA-Z]表示全部字母中的任意一个；[0-9]表示全部数字的任意一个；
边界匹配：^表示一组正则的开始；$表示一组正则的结束；
简写表达式：.表示任意的一位字符；\d表示任意的一位数字，等价于[0-9]；\D表示任意的一位非数字；\w表示任意的一位字母、数字、_，等价于[a-zA-Z0-9_]；\W表示任意的一位非字母、数字、_；\s表示任意的一位空格；\S表示任意的一位非空格；
数量表示：?表示此正则出现0次或1次；*表示此正则出现0次、1次或多次；+表示次正则出现1次或多次；{n}表示此正则出现n次；{n,}表示此正则出现n次以上；{n,m}表示此正则出现n-m次；
逻辑表示：AB表示表达式A后面紧跟着B；A|B表示A或者B；()表示将多个子表达式合成一个表示，作为一组出现；
89.String类对正则的支持：
public boolean matches(String regex) 与指定正则匹配；
public String replaceAll(String regex,String replacement) 替换满足正则的全部内容；
public String replaceFirst(String regex,String replacement) 替换满足指定正则的首个内容；
public String[] split(String regex) 按照指定正则全拆分；
public String[] split(String regex,int limit) 按照指定正则拆分为指定个数；
90.反射机制：Class是所有反射操作的源头；获得这个Class类的实例化对象，Java中定义了3中方式；通过Object类的getClass()方法取得；通过“类.class”取得；使用Class类内部定义的一个static方法(public static Class<?> forName(String className))；
可以通过反射实例化对象：public T newInstance()
91.在一个字符串内容需要频繁修改时，使用StringBuffer可以提升操作性能，因为StringBuffer的内容是可以改变的，而String的内容是不可以改变的；
StringBuffer类中提供了大量的字符串操作方法；
Runtime表示运行时在一个JVM中只存在一个Runtime，所以如果要想取得Runtime类的对象，直接使用Runtime类中提供的静态方法getRuntime()即可；
System类是系统类，可以取得系统的相关信息；使用System.gc()方法可以强制性地进行垃圾的收集操作，调用此方法实际上就是调用了Runtime类中的gc()方法；
使用Date类可以方便地取得时间，但取得的时间格式不符合地域的风格，所以可以使用SimpleDateFormat类进行日期的格式化操作；
处理大数字可以使用BigInteger和BigDecimal，当需要精确小数点操作位数时则需要使用BigDecimal类；
通过Random类可以取得指定范围的随机数字；
如果一个类的对象要想被克隆，则此对象所在的类必须实现Cloneable接口；
要想对一组对象进行排序，则必须使用比较器，比较器接口Comparable中定义了一个comparaTo()的比较方法，用来设置比较规则；
可以通过Class类中的newInstance()方法进行对象的实例化操作，但是要求类中必须存在无参构造方法，如果类中没有无参构造，则必须使用Constructor类完成对象的实例化操作；
92.在整个java.io包中，File类是唯一一个与文件本身操作有关的类；所谓的文件本身指的是文件的创建、删除、重命名、取得文件大小和修改日期；
public File(String pathname) 给定一个要操作文件的完整路径；
public File(String parent,String child) 给定要操作文件的父路径和子文件名称；
public boolean createNewFile() throws IOException 创建文件；
public boolean delete() 删除文件；
public boolean exists() 判断给定路径是否存在；
public static final String separator File类提供的常量分隔符；
public File getParentFile() 找到一个指定路径的父路径；
public boolean mkdirs() 创建指定目录；
public String getName() 取得文件名称；
public boolean isDirectory() 判断给定的路径是否是文件夹；
public boolean isFile() 判断给定的路径是否是文件；
public boolean isHidden() 判断是否隐藏；
public long lastModified() 文件的最后一次修改日期；
public long length() 取得文件的大小，以字节为单位返回；
public boolean renameTo(File dest) 为文件重命名；
public File[] listFiles() 将目录中所有文件以File对象数组的方式返回；
93.字节操作流(OutputStream、InputStream)和字符操作流(Writer、Reader)；不管是字节流还是字符流的操作，本身都表示资源操作，而执行所有的资源操作都会按照如下几个步骤进行：
如果要操作的是文件，那么首先要通过File类对象找到一个要操作的文件路径(路径有可能存在有可能不存在，不存在则要创建路径)；
通过字节流或字符流的子类为字节流或字符流的对象实例化；
执行读/写操作；
最后一定要关闭操作的资源，不管以后如何操作，资源永远要关闭；
94.字节输出流：java.io.OutputStream
public abstract void write(int b) 输出单个字节数据；
public void write(byte[] b) 输出一组字节数据；
public void write(byte[] b,int off,int len) 输出部分字节数据；
FileOutputStream:
public FileOutputStream(File file) 实例化FileOutputStream 主要用于新建数据；
public FileOutputStream(File file,boolean append) 实例化FileOutputStream 主要用于追加数据； 
95.字节输入流：InputStream;
public abstract int read() 读取单个字节数据，每次执行都会读取一个数据源的指定数据，如果现在发现已经读取到了结尾，则返回-1；
public int read(byte[] b) 读取多个字节数据，如果现在要读取的数据小于byte的数据，这个时候read()方法的返回值int返回的是数据个数，如果现在开辟的字节数组小于读取的长度，且数据已经读完了，则这个时候的int返回的是-1；
public int read(byte[] b,int off,int len) 读取指定多个字节数据；
public FileInputStream(File file) 实例化输入流；
96.字符输出流：Writer；最方便之处在于可以直接输出字符串数据；
public abstract void close() 关闭输出流；
public void write(String str) 将字符串输出；
public void write(char[] cbuf) 将字符数组输出；
public abstract void flush() 强制性清空数据；
97.字符输入流：Reader；
public abstract void close() 关闭输出流；
public int read() 读取单个字符；
public int read(char[] cbuf) 将内容读到字符数组中，返回读入的长度；
98.字节流和字符流的区别：
字节流在进行I/O操作时，直接针对的时操作的数据终端(如文件),，而字符流操作时不是直接针对于中断，而是针对于缓冲区的操作，而后由缓冲区操作终端；这属于间接操作，按照这样的方式，如果在使用字节流时不关闭最后的输出流操作，也可以将所有的内容进行输出，而字符输出流时如果不关闭，则意味着缓冲区中的内容不会被输出，当时，这个时候可以由用户自己去调用flush()方法进行强制性的手工清空；
主要区别：字节流没有使用到缓冲区，而字符流使用了；处理各种数据都可以通过字节流完成，而在处理中文时使用字符流会更好；
99.内存操作流：
字节内存操作流：内存输入流ByteArrayInputStream、内存输出流ByteArrayOutputStream、字符内存操作流：内存输入流CharArrayReader、内存输出流CharArrayWriter；
文件操作流的形式：FileOutputStream：程序->OutputStream->输出到文件；
FileInputStream：程序<-InputStream<-文件；
内存操作流的形式：ByteArrayInputStream：程序->InputStream->输出到内存；
ByteArrayOutputStream：程序<-OutputStream<-内存；
100.乱码就是由于编码和解码标准不统一造成的；
101.打印流：字节打印流类PrintStream、字符打印流类PrintWriter；
102.缓冲区操作：BufferedReader；Scanner类；
103.对象序列化：指的是可以将在内存中保存的对象数据(主要指的是一个对象里面所包含属性内容)进行二进制数据传输的一种操作，要想完成这样的二进制操作，对象所在的类就必须实现java.io.Serializable接口；这个接口和Cloneable接口一样，都属于一种标识接口，表示一种能力；
要完成对象的输入或输出，还必须依靠对象输出流ObjectOutputStream和对象输入流ObjectInputStream；
使用对象输出流输出序列化对象的步骤也成为序列化；而使用对象输入流读入对象的过程，也成为反序列化；
transient关键字：使用这个关键字修饰的属性不能被序列化；
序列化操作的主要目的是为了保证对象可以以二进制数据的方式进行传输，如果要想实现对象序列化，对象所在的类必须实现java.io.Serializable接口，默认情况下一个对象的所有属性都会被序列化下来，也可以使用transient关键字定义不被序列化的属性；
104.在Java中使用File类表示文件本身，可以直接使用此类完成文件的各种操作；
输入输出流，主要分为字节流和字符流两种，但是在传输中以字节流操作较多，字符流在操作时使用到缓冲区，而字节流没有使用到缓冲区；
字节或字符流都是以抽象类的形式定义的，根据其使用的子类不同，输入或输出的位置也不同；
在IO包中可以使用OutputStreamWriter和InputStreamReader完成字符流与字节流之间的转换操作；
使用ByteArrayInputStream和ByteArrayOutputStream可以对内存进行输入输出操作；
在IO中，输出时最好使用打印流PrintStream、PrintWriter，这样可以方便地输出各种类型的数据；
System类提供了3个支持IO操作的常量：out、err和in；System.out对应着显示器的标准输出；System.err对应着错误打印，一般此信息不希望被用户看到；System.in对应着标准的键盘输入；
BufferedReader可以直接从缓冲区中读取数据；
使用Scanner类可以方便地进行输入流操作；
造成字符乱码的根本原因就在于程序编码与本地编码的不统一；
对象序列化可以将内存中的对象转化为二进制数据，但对象所在的类必须实现Serializable接口，一个类中的属性如果使用transient关键字声明，则此属性的内容将不会被序列化；
105.网络编程：指的就是通过网络进行程序数据操作；
C/S：要开发两套程序，一套是服务器端，另外一套是与之对应的客户端，但是这种程序在进行维护时需要维护两套程序，而且客户端的程序更新也必须及时，此类程序安全；
B/S：要开发一套程序，只开发服务器端的，客户端使用浏览器进行访问，这种程序进行程序维护时只需要维护服务器端即可，客户端不需要做任何修改；此类程序使用公共端口，包括公共协议，所以安全性很差；
106.如果要进行网络程序的开发，那么首先应该开发出服务器端，需要java.net包中的两个类；
ServerSocket类：是一个封装支持TCP协议的操作类，主要工作在服务器端，用于接收客户端请求；
Socket类：是一个封装了TCP协议的操作类，每一个Socket对象都表示一个客户端；
public ServerSocket(int port) 开辟一个指定的端口监听，一般使用5000以上；
public Socket accept() 服务器端接收客户请求，通过Socket返回；
public void close() 关闭服务器；
public Socket(String host,int port) 指定要连接的主机(IP地址)和端口；
public OutputStream getOutputStream() 取得指定客户端的输出对象，使用时肯定使用PrintStream装饰操作；
public InputStream getInputStream() 从指定的客户端读取数据，使用Scanner操作；
107.ECHO程序：回应程序；
108.类集是一种动态的对象数组，属于各个数据结构的实现类，整个类集的主要组成是一些核心的操作接口：Collection、List、Set、Map、Iterator和Enumeration；
109.单值保存(每一次操作只会保存一个对象)的最大父接口Collection；
允许重复的子接口List；继承自Collection接口；两个子类ArrayList和Vector；
ArrayList和Vector的区别：ArrayList的推出时间是JDK1.2，Vector的推出时间是JDK1.0；ArrayList采用异步处理方式，性能更高，Vector采用同步处理方式，性能相对较低；ArrayList非线程安全，Vector线程安全；
不允许重复的子接口Set；继承自Collection；散列(无序)存放的子类HashSet；排序存放的子类TreeSet；
110.Object类中各个方法的作用：
取得对象信息：public String toString()；
对象比较：public boolean equals(Object obj)；
取得对象编码：public int hashCode()；
线程等待：public void wait() throws InterruptedException；
唤醒第一个等待线程：public void notify()；
唤醒全部等待线程：public void notifyAll()；
对象克隆：public Object clone()；
对象回收前的收尾：public void finalize()；
取得Class类对象：public Class<?> getClass()；
111.Java中集合有4种输出方式：Iterator、ListIterator、Enumeration、foreach；
Iterator是专门迭代输出接口，所谓的迭代输出就是对元素逐个进行判断，判断其是否有内容，如果有内容则把内容取出；
ListIterator双向迭代输出接口；可以从后向前输出；
废弃的接口Enumeration接口；
JDK1.5的支持：foreach方法；
112.偶对象(一对对象，即两个对象key=value)保存：Map接口；
新的子类：HashMap；旧的子类：Hashtable；
HashMap和Hashtable的区别：HashMap是JDK1.2推出的，Hashtable是JDK1.0推出的；HashMap采用异步处理方式，性能更高，Hashtable采用同步处理方式，性能相对较低；HashMap非线程安全，Hashtable线程安全；HashMap允许将key或value设置为null，Hashtable不允许出现null，否则出现空指向异常；
113.Map.Entry<K,V>接口；Map集合是将保存的key和value变成了一个Map.Entry对象，通过这个对象包装了key和value；
Map使用Iterator输出的操作步骤：
使用Map接口种的entrySet()方法，将Map集合变为Set集合；
取得了Set接口实例后就可以利用iterator()方法取得Iterator的实例化对象 ；
使用Iterator迭代找到每一个Map.Entry对象，并进行key和value的分离；
114.Collections是专门提供的一个集合的工具类，并没有实现Collection接口；
Collection和Collections的区别：Collection是一个接口，用于定义集合操作的标准；Collections是一个工具类，可以操作任意的集合对象；
115.类集的目的是用来创建动态的对象数组操作；
Collection接口时类集中的最大单值操作的父接口，但是一般开发中不会直接使用此接口，而常用List或Set接口；
List接口扩展了Collection接口，里面的内容是允许重复的；
List接口的常用子类是ArrayList和Vector，在开发中ArrayList性能较高，属于异步处理，而Vector性能较低，属于同步处理；
Set接口与Collection接口的定义一致，里面的内容是不允许重复的，依靠Object类中的equals()和hashCode()方法来区分是否是同一个对象；
Set接口的常用子类是HashSet和TreeSet，前者是散列存放，没有顺序，后者是顺序存放，使用Comparable进行排序操作；
集合的输出要使用Iterator接口完成，Iterator属于迭代输出接口；
在JDK1.5之后，集合也可以使用foreach的方式输出；
Enumeration属于最早的迭代输出接口，现在基本上很少使用，在类集中，Vector类可以使用Enumeration接口进行内容的输出；
List集合的操作可以使用ListIterator接口进行双向的输出操作；
Map接口可以存放一对内容，所有的内容以key->value的形式保存，每一对key->value都是一个Map.Entry对象的实例；
Map中的常用子类是HashMap和Hashtable；HashMap属于异步处理，性能较高，Hashtable属于同步处理，性能较低；
类集中提供了Collections工具类完成类集的相关操作；
Stack类可以完成先进后出的操作；
Properties类属于属性操作类，使用属性操作类可以直接操作属性文件；
116.JDBC(Java数据库连接)提供了一种与平台无关的用于执行SQL语句标准Java API，可以方便地实现多种关系型数据库的统一操作，由一组用java语言编写的类和接口组成；
4类比较常见的JDBC驱动程序：
JDBC-ODBC桥驱动：是SUN提供的一个标准的JDBC操作，直接利用微软的ODBC(开放数据库连接)进行数据库的连接操作；
JDBC本地驱动：直接使用各个数据库生产商提供的JDBC驱动程序，因为其只能应用在特定的数据上，所以会丧失掉程序的可移植性，但这样操作的性能较高；
JDBC网络驱动：这种驱动将JDBC转换为DBMS无关的网络协议，之后这种协议又被某个服务器转换为一种DBMS协议，这种网络服务器中间件能够将它的纯Java客户机连接到多种不同的数据库上，所用的具体协议取决于提供者，通常这是最为灵活的JDBC驱动程序；
本地协议纯JDBC驱动：这种类型的驱动程序将JDBC调用直接转换为DBMS所使用的网络协议，这将允许从客户机机器上直接调用DBMS服务器，是Intranet访问的一个很实用的解决方法；
117.在JDBC中的核心组成部分为：DriverManager类、Connection接口、Statement接口、PreparedStatement接口和ResultSet接口，即五个接口一个类，就构成了整个JDBC的组成；
加载驱动程序----数据库连接----数据库操作----关闭
118.连接Oracle数据库：需要知道如下的几个连接信息：
数据库的驱动程序路径(配置的*.jar)：oracle.jdbc.driver.OracleDriver；
数据库的链接地址：jdbc:oracle:thin:@主机名称:端口号:数据库的实例名称；
要连接本机的数据库：jdbc:oracle:thin:@localhost:1521:mldn；
数据库的用户名：scott；
数据库的密码：tiger；
119.使用Statement操作数据库：要想取得Statement接口对象，必须依靠Connection接口完成；
PreparedStatement是Statement的子接口，属于预处理操作；
120.JDBC的操作步骤：
加载驱动程序：驱动程序由各个数据库生产商提供；
连接数据库：连接时要提供连接路径、用户名、密码；
实例化操作：通过连接对象实例化Statement或PreparedStatement对象；
操作数据库：使用Statement或PreparedStatement操作，如果是查询，则全部的查询结果使用ResultSet进行接收；
在开发中不要使用Statement接口操作，而是要使用PreparedStatement，这样不仅性能高，而且安全性也高；
121.程序分层：客户----显示层----控制层----业务层----数据层----数据库；
不同层之间最为重要的连接组成部分就是接口，所以整个代码开发中，后台代码就一定要有两个组成接口(业务层接口，给以后的控制层使用；数据层接口，给以后的业务层接口)；
数据层(数据访问层DAO)：指的是执行数据的具体操作，而现在的开发中，大多数都是针对于数据库的开发，所以在数据层中的主要任务是负责完成数据的CRUD，而在Java中，如果要想进行数据的CRUD实现，肯定使用java.sql.PreparedStatement接口完成；
业务层(业务对象，BO，Service)：业务层的主要目的是根据业务需求进行数据层的操作，一个业务层要包含多个数据层的操作；
122.VO(POJO\TO\PO)类：负责数据的传输与包装；
简单Java类：类名称要和表名称保持一致；为了日后类的操作方便，所有的简单Java类必须实现java.io.Serializable接口；类中不允许出现任何的基本数据类型，只能使用包装类；类中的所有属性都必须封装，必须都编写setter\getter；类中一定要提供有无参构造方法；