Java编程思想学习

一 基础知识点
1.面向对象程序设计（Object-oriented Programming OOP），UML(Unitied Modelling Language 统一建模语言)。将对象想像成“服务提供者”，它们看起来像什么？能够提供哪些服务？需要哪些对象？
2.Java中动态绑定是默认行为。Java采用动态内存分配方式，通过new操作在堆(Heap)的内
存池中动态创建对象。Java存储结构类型：1）寄存器2）堆栈，主要存储对象引用3）堆，主要用于存放所有的Java对象4）常量存储，也就是程序代码区5）非RAM存储，如流对象和持久化对象。基本类型不用new来创建变量，而且这个变量直接存储”值”，并置于堆栈中。
3.BigInteger和BigDecimal的使用。当变量作为类的成员使用时，Java才确保给定其默认初始值，但是在方法中定义的变量，它有可能是任意值。面向对象的程序设计可以归纳为“向对象发送消息”。关键字Static。
4.Javadoc只能为public和protected成员进行文档注释，但是也可以通过-private进行标记注释。Javadoc常用方法：@see 引用其他类，{@ link package.class#member label}，{@docRoot}，{@inheritDoc},@version，@ author，@since,@param，@return,@throws,@deprecated。
5.整数除法会直接去掉结果的小数位。基本类型的对象如果直接对它们赋值，对象指向同
一个常量存储区，但是如果通过对象来初始化则会指向不同的堆的存储区。如：
String st1 = new String("A");String st2 = new String("A"); st1==st2 false String st1 = "A"; String st2 = "A"; st1==st2 true
6.逻辑操作符：与(&&)、或(||)、非(!)，其中与(&&)、或(||)会产生短路现象。& |也支持逻辑运算操作。
7.直接常量中L代表Long，F代表Float，D代表Double。显示二进制形式的话，可以通过Integer和Long类的静态方法toBinaryString()。如：Long.toBinaryString(10L)。
8.在返回void的方法中没有return语句，那么在该方法的结尾处会有一个隐式的return。一般情况下每个方法都会有一个显示的return语句。
9.Break用于强行退出循环，不执行循环中剩余的语句，而continue则停止执行当前的迭代，然后退回循环起始处，开始下一次迭代。goto仍是Java的一个保留字，但在语言中并未使用它。Break和continue与标签一起使用，可以中断循环，直到标签所在的地方。This用法：

public class Leaf {
  int I = 0;
  Leaf increment() {
    i++;
    return this;
  }
}

10.回答一个新技术的问题大概思路和步骤是：我们想干什么，怎么干，干的过程中遇到了什么问题，现在用什么方式来解决。答题时，先答是什么，再答有什么作用和要注意什么（这部分最重要，展现自己的心得）。
11.finalize的使用：垃圾回收只与内存有关，当“垃圾回收”时，finalize()得到调用。Java中的对象都能被垃圾回收器回收，但是在“本地方法”的情况下，有可能在分配内存时采用类似C语言的做法通过malloc()函数来分配存储空间时，这时只能通过free()函数来释放空间，而这些释放操作必须要放到finalize()方法中，垃圾回收器才能正确的释放内存。“垃圾回收”都不保证一定会发生。
12.垃圾回收原理：引用记数是一种简单但速度很慢的垃圾回收技术。每个对象都含有一个引用记数器，当有引用连接至对象时，引用计数加1。当引用离开作用域或被置为null时，引用计数减1。垃圾回收器会在含有全部对象的列表上遍历，当发现某个对象的引用计数为0时，就立即释放其占用的空间。定位交互自引用的对象组所需的工作量极大，所以并没有被应用于任何一种Java虚拟机中。Java虚拟机采用一种自适应的垃圾回收技术，Java虚拟机会进行监视，如果所有对象都很稳定，垃圾回收器的效率降低的话，就切换到“标记-清扫”方式；同样，Java虚拟机会跟踪“标记-清扫”的效果，要是堆空间出现很多碎片，就会切换回“停止-复制”方式。“停止-复制”，先暂停程序的运行，然后将所有存活的对象从当前堆复制到另一个堆，没有被复制的全部都是垃圾。“标记-清扫”，从堆栈和静态存储区出发，遍历所有的引用，进而找出所有存活的对象，每当它找到一个存活对象，就会给对象设一个标记，这个过程中不会回收任何对象，只有全部标记工作完成的时候，清理动作才会开始。在清理过程中，没有标记的对象将被释放，不会发生下任何复制动作。
13.初始化顺序:先静态对象，后“非静态”对象，先变量，再构造函数，然后是方法。静态初始化只有在必要时刻才会进行，如果不引用其对象，那么该对象中的静态成员将不会被创建，而且它们只会在第一次被访问时进行初始化，其后不会再次被初始化。
14.对象的创建过程：1）当首次创建对象时，或类的静态方法/静态域首次被访问时，Java解释器必须查找类路径，以定位.class文件。2）载入.class，有关静态初始化的所有动作都会执行。3）当用new 创建对象时，在堆上为对象分配存储空间，而且这块存储空间会被清零，也就是说它会自动地将对象中的所有基本类型数据都设置成默认值，而引用是被设置成null。4）执行所有出现于字段定义处的初始化动作。5）执行构造器。
15.数组：java.util.Arrays常用方法的使用。binarySearch(),copyOf(),asList(),copyOfRange(),equals(),fill(),sort(),toString(),hashCode()。可变参数列表:void f(float i,Character… args)。枚举类型:enum,它可以在switch语句内使用。
16.类的结构依次为：1）包的注释2）package的设置3)import导入设置4)类的注释5）类的编写。
17.Java的访问权限：类的访问权限只有public和默认包访问权限，成员和方法有public,protected,默认包访问权限和private。使用类的客户端程序是无法访问包访问权限成员的。包访问权限的类的对象可以由包内任何其他类来创建和使用，但是包外则不行。
18.为了继承，一般的规则是将所有的数据成员都指定为private，将所有的方法指定为public或protected。Java会自动在导出类的构造器中插入对基类构造器的调用。调用基类的构造器必须是你在导出类构造器中要做的第一件事。
19.代理，它是继承与组合之间的中庸之道，因为我们将一个成员对象置于所要构造的类中（就像组合），但与此同时我们在新类中暴露了该成员对象的所有方法（就像继承）。
20.清理方法的顺序：首先，执行类的所有特定的清理动作，其顺序同生成顺序相反；然后，调用基类的清理方法。除了内存之外，不能依赖垃圾回收器去做任何事，如果需要进行清理，最好是编写自己的清理方法，但不要使用finalize()。@Override注解可以防止在你不想重载时而意外地进行了重载。
21.组合与继承之间的选择：组合技术通常用于想在新类中使用现有类的功能而非它的接口，也就是在新类的嵌入某个对象，让其实现所需要的功能，但新类的用户看到的只是为新类所定义的接口，而非所嵌入对象的接口，一般情况下会在新类中嵌入一个现有类的private对象。而继承，它是指使用某个现有类，并开发一个它的特殊版本。“is-a”（是一个）的关系是用继承来表达的，而“has-a”（有一个）的关系则是用组合来表达的。
22.final的用法：根据惯例，既是static又是final的域将用大写表示，并使用下划线分隔各个单词。类中所有的private方法都隐式的指定为是final的。final类中所有的方法都隐式指定为是final的。当前用HashMap替代了Hashtable，用ArrayList替代了Vector。
23.Java中除了static方法和final方法（private方法属于final方法）之外，其他所有的方法都是后期绑定。接口中的属性都是public static final的，方法都是public
24.多态：只有普通的方法调用可以是多态的。任何域访问操作都将由编译器解析，因此不是多态的。如果某个方法是静态的，它的行为也不具有多态性。
25.初始化的实际过程：1）在其他任何事物发生之前，将分配给对象的存储空间初始化成二进制的零。2）如前所述那样调用基类构造器，此时，调用被覆盖后的方法（要在调用子类构造器之前调用）。3）按照声明的顺序调用成员的初始化方法。4）调用导出类的构造器主体。编写构造器时有一条有效的准则：“用尽可能简单的方法使对象进入正常状态；如果可以的话，避免调用其他方法”。在构造器内唯一能够安全调用的那些方法是基类中的final方法（也适用于private方法，它们自动属于final方法）。这些方法不能被覆盖。
26.一条通用的准则是：“用继承表达行为间的差异，并用字段表达状态上的变化”。
27.一个内部类的对象能访问其外围对象的所有成员，还拥有其外围类的所有元素的访问权。在内部类中，如果你需要生成对外部类对象的引用，可以使用外部类的名字后面紧跟圆点和this，（OuterClass out = OuterClass.this）。有时你可能想要告知某些其他对象，去创建其某个内部类的对象，可以在new表达式中提供对其他外部类对象的引用，需要使用.new语法（OuterClass out = new OuterClass, OuterClass.InnerClass inner = out.new InnerClass()）。在拥有外部类对象之前是不可能创建内部类对象的，但是，嵌套类（静态内部类）除外。如果定义一个匿名内部类，并希望它使用一个在其外部定义的对象，那么其参数引用必须是final的。匿名类的实例初始化的实际效果就是构造器，而且你不能重载实例初始化方法，它可以扩展类，也可以实现接口，但是实现接口，也只能实现一个接口。
28.嵌套类（静态内部类）：1)要创建嵌套类的对象，并不需要其外围类的对象；2)不能从嵌套类的对象中访问非静态的外围类对象。
30.为什么需要内部类：1）每个内部类都能独立继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。2）内部类可以更好的实现“多重继承”。3）内部类可以有多个实例，每个实例都有自己的状态信息，并且与其外围类对象的信息相互独立。4）在单个外围类中，可以让多个内部类以不同的方式实现同一个接口或继承同一个类。5）创建内部类对象的时刻并不依赖于外围类对象的创建。6）内部类并没有令人迷惑的“is-a”关系，它是一个独立的实体。
31.闭包：它是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。通过内部类提供闭包的功能是优良的解决方案。使用局部内部类而不使用匿名内部类的的理由是需要不止一个该内部类的对象，或者需要一个已命名的构造器。
32.内部类的继承：内部类的构造器必须连接到指向其外围类对象的引用，必须在构造器内使用如下语法：enclosingClassReference.super();
33.容器：List、Set、Query、Map。程序中不应该使用过时的Vector,Hashtable和Stack。
常用的类有:Collection,Collections,Arrays,ArrayList,LinkedList,HashSet,TreeSet,LinkedHashSet,HashMap,TreeMap,LinkedHashMap,Query,Stack，PriorityQuery
迭代器：Iteratror,ListIterator
34.异常：把当前异常对象重新抛出时，printStackTrace()方法显示原来异常抛出点的调用栈信息，要想更新这个信息，可以调用fillInStackTrace()方法。如：
throw (Exception) e.fillInStackTrace()。
35.异常链：在捕获一个异常后抛出另一个异常，而且希望把原始异常的信息保存下来。现在所有的Throwable的子类在构造器中都可以接受一个cause(因由)对象作为参数。这个cause就用来表示原始异常，这样通过把原始异常传递给新的异常，使得即使在当前位置创建并抛出了新的异常，也能通过这个异常链追踪到异常最初发生的位置。只有三种基本异常类（Error、Exception、RuntimeException）提供了带cause参数的构造器，其他的异常只能使用initCause()方法。
36.当覆盖方法的时候，只能抛出在基类方法的异常说明里列出的那些异常，或者抛出的异常的子类或者不抛出异常。
37.Java标准异常：Throwable这个Java类被用来表示任何可以作为异常被抛出的类。Throwable对象可分为两种类型（指从Throwable继承而得到的类型）：Error用来表示编译时和系统错误（除特殊情况外，一般不用你关心）；Exception是可以被抛出的基本类型，在Java类库、用户方法以及运行时故障中都可能抛出Exception型异常。所以Java程序员关心的基类型通常是Exception。
38.RuntimeException:Java运行时异常，它属于Java的标准运行时检测的一部分，它会自动被Java虚拟机抛出，它也被称为“不受检查异常”，这种异常属于错误，将被自动捕获，不用自己进行处理。除此之外的异常需要进行声明，并进行捕获或都向上抛出。只能在代码中忽略RuntimeException（及其子类）类型的异常，其他类型异常的处理都是由编译器强制实施的。RuntimeException代表的编程错误：1）无法预料的错误；2）作为程序同，应该在代码中进行检查的错误。
39.catch会捕获基类异常本身以及所有从它派生的异常，如果将基类异常放在前面，子类异常放在后面的话，子类异常永远不会被捕获，编辑器会报错。Unreachable catch block for RuntimeException. It is already handled by the catch block for Exception。
40.异常处理的一个重要目标就是把错误处理的代码同错误发生的地点分离。应该在下列情况下使用异常：1）在恰当的级别处理问题。（在知道该如何处理的情况下捕获异常）2）解决问题并且重新调用产生异常的方法。3）进行少许修被，然后绕过异常发生的地方继续执行。4）用别的数据进行计算，以代替方法预计会返回的值。5）把当前运行环境下能做的事情尽量做完，然后把相同的异常重抛到更高层。6）把当前运行环境下能做的事情尽量做完，然后把不同的异常抛到更高层。7）终止程序。8）进行简化。9）让类库和程序更安全。
41.字符器：String,StringBuilder,Formatter.格式化语法：
%[argument_index$][flags][width][.precision]conversion
在默认的情况下，数据是右对齐，不过可以通过使用“-”标志来改变对齐方向。
42.正则表达式：\\意思是“我要插入一个正则表达式的反斜线，所以其后的字符具有特殊的意义”。数字的正则表达式是:\\d，普通反斜线：\\\\，换行：\n，制表符：\t。要表示“一个或多个之前的表达式”，使用+。“零个或多个”，使用?。(-|\\+)?:+在正则表达式中有特殊意义，必须使用\\将其转义。String类有matches()和split()方法处理正则表达式。
43.我们通过java.util.regex.Pattern类和Matcher类来构造正则表达式对象。导入java.util.regex包，用static Pattern.compile()方法来编译正则表达式生成一个Pattern对象，再将你想要检索的字符串传入Pattern对象的matcher()方法，它会生成一个Matcher对象，最后通过操作Matcher对象来实现相关功能。还可以通过Scanner来完成正则表达式相关功能。
44.在Java中，所有的类型转换都是在运行进进行正确性检查的。通过Class.forName()获得Class对象的引用，也可以通过Object类的getClass()方法来获得。
45.使用类的准备工作：1）加载，这是由类加载器执行，该步骤将查找字节码，并从这些字节码中创建一个Class对象。2）链接，将验证类中的字节码，为静态域分配存储空间，并且如果必需的话，将解析这个类创建的对其他类的所有引用。3）初始化，如果该类具有超类，则对其初始化，执行静态初始化器和静态初始化块。（构造器隐式地是静态的）。
46.RTTI和反射之间的区别：对RTTI来说，编译器在编译时打开和检查.class文件。而对于反射机制来说，.class文件在编译时是不可获取的，所以是在运行时打开和检查.class文件。
47.泛型中T代表类型Class，要显式地指明类型，必须在点操作符与方法名之间插入尖括号，然后把类型置于尖括号中；如果是在定义该方法的类的内部，必须在点操作符之前使用this关键字，如果是使用static的方法，必须在点操作符之前加上类名。在泛型代码内部，无法获得任何有关泛型参数类型的信息。在泛型中创建数组，推荐使用Array.newInstance()。泛型(<T>)会擦除出现在方法或类内部的有关实际类型的信息。但是可以引入类型标签来传递类型信息（Class<T>）。<? extends SuperClass>、<? super SuperClass>
48.任何基本类型都不能作为类型参数，但是可以使用它们的包装类，如不能使用ArrayList<int>，但可以使用ArrayList<Integer>
49. 异常的分类：1）Error:称为错误，由Java虚拟机生成并抛出，包括动态链接失败、虚拟机错误等，程序对其不做处理；2)Exception:所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显示的声明或捕获；3)Runtime Exception:一类特殊的异常，如被0除、数据下标超范围等，其产生比较频繁，处理麻烦，如果显式的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）。
50.使用自定义异常一般步骤：1）通过继承java.lang.Exception类声明自己的异常类；2）在方法适当的位置生成自定义异常的实例，并用throw语句抛出；3）在方法的声明部分用throws语句声明该方法可能抛出的异常。

