java学习重点

J2SE

用于桌面开发，低端商务开发(Java to Standard Edition) ；

J2ME

用于移动电话、电子消费品、嵌入式开发(Java to Micro Edition) ；

J2EE

企业级解决方案的开发，基于WEB的开发等，(Java to Enterprise Edition) ；

序号

语言角度

学习角度

1

比C++简单，放弃了对指针的使用；

入门迅速，容易学；

2

目前最好的网络编程语言；

编写更少、更好的代码；

3

开放式先进的技术，可移植性强；

更快的开发程序

4

完全的OO(面向对象，单根结构) 的跨平台语言；

用纯Java编写的程序可以避免平台相关性；

5

分布式开发，支持多线程，可靠安全健壮；

一次编写，处处运行，可以更容易的发布软件；

序号

特征

1

目前国内比较流行的技术组合：spring(www.springframework.com) + hibernate技术，还有webservice +XML技术；

2

J2EE的相关技术：EJB，SEVILET，JSP等；

3

源文件(*.java) --------->类文件(*.class) --------->java虚拟机(JVM)

             编译器              解释器

4

应用程序层

Java应用程序

Java平台层

Java虚拟机

操作系统层

UNIX

WINDOWS

RTOS

硬件层

SPARC

X86

MIPSPPC

序号

特征

1

面向对象的三个原则

封装性

封装的基本单元是类(class)，类是一个抽象的逻辑结构，而类的对象是一个真实的物理实体；类的目的是封装复杂性，在类内部存在隐藏实现复杂性机制；

封装(encapsulation) 的两个好处：

模块化：可以独立于其他对象的源代码进行编写和维护，可以很容易的将对象在系统中传递；

隐藏信息：其他对象可以通过本对象的一个公共接口进行通信而不影响其他对象；

继承性

继承是一个对象获得另一个对象的属性的过程，继承机制是一个对象成为一个更具通用类的一个特定实例成为可能，避免了代码的重复编写；

多态性

(重载overload，方法名相同、参数的个数不同、参数的类型不同、返回的类型不同和覆盖override) ；多态性就是“一种接口，多种方法”，可以为一组相关的动作设计一个通用的接口，其实类的函数的重载就是一种多态的体现；

4

引入抽象编程的思想；

类的封装就是一种抽象思想

序号

说明

1

类的修饰符只有public和default两个；

2

public修饰类时表示任何包的其它类都可以访问该类；

3

访问修饰符为default时只有在同一个包里的类才能访问它，其他包里的都不行；

4

类的构造函数(构造器) 不能用final、abstract、synchronized、native、static等关键字进行修饰；

序号

规则说明

1

java的成员访问修饰符有4种：public、private、protected、default

2

public static == static public；

3

类的成员访问修饰符的详细描述如下：(√表示允许访问，×表示不能访问)

visibility

public

protected

default

private

访问同一个类

√

√

√

√

访问同一个package中不同的类

√

√

√

×

访问在不同package中的父类（superclass）

√

√

×

×

访问不同的package中不同的类

√

×

×

×

综合上表，访问修饰符的访问权限为：public>protected>default>private

序号

修饰范围

规则说明

1

类

final类不能被继承，final类的性能会有所提升如：

public final class A{…}

public class B extends A{…} //错误，A被final类不能作为B的基类

2

方法

final成员不能被重写（overriding）；

3

类的成员变量

final变量不能被修改值，如：

public final class A{

static final int a = 10；

a = 11； //错误，不能被修改

static final int b; //此处是非法的，必须是如static final int b=9；

}

4

方法中的变量

可以在声明时不赋值，但是在使用之前必须赋值，一旦赋值就不能被修改；

public static void method() {

Final int a;

System.out.println(a) ; //错误，必须改为：a = 10；System.out.println(a) ;

}

5

final修饰的对象表示它所修饰的对象所分配的内存地址不可变；

final和abstract不能同时使用，如public final abstract class A{}是不允许的；因为final是使类A不能被继承而abstract是要类A在其子类中实现它的方法；

