Core Java笔记

 

 下面是我对Core Java做的一点笔记，不全，但对自己还是有点参考价值：

 

1. 在C++中，字符串作为字符的数组来实现的，而在Java中，字符串实际上是对象类型。

2. 不能将内部作用域声明的变量与其外部作用域声明的变量重名。

3. Java自动类型转换必须同时满足两个条件，称为拓宽转换（widening conversion）：
1） 这2种类型是兼容的。
2） 目的类型数的范围比来源类型的大。

4. 强制类型转换：（target-type）value

5. 类型提升的约定：
所有的byte型和short型的值被提升到int型；
如果有一个操作数是long型，整个表达式将被提升到long型；
如果有一个操作数是float型，整个表达式被提升到float型；
如果有一个操作数是double型，整个表达式被提升到double型。
例如：
byte a = 40;
byte b = 50;
byte c = 100;
int d = a * b / c;    // a * b 被提升为int型。

6. Java中的数组可以动态分配：
如：
int month_days[];
month-days = new int[12];
month_days[0] = 31;

当然，专业的做法是：
int month_days[] = new int[12];
或者:
int[] month_days = new int[12];

多维数组：
int twoD[][] = new int[4][5];

7. >>>运算符：右移，左边空出的位以0填充。
>>=运算符：右移赋值。
>>>=运算符：右移赋值，左边空出的位以0填充。
<<=运算符：左移赋值。

8. 与(&)、或(|)、异或(^)、非.(~)。

9. Java的跳转语句：break，continue，return。没有goto，用break label代替goto。

10. Java中获得一个类的对象需要两步：第一步，必须声明该类类型的一个变量，这个变量没有定义一个对象。实际上，它只是一个能够引用对象的简单变量。第二步，该声明要创建一个对象的实际的物理拷贝，并把对于该对象的引用赋给该变量。这是通过new运算符实现的。new运算符为对象动态分配内存空间，并返回对它的一个引用。这个引用或多或少的是new分配给对象的内存地址。然后这个引用被存储在该变量中。这样，在Java中，所有的类对象都必须动态分配。如下：
Box mybox = new Box();

实际上是下面两步的组合：
Box mybox;  // declare reference to object
Mybox = new Box();  // allocate a Box object
第一行声明了mybox，把它作为对于Box类型的对象的引用。当本句执行后，mybox包含的值为null，表示它没有引用对象。这时任何引用mybox的尝试都将导致一个编译错误。第二行创建了一个实际的对象，并把对于它的引用赋给mybox。现在，可以把mybox作为Box的对象来使用。但实际上，mybox仅仅保存实际的Box对象的内存地址。

11. 给对象引用变量赋值：
Box b1 = new Box();
Box b2 = b1;  // b1和b2将引用同样的对象。
尽管b1和b2都引用同一个对象，但是他们之间没有任何其他的关系。接下来对b1的赋值仅仅b1脱离（unhook）初始对象，而没有影响对象或影响b2。
Box b1 = new Box();
Box b2 = b1;  // b1和b2将引用同样的对象。
// …
B1 = null; // 这里b1被设置为空，但是b2仍然指向原来的对象。

12. 在同一个范围或一个封装范围内，定义二个重名的局部变量在Java中是不合法的。但局部变量，包括传递到方法中的正是的自变量，可以与类的实例变量的名字重叠，这种情况下，局部变量名酒隐藏了实例变量名。

13. 垃圾回收（garbage collection）工作原理：当一个对象的引用不存在时，则该对象被认为是不再需要的，它所占用的内存就被释放掉。

14. finalize()方法：收尾机制。使用该机制可以定义一些特殊的操作，这些操作在一个对象将要被垃圾回收程序释放时执行（如一些非Java资源，文件句柄，Windows字符字体等）。要给一个类增加收尾（finalizer），只要给类定义finalize()方法即可。Java回收该类的一个对象时，就会调用这个方法。finalize方法返回类型只能是void型的，如下形式：
@Override
 protected void finalize() throws Throwable {
  // TODO Auto-generated method stub
  super.finalize();
 }

15. 类的static方法：
仅能调用其他的static方法。
只能访问static数据。
不能以任何方式应用this或super。

16. final的三个用途：
(1)一个变量可以声明为final，这样做的目的是阻止它的内容被修改。这意味着在声明final变量的时候，必须初始化它（类似于C++众的const）。final变量实质上是一个常数。
(2)声明成final的方法不能被重载。
(3)声明成final的类不能被继承。因此，声明一个既是abstract又是final的类是不合法的。

17. 嵌套类：嵌套类可以访问嵌套它的类的成员，包括private成员。但是，包围类不能访问嵌套类的成员。