二 专项复习
1.容器
2.正则表达式
3.设计模式
4.异常
5.泛型
6.反射
7.多线程
8.IO

三 J2SE常用包（加粗是抽象类，斜体是接口，普通是类）
1.java.lang
提供利用 Java 编程语言进行程序设计的基础类。Process、ProcessBuilder、Runtime、System、String、Object、Class、ClassLoader、Math、Compiler、Thread、ThreadGroup、Runnable、ThreadLocal、InheritableThreadLocal、Package
2.java.util
ArrayList、Arrays、Collection、Collections、LinkedList、HashSet、TreeSet、Iterator、ListIterator、Map、HashMap、TreeMap、Comparator
历史遗留的类：Dictionary、Hashtable、Properties、Stack、Vector、Enumeration
使用迭代函数的步骤：1）通过调用类集的iterator()或listIterator()方法获得对类集头的迭代函数；2）建立一个调用hasNext()方法的循环，只要hasNext()返回true，就进行循环迭代；3）在循环内部，通过调用next()方法来得到每一个元素。
BitSet、Calendar、GregorianCalendar、TimeZone、SimpleTimeZone、Locale、DateFormat、SimpleDateFormat、Random、Observer、Observable、Timer、TimerTask
GregorianCalendar定义了两个域：AD和BC。它们代表由公历定义的两个纪元。BC公元前，AD公元后
3.java.io
InputStream、OutputStream、Reader、Writer、FileInputStream、FileOutputStream、ByteArrayInputStream、ByteArrayOutputStream、FilterOutputStream、FilterInputStream、BufferedInputStream、BufferedOutputStream、SequenceInputStream、PrintStream、RandomAccessFile、FileReader、FileWriter、CharArrayReader、CharArrayWriter、BufferedReader、BufferedWriter、PrintWriter
ObjectInputStream、ObjectOutputStream序列化的类必须实现java.io.Serializable 或 java.io.Externalizable 接口的对象才能从流读取。

