java学习重点

编译器              解释器

封装(encapsulation) 的两个好处：

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

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

public final class A{…}

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

public final class A{

static final int a = 10；

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

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

}

public static void method() {

Final int a;

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

}

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

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

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

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

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

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

public A(int i){

…

}

}

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 static void main(String[] args){

B b = new B();

}

}

public class A{

private int a；

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

public A（int i）{

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

}

while（a<b）{

…

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

}

int a =0,b=10;

do{

…

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

} while（a<b）；

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

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

}

上个for循环语句等价于：

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

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

}甚至可以：

int a=0;

for(;a<10;){

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

a++;

}

②用来跳出循环语句；

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

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

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

else

System.out.println(i);

}

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

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

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

else

System.out.println(i);

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

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 (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

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；

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();

public class Outer{

Public class Inner{ }

}

public class Test{

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

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

}

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，

}

}

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

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

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

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

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

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

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

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

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

（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）

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

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

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

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

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

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

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

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

obj.getClass()[email protected]+obj.hashCode()

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

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时无论什么时候判断都返回相同的值；

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

HashMap对key进行散列,

TreeMap按照key进行排序。

Array：arrays的元素个数不能下标越界，保证了Java程序的安全性。

Array可以存放Object和基本数据类型，但创建时必须指定数组的大小，并不能再改变。值得注意的是：当Array中的某一元素存放的是Object  reference 时，Java将其初值设为null。

Vector内部也是通过元素的整数索引来访问元素，但它只能存Object对象，不能用于存放基本类型数据，比如要存放一个整数10,得用Integer包装类对象再放进去。当Vector中的元素个数发生变化时, 其内部的Array必须重新分配并进行拷贝。

Vector同时也实现了List接口，所以也可以算作Collection了，只是它还特殊在：Vector is synchronized。即Vector对象自身实现了同步机制。