序号

修饰范围

规则说明

1

类

1、 被修饰的类为抽象类，不能被实例化(生成对象) 只能作为其他类的基类(父类)

2、 abstract不能修饰类的构造函数(构造器) ；

3、 类下面的方法可以不都被修饰为abstract，没有被修饰的方法则需要实现该方法；

2

类的方法

修饰方法时，它的类也必须被修饰为abstract

3

其它

abstract不能与final同时使用；

序号

规则说明

1

在java中只有接口、最外层的类和static Inner Class可以定义static变量或方法；

2

Static变量和方法属于它的类，它的类的所有对象都可以访问到它；但是任何一个类的对象对static变量进行修改都直接影响到所有对象；

3

它们只能访问static修饰的类的成员变量和方法

4

它们不能以任何方式引用this或super；

序号

规则说明

1

变量名称的命名规则：

（1）java只允许英文字母以及”$”以及”_”两个非英文字母作为变量或类名的首字母；     

（2）变量以小写字母开头，以后的每个单词首字母大写；其它的普通变量除了第一个单词首字 母小写外其他的都大写；

（3）类名的每个单词的首字母都大写；

（4）java约定_只用在常量声明的单词之间分隔单词;

2

规则1

int  99year = 99是非法的，而int  _99year=99是允许的

规则2

int  myInt = 99;

规则3

Class MyClass{}

规则4

int MAX_VALUE = 99

3

当变量声明为null时表示该变量没有初始化即没有分配内存空间；

4

八进制数的声明

int five = 05；int nine = 011；

十六进制的声明

int a = 0x9；int fifteen= 0xF；int sixteen=0x10；

在java中除了接口、外部类和static Inner Class可以定义static变量或方法；

序号

声明范围

规则说明

1

类的成员变量

它是一个类的成员（static修饰，所有类的变量即是所有对象公有的一个变量，它的更改将影响到所有的类的对象）或者一个对象的成员(非静态变量,属于类的对象的变量)，它在类内，但是是在任何方法和构造函数之外；

2

局部变量

主要是在类的方法或者一个代码块中，只在所在的方法或代码块中起作用；

3

方法的参数

是方法或者构造器中的正式自变量，用于向方法或者构造器传递值，作用范围是它所在方法或则构造器内；

4

异常处理器参数

与参数类似，它是异常处理器的自变量;

序号

规则说明

1

接口可以继承接口，用关键字extends(扩充、继承)

2

普通类可以实现多个接口，用关键字implements(实现)，用“，”分隔

3

接口中的定义中不能加private和protected，其default值是public；

4

接口中可以定义静态的变量，格式为：public static final type variableName;

5

实现类必须实现接口中的所有方法；

序号

规则说明

1

构造函数的作用：在生成类的对象时，为对象分配一个（封闭）的内存空间；

2

构造函数必须与类名一致；构造函数可以重载；

3

不管父类有无构造器，子类在实例化时都会调用父类的构造器，所以当父类中声明了带参数的构造器时，子类必须在构造器的第一行指定调用父类的哪个构造器；

4

构造器不返回任何类型，可以是个空方法，也可以给类的变量赋值；

5

在类的继承中，子类会默认调用父类中的构造器，可能出现的情况有：

public class A{

  public A(int i){

…

}

}

可以将类B中加个构造器：

public class B extends A{

  public B(int i){super(i)}

public static void main(String[] args){

  B b = new B(1);

}

}

或者在A类中加个没有参数和方法体的构造函数：

public class A{

  public A(){}

  public A(int i){…}

}

public class B extends A{

public static void main(String[] args){

  B b = new B();

}

}

6

例子：

public class A{

private int a；

public A（）{} //默认的构造函数可以不写

public A（int i）{

a= i；} //一旦建立了自己的构造函数，则java默认构造函数则将不再使用了。

}

序号

类型

规则说明

1

while

int a =0,b=10;

while（a<b）{

…

a++  //当a等于b时即跳出循环；

}