4.java.net
InetAddress、URL、URLConnection
Java中有两类TCP套接字。一种是服务器端的，另一种是客户端的。ServerSocket类设
计成在等待客户建立连接之前不做任何事的“监听器”。Socket类为建立连向服务器套接
字以及启动协议交换而设计。
http://www.osborne.com:80/index.htm是URL 的例子。一个URL规范以四个元素为基础。第一个是所用到的协议，用冒号（：）来将它与定位符的其他部分相隔离。尽管现在所有的事情都通过HTTP(实际上，如果你在URL规范中不用“http://”，大多数浏览器都能正确执行)完成，但它不是惟一的协议，常见的协议有http、ftp、gopher和文件。第二个元素是主机名或所用主机的IP地址，这由左边的双斜线（//）和右边的单斜线（/）或可选冒号（：）限制。第三个成分，端口号，是可选的参数，由主机名左边的冒号（：）和右边的斜线（/）限制（它的默认端口为80，它是预定义的HTTP 端口；所以“:80”是多余的）。第四部分是实际的文件路径。多数HTTP服务器将给URL附加一个与目录资源相关的index.html或 index.htm 文件。所以，http://www.osborne.com/ 与http://www.osborne.com/index.htm 是相同的。

Java通过两个类实现UDP协议顶层的数据报：DatagramPacket对象是数据容器，
DatagramSocket是用来发送和接受DatagramPackets的机制。

5.java.rmi