本人有点c++基础，看了两天《java从入门到精通》，总结java不同点如下，还请高手指教。
相信c++基础好的朋友，比我理解更快，一天学会java不是问题。
过程语法都免了，只讲特征！
1 变量申明：
c++:
int a;
java:
int a = new int();
int b = new int(10);
int[] c = {1, 2};
String str = new String();
String str = "Hello";
Person mm = m;//这里 b 和 bb 使用同一内存，因为没有重新分配空间。所有对象实例是类似c++指针的东西。
int mm = m;//基本类型 int/double 等是复制操作，对象是指针指向操作。
2 继承：
c++:
class Fa
{
int a;
Fa():a(11){};
};
class Child : public Fa{}
java:
public class Fa
{
int a = 11;
Fa(){}
}
public class Child extends Fa{}
3 显式调用父类构造：
c++:
class Fa
{
int m;
Fa():m(0){};
Fa(int a){};
}
class Child: public Fa
{
Child(){};
Child(int a):Fa(a){};
}
java:
public class Fa
{
int m = 10;
Fa(){}
Fa(int a){}
void f(){};
}
public class Child extends Fa
{
int n = 11;
Child(){}
Child(float f)
{
// 调用父类的构造和成员初始化 使用 super
super.m = 20;
super(12);
}
void f()
{
// 调用父类的接口：需要用 super关键字
super.f();
}
}
4 final 关键字
java:
修饰类：
final class A{}//类 A 将不能被继承
修饰方法：
class A
{
final void f(){};// 方法 f()在子类中不能调用，也不能重载
}
修饰变量：此变量不能被修改，必须初始化。
5 abstract 关键字
java:
只要类中有函数使用此关键字，这个类的声明也要加此关键字
abstract public class A
{
abstract f(){}
}
修饰类指得是有抽象方法的类，修饰方法等同于c++的纯虚函数，不能在父类有实现，子类必须有实现
// 含有抽象方法的类，必须定义成抽象类，
// 抽象类不能生成实体对象，但可以用父类类型声明子类对象: Father fa = new Child();
// 调用子类方法：((Child)fa).childFunction();
6 Object 是祖先类，所有类直接或间接继承与该类
Object 类带的方法：
public boolean equals(Object obj)// 可以重载
{
return (this == obj);
}
public String toString() // 可以重载
{
return getClass().getName()+"@"+Integer.toHexString(hashCode());
}
7 接口
接口相当于纯虚类，允许子类多继承(java本身不支持多继承)。
接口修饰：默认修饰：接口所在包之外的类不能使用接口。public 修饰：所有类能够使用接口。
接口声明的变量：自动设置为共有的，静态的，最终的类型。
接口定义的方法：都为抽象，自动设置为 public.
接口的实现：
class 类名1 implements 接口1，接口2
{
void 接口方法1(){}
void 自用方法2(){}
}
如果实现接口的【类名1】不是抽象类，【类名1】需要实现接口1和接口2的所有方法。(与c++继承纯虚函数必须实现一样)
实现接口的【类名1】实现的方法都必须是public,因为接口中的方法都默认是public.
接口可以声明类型，但是对象必须是实体类型，比如：
Animal aa = new Tiger();
@Override 是编辑器添加的伪代码，不是什么神奇语法
接口没有构造函数，只是定义一堆函数框架。
8 内部类
很好理解，就像定义在类中的成员结构体
外部类可以访问内部类方法，但是要单独生成内部类对象。(不是同时生成)
非静态内部类可以访问宿主类的成员，静态内部类必须通过对象来访问：
class Outer
{
int a = 0;
class Inner1 //非静态类
{
int i = 0;
void f()
{
a++;//直接访问外部类成员
}
}
static class Inner2 // 静态类
{
int i = 0;
void f()
{
Outer out = new Outer();
out.a++;//必须生成对象，再调用外部类成员
}
}
void f() // 外部类方法
{
Inner1 i1 = new Inner1();
++i1.i; //操作非静态内部类成员
++Inner2.i; //操作静态内部类成员
}
}
public class Main
{
public static void main() //全局函数
{
Outer o1 = new Outer();
Outer.Inner1 i1 = new Outer().new Inner1(); //非静态声明方法
Outer.Inner2 i2a = new Outer.Inner2(); //静态声明方法
Outer.Inner2 i2b = o1.new Inner2();
}
}
9 局部内部类： 定义在函数中的类，不能在外面生成对象，仅仅在局部使用(不常用)
10 匿名内部类；(少为常用)
public class NoNameInerClass2 {
Constant getConstant(){
return new Constant(5){ //Constant 是匿名类，不用从外面声明，临时声明就可以了
int n=5;
};
}
public static void main(String[ ] args) {
NoNameInerClass2 nnic=new NoNameInerClass2();
System.out.println(nnic.getConstant().n);; // 访问匿名类型的结果
}
}
11 对象克隆：
与 c++ 深度拷贝构造相似，c++ 重载拷贝构造函数，java 用祖先类 Object 的抽象方法 Clonable()，将其实现。
可以重载 Object.clone()方法，也可以使用自定义重载，在方法中需要对所有成员分配新的空间，不要指向旧的对象。
12 其他方面：
eclipse 使用，调试
jvm 环境的熟悉，安装