2

do while

规则：先执行后判断，至少要执行一次，如：

int a =0,b=10;

do{

   …

a++  //当a等于b时即跳出循环；

} while（a<b）；

3

for

规则根据条件执行；

for(int a=0;a<10;i++){

…//当a=10时自动跳出循环；

}

上个for循环语句等价于：

for(int a=0;a<10;){

… //当a=10时自动跳出循环；

a++;

}甚至可以：

int a=0;

for(;a<10;){

… //当a=10时自动跳出循环；

a++;

}

序号

跳转类型

规则说明

1

break

①switch语句中的跳转；

②用来跳出循环语句；

for(int i=0;i<100;i++){

if(i== 50 && j==49)

break; //直接跳出循环语句

else 

System.out.println(i);

}

③可以作为一种的先进的goto语句来使用；

2

continue

for(int i=0;i<100;i++){

if(i== 50 && j==49)

continue; //直接跳转到控制语句控制体中i++

else 

System.out.println(i);

}在循环体语句中可以用continue语句使程序只执行满足循环体条件的表达式；

3

return

直接结束并跳出方法，或者返回方法定义的数据类型；

public class Box{

public int length;

public int height;

public Box(int l,int h){

this. length = l;

this. height = h;

}

}

public class B{

Box  b1= new Box（10,20）；

Box  b2= b1；

System.out.println (b1.length+”-“+b1.height);

System.out.println (b2.length+”-“+b2.height);

b1.length =20;

b1.height =30;

System.out.println(b1.length+”-“+b1.height);

System.out.println (b2.length+”-“+b2.height);

}

结果： 10-20

10-20

20-30

20-30

这是因为：在上面的代码中，先是为b1分配了内存空间，然后在b2=b1时，将b2的指针也指向了b1所指向的内存空间，所以无论b1怎么变，b2都跟b1完全一致；

序号

分类

规则说明

1

优先级

在同一个运算表达式中，A++的优先级高于++A

2

A++

B=A++表示B=A；A=A+1；

3

++A

B=++A表示B=A=A+1；

定义：inner class是 class的另一种类的成员；内部类可以实现(implement)接口或者继承(extends)其它的类；

序号

分类

规则说明

1

静态内部类（又叫嵌套类）

类似与类中的static成员方法，在调用该类时不需要声明，可以直接调用；

2

成员内部类

类似与类中的非static成员方法，在调用该类时需要实例化它的外部类，然后通过该实例在实例化该内部类

3

本地内部类(local Inner Class)

类似于类的方法中的局部变量；

4

匿名类(Anonymous Inner Class)

一种特殊的local Inner Class；

5

总之，这4种内部类类似于普通类中的静态成员、非静态成员、方法中的局部变量

序号

规则说明

1

Static inner class可以访问它的外部类的所有的静态成员变量和方法；而它的外部类可以访问它的所有成员和方法（无论用什么修饰符）；

2

Static inner class访问它的外部类的非static变量时只能通过它的外部类的对象实例去访问；

3

Static inner class中只能有静态成员变量和方法；

4

Static inner class的名字不能跟它的外部类相同；

例子：public class MyOuter {

public static int ins;

public int myins;

public static class MyInner {

int i = ins;

int x =myins; //不能这样访问外部类的非静态成员，必须通过它的实例来访问；

int y = new MyOuter().myins; //这样访问myins是正确的；

public void food() { …}

}

 }

在编译之后不仅要生成一个MyOuter.class还将生成一个MyOuter $MyInner.class；

序号

规则说明

1

它类似与普通类中的非静态成员变量，但又具有类的特性，调用它需要对它实例化；

2

它可以访问public, package, protected, and private修饰的任何方法和成员变量；

3

Member Inner Class不能有static变量和方法；

4

Member Inner Class对象只能通过它的外部类的实例对象来进行访问，如 href="#例子memInner" 例子；

5

Member Inner Class的名字不能跟它的外部类的名字相同；

6

inner class的声明：

