=======================================================
java与C++的异同点：
相同点：java与C++有类似的语法和控制结构
不同点：java没有预处理器或者文件包含；
没有指针；没有全局变量；
没有结构体和联合体；
所有原始类型（基本类型）有明确大小；
没有操作符重载；
只能单继承；
较好的定义了异常，有些异常处理是强制的；
没有内存泄漏（动态内存管理，垃圾回收机制）；
针对语言和虚拟机设计的安全性:字节码验证；数组访问边界检查；安全管理员/安全策略；
java网络支持性良好；
java有着众多的库；
=======================================================
JVM:
JVM是Java运行时环境（JRE）的一部分；
JVM将Java代码输出为高度优化的字节码，JVM执行字节码；
另外也可以用JIT将字节码编译成机器指令以提升性能；
JIT编译器并不一次性把整个Java程序编译成可执行代码。此外，JIT并不会编译所有的字节码序列，它只编译那些能通过程序编译获得好处的代码，甚至当动态编译字节码时，可移植性和安全特性依然存在，因为JVM仍然控制着执行环境。
========================================================
面向对象设计原则：
单一职责原则（SRP）
就一个类而言，应该仅有一个引起它变化的原因。软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离。
替换原则（LSP）
子类应当可以替换父类并出现在父类能够出现的任何地方。
开闭原则（OCP）
软件实体（类、模块、函数）应该是可扩展的，但是不可修改的。
依赖倒置原则（DIP）
高层模块不应该依赖于低层模块。二者都应该依赖于抽象。
抽象不应该依赖于细节。细节应该依赖于抽象
接口分离原则（ISP）
采用多个与特定客户类有关的接口比采用一个通用的涵盖多个业务方法的接口要好。
=====================================================================
基本类型大小：
boolean: 8 bit, true/false;
char:16 bit;
int:32 bit;
long:64 bit;
short:16 bit;
byte: 8 bit;
float: 32 bit;
double: 64 bit;
===================================================================
int i = 15;
String s = i.toString(); // C# ok, Java error
===================================================================
Different from c#
if ( s1.equals(s2) )
//not like this:
if (s1 == s2)
===================================================================
Java访问修饰符：
http://www.cnblogs.com/Annoying/p/5403957.html
===================================================================
声明static的方法有一些限制：
只能调用其他static方法；
只能访问static数据；
没有this引用；
静态代码块：
在首次载入类时，执行static代码块
===================================================================
final类：使用此修饰符的类不能够被继承
static变量：常量，值只能够分配一次，不能更改；可以同static一起使用，避免对类的每个实例维护一个拷贝；
static方法：防止任何子类重载该方法；可以同static一起使用，避免对类的每个实例维护一个拷贝
===================================================================
enum类型：
作为字符串显示给程序员或用户，而不是数字
enum Bread { wholewheat, ninegrain, rye, french }
public class Hello {
public static void main(String[] args){
Bread todaysLoaf;
todaysLoaf = Bread.rye;
todaysLoaf=Bread.french;
//todaysLoaf =1; //error
System.out.println("bread choice is: " + todaysLoaf);
for (Bread b : Bread.values() ) {
// b iterates through all the Bread
System.out.println("bread type = " + b);
}
Bread myLoaf = Bread.rye;
int price = 0;
switch (myLoaf) {
case wholewheat:
price = 190;
System.out.println(price);
break;
case french: price = 200; break;
default:
System.out.println(myLoaf);
}
}
}
====================================================================
静态导入：
import static java.lang.System.out;
Or import static java.lang.System.*;
//import java.lang.System.out;//error out is static final class
out.println(“Static import example”);
=====================================================================
java没有逗号操作符， 逗号被视为for语句的的一个方面。
for (i=0, j=0; i<10; i++, j++)
=====================================================================
“==”操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同。
equals操作表示的两个变量是否是对同一个对象的引用，即堆中的内容是否相同。
=====================================================================
class Base{
Object fun(){return fun;};
String fun(String s){return s+ " in Base";}
int fun;
};
public class Test extends Base {
int fun(int x){return x;}
String fun(){
System.out.println(super.fun());
Integer myInt=new Integer(fun);
return "Value:"+myInt.toString()+" in Test";
}
public static void main(String []args){
Test t=new Test();
System.out.println(t.fun());
System.out.println(t.fun(2));
System.out.println(t.fun("3"));
System.out.println(t.fun);
}
}
输出结果：
0
Value:0 in Test
2
3 in Base
0
=======================================================================
import java.lang.reflect.Method;
public class Hello {
public void Show() {
System.out.println("Hello World!");
}
public void Show(String str) {
System.out.println(str);
}
public static void main(String[] args) {
try {
Class c=Class.forName("Hello");
Object o=c.newInstance();
Method showMethod=c.getMethod("Show");
showMethod.invoke((Hello)o);
String sShow="Show More Info";
showMethod=c.getMethod("Show",sShow.getClass());
showMethod.invoke((Hello)o,sShow);
}
catch(Exception ee){
ee.printStackTrace(System.out);
}
}
}
输出结果：
Hello World!
Show More Info
======================================================================
java中的数组是对象；
数组是引用类型；
new 就像构造函数；
数组分配在堆中；
数组可以调用Object类的任何方法；
数组不能扩展；
无法为数组定义自己的方法；
数组可以作为方法的参数，void main（String [] args）{...
==================================================================
myArray.length // yes
String have length()
已经定义好的数组可以引用其他相同类型的数组；
==================================================================
Timestamp appts [] = new Timestamp[256];
for (int i=0; i<appts.length; i++) {
appts[i] = new Timestamp();
}
appts[7].hh = 10; // now OK!
==================================================================
数组兼容性：
class Number extends Object { /* more code */ }
class Integer extends Number { /*more code */ }
Number[] na;
Integer [] ia = new Integer[12];
void example(Numbers[] x) {/*more code */}
example(ia);//ok, why?
na = ia;//ok
==================================================================
Fruit orchard[] = new Fruit [] {new Fruit(), new Fruit(4,3), null };
==================================================================
class TestClass {
int x;
TestClass(int val) {
x = val;
}
}
public class Hello {
public static void main(String[] args) {
TestClass arr1[] = { new TestClass(1), new TestClass(2), new TestClass(3) };
TestClass[] arr2 = new TestClass[3];
System.arraycopy(arr1, 0, arr2, 0, 3);
TestClass[] arr3 = (TestClass[]) arr1.clone();
arr1[0].x = 4;
arr1[1] = new TestClass(5);
for (int i = 0; i < 3; i++)
System.out.print(arr1[i].x);
for (int i = 0; i < 3; i++)
System.out.print(arr2[i].x);
for (int i = 0; i < 3; i++)
System.out.print(arr3[i].x);
}
}
输出结果：453423423
================================================================
Java中数组的数组：
底层数组不一定都是一个统一的大小；
int myTable[][] = new int[][] { new int[] {0}, new int[] {0,1}, new int[] {0,1,2}, new int[] {0,1,2,3}, };
int myTable[][] = new int[][] { {0}, {0,1}, {0,1,2}, {0,1,2,3}, };
myTable[0][1] //error
=================================================================
class TestClass {
int x;
TestClass(int val) {
x = val;
}
}
public class Hello {
public static void main(String[] args) {
TestClass arr1[] = { new TestClass(1), new TestClass(2), new TestClass(3) };
TestClass arr2[] = { new TestClass(1), new TestClass(2), new TestClass(3) };
for (TestClass t : arr1)
t = new TestClass(4);
// or t.x=4;
for (int i = 0; i < 3; i++)
arr2[i] = new TestClass(4);
for (TestClass t : arr1)
System.out.print(t.x);
for (int i = 0; i < 3; i++)
System.out.print(arr2[i].x);
}
}
输出结果：
123444
===============================================================
short [] h[], i[], j, k[][];
"j" is an array of short, and "i" is an array of arrays of short
===============================================================
随机数：
double probability = Math.random(); // value 0.0..1.0
===============================================================
终结器：
class Fruit {
protected void finalize() throws Throwable {
}
}
===============================================================
内部成员类：
可以引用（引用）其父项中的任何成员
必须声明一个内部类的实例才能调用它
内部类不是包的一部分，并且在它们嵌套的类之外不可见
===============================================================