18. String类：创建的每一个字符串实际上都是String类型的一个对象，即使是字符串常量实际上也是String对象。
字符串的另一个特点是，String类型的对象是不可以改变的，一旦创建了一个字符串对象，它的内容是不能被改变的。因为：
如果需要改变一个字符串，可以创建一个新的字符串，其中包含修改后的字符串即可。
Java定义了一个和Sting类同等的类叫StringBuffer，它允许字符串改变，因此所有正常的字符串操作在Java中还是可用的。

19. Java所有的命令行参数都是以字符串的形式传递的，必须手工把数字值变换到它们的内部形式。

20. 继承：class B extends A{}

21. super:任何时候一个子类需要引用它直接的超类，可以用super关键字来实现。

22. 抽象类：任何含有一个或多个抽象方法的类都必须声明成抽象类。
abstract class A{
abstract void func（）{
}
}
抽象类没有对象，不能通过new操作符直接实例化。所有抽象类的子类都必须执行超类中的所有抽象方法或者是它自己也声明称abstract。

23. Object类：所有其它类都是Object的子类。这意味着一个Object类型的引用变量可以引用其它任何一个类的对象。同样，因为数组像类一样执行，Object类型变量可以引用任何数组。

24. 包（package）：是类的容器，用来保存划分的类名空间。Java用文件系统目录来存储包，目录名必须和包名严格匹配。

25. Java编译器考虑的特定位置作为包层次的根，被类路径（CLASSPATH）控制。

26. 因为类和包的相互影响，Java将类成员的可见度分为四个种类：
(1) 相同包中的子类。
(2) 相同包中的非子类。
(3) 不同包中的子类。
(4) 既不在相同包又不在相同子类中的类。
三个访问控制符，private，public，protected，提供了多种方法来产生这些种类，下面是类成员访问表（仅适合类成员）。
                         private成员 默认的成员 protected成员 public成员
同一类中可见                 是          是          是           是
同一个包中对子类可见         否          是          是           是
同一个包中对非子类可见       否          是          是           是
不同包中对子类可见           否          否          是           是
不同包中对非子类可见         否          否          否           是
public：任何声明为public的内容可以被从任何地方访问。
private：被声明成private的成员不能被该类外访问。
默认访问：不含有明确的访问说明，它对于该包中的其他类是可访问的。
protected：可以被该类自身，同一个包中的其他类，其他包中的子类访问。

27. 类的访问控制符只有一个public或没有访问控制符。如果类没有访问控制符，那么它具有缺省的访问控制特性，只能被同一个包中的类访问和引用。

28. 引入包：import pkd1[pkg2.].(classname|*);

29. 接口：用关键字interface，可以从类的实现中抽象一个类的接口，指定一个类必须做什么，而不是规定它如何去做。通过interface关键字，Java允许你充分利用多态性的“一个接口，多个方法”。
通常，为使一个方法可以在类间调用，两个类都必须出现在编译时间里，以便Java编译器可以检查以确保方法是兼容的。这导致了一个静态的不可扩展的类环境。接口的设计避免了这个问题。它把方法或方法系列的定义从类层次中分开。因为接口是在和类不同的层次中，与类层次无关的类实现相同的接口是可行的。
接口增加了很多应用程序所需的功能，而在C++中，这些功能通常借助于多重继承来完成。
当实现一个接口方法时，它必须声明成public。
如果一个类包含一个接口但是不完全实现接口定义的方法，那么该类必须定义成abstract型。
接口可以被其他接口继承。

30. Java异常处理通过5个关键字控制：try、catch、throw、throws、finally。
如果一个方法可以导致一个异常但不处理它，它必须指定这种行为以使方法的调用者可以保护他们自己而不发生异常。要做到这点可以在方法声明中包含一个throws子句。
finally创建一个代码块。该代码块在一个try/catch块完成之后另一个try/catch出现之前执行。finally块无论有没有异常引发都会执行。

31. Java通过两种方式来创建线程：实现Runnable接口或继承Thread类。

32. Java线程同步的关键是管程（也叫信号量semaphore），是一个互斥独占锁定的对象，或称互斥体（mutex）。这是core java中的描述，怎么这么奇怪？信号量怎么是互斥体了？
线程进入某一对象的管程，就是调用被synchronized关键字修饰的方法。
Java包含了通过wait()，notify()，notifyAll()方法实现的一个进程间通信机制，这些方法在对象中是用final方法实现的，所有的类都含有他们。但仅在synchronized方法中才能被调用。
wait()：告知被调用的线程放弃管程进入睡眠直到其他线程进入相同管程并且调用notify()。
notify()：回复相同对象中第一个调用wait()的线程。
notifyAll()：回复形同对象中所有调用wait()的线程，具有最高优先级的线程最先运行。
suspend()：暂停。
resume()：再启动。
stop()：终止。
注意：Thread中定义的suspend、resume、stop不能用于新版本的Java2。因为suspend有时会造成严重的系统故障，比如对关键数据结构的一个线程被锁定的情况，如果该线程在那里挂起，其他等待这些资源的线程可能死锁。而resume不能离开suspend独立使用。sop也可能导致严重的系统故障，比如在写一个精密的重要的数据结构且未完成时被stop，则数据结构可能会停留在崩溃状态。
所以，线程必须被设计以使run()方法定期检查以来判定线程是否应该被挂起，回复或者终止它自己的执行。这由创建一个指示线程状态的标志变量来完成：running、suspend、stop。