A． 在outerclass内部访问：

MyInner in = new MyInner();

B． 在outer class的外部访问：

Myouter.MyInner in = new Myouter().new MyInner();

或者 Myouter out = new Myouter();

 Myouter.MyInner in = out.new MyInner();

Member Inner Class例子：

public class Outer{

Public class Inner{ }

}

public class Test{

Outer ot = new Outer();

Inner inn= new Inner(); //这样是错误的，不能这样直接初始化

Outer .Inner inn= ot.new Inner(); //这样才是正确的

}

序号

规则说明

1

Local Inner Class是定义在类的方法中或者方法的某个代码块中的一种类；

2

类似于类的方法中的变量，不能被public, protected, private, or static修饰；

3

名字不能跟外部类的名字相同；不能有static成员或方法；只能访问它所在方法中的final变量；

序号

规则说明

1

Anonymous Inner Classes可以说是一个没有类名的Local Inner Class，由于没有名字所以不需要为它定义构造器；

2

匿名内部类只能访问final修饰的本地变量；

3

它总是要继承一个类或实现一个接口（2取其1），但不需使用extends或者implement关键字；

例子

public class A{

public void print(){

System.out.println(“printing A”);}

}

public class B{

public void print(){

A a = new A(){

//覆盖A类中的print()

public void print(){

System.out.println(“printing B”);

}; //声明一个匿名类，并将它的对象赋值给它的父类A的对象a，

a.print();

}

}

public class Test{

public static void main(String[] args){

A a = new A();

B b = new B();

a.print();

b.print()

}

}结果是：printing A

 printing B

序号

规则说明

1

String类与StringBuffer类的区别：

a、 String类是一个final类，一旦生成对象便不可改变它的值，如果改变这个对象则相当于生成了一个新的对象（将该对象指向了一个新的内存）

b、 StringBuffer类则可以创建和操作动态字符串，系统可以自动地为对象扩展内存以容纳新增的文本；

2

StringBuffer中的length()和capacity()方法的区别：

1）length方法返回字符串或字符串缓冲区中包含的字符数；

2）capacity方法返回分配给字符串缓冲区的空间量（capacity() = length()+16）；

3

String类中的equals方法与==是不一样的，equals方法表示两个比较的字符串中的字符是否一致，而==则表示操作符的两边的字符串变量所指的地址是否相同；

4

1）String A=”a”+”b”+”c”;

2）StringBuffer B=new StringBuffer(“a”); B. append(“b”). append(“c”);

上面的两个语句最后都是返回的字符串”abc”,但是1）共创建了5个字符对象（a,b,ab,c,abc）,而2）中只创建了3个，节省了内存空间，效率更高；

序号

规则说明

1

定义：它是程序内的一个单一的顺序控制流程；

２

特点：多个线程可以同时运行，在一个程序内可以执行不同的任务；这正是它的神奇之处；

3

线程与进程

相同点：

a、 都有一个专门的单一的顺序控制流程；

b、 线程又被称为轻量级进程（lightweight process）；因为它在一个完整程序的上下文中运行，并利用了程序分配给它的资源和此程序的环境；

4

创建一个线程的方法：

（1）继承一个Thread类，覆盖Thread类的run()方法：

 public class A extends Thread(public void run(){…..})；

（2）继承一个接口Runnable来实现一个线程：