33. 流：Java程序通过流来完成I/O。流是生产或消费信息的抽象（就是输入输出的抽象吧？）。Java2定义了两种类型的流：字节流和字符流。
Java中所有的文件都是字节形式的。

34. ransient：如果用rransient声明一个实例变量，当对象存储时，它的值不需要维持。
volatile：告诉编译器被volatile修饰的变量可以被程序的其他部分改变。

35. instanceof：在运行时间内判断对象类型。

36. strictfp：用strictfp修饰类或方法，可以确保浮点运算（以及所有切断）以较快速度进行，正如它们在早期Java版本中那样准确。当一个类被strictfp修饰，所有该类的方法都自动被strictfp修饰。

37. 本机代码：CPU或者工作环境的执行代码。
native：Java被编译为字节码，由Java运行时系统解释，所以在Java中调用本机代码子程序就要用到native。
声明为本机方法后，必须编写本机方法并执行一系列复杂的步骤使它与Java代码连接。典型的机制是调用C代码的JNI（Java Native Interface）。
本机代码的两个严重问题：潜在的安全隐患，因为它不受Java执行环境的限制。丧失了可移植性。

38. 简单类型包装器（Number、Double、Float…）：为什么需要？因为简单数据类型不是对象层次结构的组成部分，它们通过值传递给方法而不能直接通过引用传递，而且也没有办法是两种方法对整形（int）引用同一实例。有时候需要对简单类型建立对象表达式，所以简单类型包装器就出现了。

39. 类集：对应C++中的容器这个概念。

40. Java自省：允许在运行时而不是在编译时分析一个软件组件并且动态的描述它的功能。

41. Java Bean：是一个软件组件，被设计成可以在不同的环境里重复使用。
Bean开发工具包（Bean Develpoer Kit， BDK）：是一个简单工具可以用来创建、配置、连接一组Bean。

42. JAR（Java存档文件）：一个JAR文件可以装入一组类及它们的相关资源。JAR文件中的组件可以附带数字签名。

43. 内省（Introspection）：是分析一个Bean确定其功能的过程。内省机制允许应用开发工具将一个组件的信息提供给软件设计者。

44. Swing：一个新的可以替代AWT的图形界面类。

45. Java摈弃的C++内容：
(1) Java不包含结构和联合。
(2) Java不支持操作符重载。
(3) Java不包含预处理。
(4) Java不支持自动的类型转换。
(5) Java的代码必须封装在类中，不包含所谓的全局变量或全局函数。
(6) Java不允许默认参数。
(7) Java不支持多重继承。
(8) Java不支持析构函数。但增加了finalize函数。
(9) Java不支持typedef。
(10) Java不能声明无符号整数。
(11) Java不支持goto。
(12) Java不支持delete操作符。
(13) Java中的<<and>>不重载I/O操作。
(14) Java中的对象只能由引用传递。

46. Java的新特性：多线程、包、接口。
Java新增文档注释，格式是：/**  …   */

47. Java的文档注释。

48.在Java中，逗号仅仅是一个分隔符，只适用于for循环；而C++中逗号是一个运算符，可以在任何表达式中使用。

49.如下函数，表示个数可变的参数,但是用作数组.
例如定义:
static void x(int... aaa) {
  for (int i : aaa) {
  System.out.println(i);
  }
}
这里调用aaa就是数组.
调用x的时候,就可以说:
x(1) x(1, 2) x(3, 2, 1) 都可以.这就是参数个数可变的意思.

50.J2SE 5.0新增了foreach的语法，又称强化的for循环(Enhanced for Loop)，其应用的对象之一是在数组的依次存取上。
foreach语法如下：for(type element : array) {System.out.println(element)...}

在J2SE 5.0之前可以使用以下的方式来依次存取数组中的元素：
int a[] = {1, 2, 3, 4};
for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}

在J2SE 5.0中可以使用新的foreach语法，这么写：
int a[] = {1, 2, 3, 4};
for (int element : a) {
System.out.println(element);
}