 public class A implements Runnable{public void run(){…..}}；

实例化一个线程：

对于（１）：A a = new A();     a.start();

对于（２）：A a = new A();     Thread th = new Thread(a);  th.start();

start()方法对于一个线程来说只能调用一次，如果再次start一个已经started的线程，则会抛出一个unchecked exception（IllegalThreadStateException）

5

线程的4种状态：

主函数入口点，作为一个线程（main thread，主线程）在后台运行

序号

规则说明

1

定义：异常是在程序执行期间中断指令的正常流程的事件；

2

异常有两种：

运行时异常

它是在java运行时系统内发生；如算术异常（被零除），指针异常（通过一个null引用访问对象成员）、索引异常（如试图用太大或太小的索引访问数组中的元素）

方法不必捕获或者指定运行时异常；

非运行时异常

它是在java运行时系统外的代码中发生的异常，比如输入输出期间的异常，它也叫被检查的异常（checked exception）

3

在异常处理中所涉及到的关键字：try、catch、throw、throws、finally

4

构造异常处理器的步骤：

a、 将可能抛出异常的语句封闭在try块中；

b、 然后在catch块中捕获并抛出异常（可以多个）；

c、 最后在finally块中释放在try块中资源（可有可无，视情况而定）；

5

在程序中使用异常的优点：

a、 将错误处理代码与常规代码分离；

b、 将错误沿调用堆栈向上传递；

c、 将错误类型进行分组和区分

6

在一个捕捉异常的句子中，必须包含try{}的语句块，而catch和finally块两者必取其一或者都有，其中catch语句块可以有多个，catch块捕获的异常类型必须是子类异常在前，父类在后；

7

当try、catch和finally三块都有时，无论在try或者catch块中使用了return或者break也好，都将执行finally块中的语句；

8

在开发当中，我们一般使用finally语句块来清除错误或者异常发生时的无用的内存资源；

9

error

在java虚拟机中发生dll链接故障或者其他硬故障时，jvm抛出error。典型程序不应该也不可能捕获error。

Exception

所有的Exception子类都是派生自Exception类；

10

左图中：

大的红圈表示thirowable类的子类error和exception下的子类runtimeException都属于uncheck Exception，小的红圈表示exception的其它子类都属于check Exception

序号

内容

1

三个方法都是都是属于object类的public的方法，有返回值的方法；

2

方法

返回类型

不覆盖

覆盖

toString()

String

默认返回值为：

obj.getClass()+@+obj.hashCode()

其中hashCode值为无符号十六进制数；

当需要了解对象的相关信息时，可以根据程序的要求以及对象中的字段等等去返回一个字符串；

equals()

boolean

在object类中，判断是否引用对象(references)是否指向同一片内存，是则返回true；

可以在不指向同一片内存但满足程序需求来判断是否返回true，否则返回false；

hashCode()

int

一个无符号的十六进制整数

覆盖的话可以根据程序所要求的算法返回一个int类型，尽可能返回具有唯一性的值；

3

覆盖一个equals()方法，要满足以下条件：

Reflexive（反自身的）即 obj.equals(obj) =true应该恒成立；

Symmetric（对称的）即obj1.equals(obj2)=true时，obj2.equals(obj1)=true；

Transitive（可传递的）即当x.equals(y) =true 并y.equals(z) =true时x.equals(z) =true；

Consistent（一致性）即如果x.equals(y) =true或者为false时无论什么时候判断都返回相同的值；

４

覆盖一个hashCode()方法，要满足以下条件：

a、当obj1.equals(obj2)=true时，obj1.hashCode() = obj2.hashCode()恒成立；

b、当obj1.hashCode() = obj2.hashCode()时，obj1.equals(obj2)不见得返回true，也有可能返回false；

c、在同一个应用程序中，无论什么时候调用hashCode()方法时，返回值都必须保持一致；

５

equals()和hashCode()的关系

方法

返回值

与hashCode()的关系

A.equals(B)

true

A与B的hashCode()肯定相等；

false

A与B的hashCode()有可能相等；

一般在覆盖equals()方法时都要覆盖hashCode()方法；

If two objects are equal, their hashcodes must be equal as well.

６

在collections中的HashMap 和HashSet 经常用对象的hashCode值来决定它的存储位置或者定位它的存储位置，它有点类似与表中的primaryKey，应该尽可能的使hashCode值具有的唯一性。

序号

内容

1

一个implements类如果是sorted类型那么它一定是ordered类型(an implementation class can never be sorted but unordered, because sorting is a specific type of ordering)

接口

Implements

Ordered

Sorted

Synchronized

属性

List

ArrayList

√

×

By index

LinkedList

√

By index

Vector

√

√

By index

Set

HashSet

LinkedHashSet

√

By insertion order or last access order

TreeSet

√

By natural order or common comparison rule.

Map

HashMap

Hashtable

√

LinkedHashMap

√

By insertion order or last access order

TreeMap

√

By natural order or common comparison rule.

接口

内容

List

List是一个有序的集合，有时称为序列，可以包含重复元素

ArrayList

1、我们可以将其看作是能够自动增长容量的数组；

2、利用toArray()返回一个数组；

3、Arrays.asList()返回一个列表；

4、迭代器(Iterator) 给我们提供了一种通用的方式来访问集合中的元素；

LinkedList

1、LinkedList是采用双向循环链表实现的。

2、利用LinkedList实现栈(stack)、队列(queue)、双向队列(double-ended queue )。

Vector

ArrayList和LinkedList的异同：

1

ArrayList底层采用数组完成，而LinkedList是以一般的双向链表完成，其中的元素除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素。

2

ArrayList在遍历时的性能要高于LinkedList，但LinkedList在增加和删除时的性能要高于ArrayList

Vector与ArrayList的区别：

Vector的方法都是synchronized的（多线程安全），而ArrayList是unsynchronized的

接口

内容

Set

Set的value具有唯一性(Unique)；由equals方法来决定是否存在所要加入的值；

HashSet

1、实现Set接口的hash table(哈希表)，依靠HashMap来实现的。

2、我们应该为要存放到散列表的各个对象定义hashCode()和equals()。

TreeSet

保证它里面的元素根据natural order升序或者根据自己的规则进行排序；

LinkedHashSet

它是ordered型的doubly-linked的HashSet，

HashMap

UnSynchronized for thread,允许一个null Key多个nullValue

HashSet和TreeSet的比较:

HashSet是基于Hash算法实现的，其性能通常都优于TreeSet。

我们通常都应该使用HashSet，在我们需要排序的功能时，我们才使用TreeSet;

接口

内容

Map

Map是一个将key映射到value的对象，其中key是唯一的，每个key与value是一一对应的

HashMap

1、它是一个unordered、unsorted的Map；

2、允许一个为null的key，同时也允许多个为null的value；

Hashtable

不允许有为null的key或value；

LinkedHashtable

Remove或者add元素的效率低于Hashtable，但遍历的效率高于Hashtable；

TreeMap

1、保证它里面的元素根据natural order升序或者根据自己的规则进行排序；

2、并根据key值进行排序；

Hashtable是一个synchronized的HashMap

HashMap和TreeMap的异同：

HashMap的速度通常都比TreeMap快，只有在需要排序的功能的时候，才使用TreeMap。

HashMap和Hashtable的异同：

1.

Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；

2.

Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决：Map Collections.synchronizedMap(Map m) ，   这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。

3.

在HashMap中，可以允许唯一的一个null值作为键；但可以有一个或多个value值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。

Map中的key是唯一的；

HashMap对key进行散列,

TreeMap按照key进行排序。

1

. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。

2

. getInputStream方法获得网络连接输入，同时返回一个IntputStream对象实例，。

3

. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。

注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

数据库名

驱动程序

URL

MSSQL Server2000

com.microsoft.jdbc.sqlserver.SQLServerDriver

jdbc:microsoft:sqlserver://[ip]:[port];databaseName=[databaseName]

JDBC-ODBC(Access)

sun.jdbc.odbc.JdbcOdbcDriver

jdbc:odbc:[odbcsource]

Oracle oci8

oracle.jdbc.driver.OracleDriver

jdbc:oracle:oci8:@ [ip]:[port]:[sid]

Oracle thin Driver

oracle.jdbc.driver.OracleDriver

jdbc:oracle:thin:@[ip]:[port]:[sid]

MySQL

org.gjt.mm.mysql.Driver

jdbc:mysql://ip/database

Cloudscape

COM.cloudscape.core.JDBCDriver

jdbc:cloudscape:database