C++ 和java的不同点

1）类的静态成员变量访问问题

c++ 非静态的成员函数不能访问静态成员，而java可以；

静态变量和静态方法既可以在类的实例方法中使用，也可以在类的静态方法中使用；但是，实例变量和实例方法只能在实例方法中使用，不能在静态方法中使用；

因为静态变量和静态方法不属于某个特定的对象。

 

#include "stdafx.h"

class A
{
public:
A(){

}

static int getCount(){
return count;
}

protected:
private:
static int count;
};

int A::count=2;

int _tmain(int argc, _TCHAR* argv[])
{
A aa;

printf("count=%d\n",A::getCount());

return 0;
}

 

2）函数的参数传递

函数形参和实参 怎么传递？

 

java:

当传递基本数据类型参数时，传递的实参的值，在这种情况下，形参的改变并不会影响实参的值；

传递引用类型的参数时，传递的是对象的引用，引用上的传值在语义上最好描述为传共享(pass-by-sharing);也就是说，在

方法中引用的对象和传递的对象是一样的。 传引用，比如String；

void convert(String src,String dest) 

{

         dest="hello";

}

 

在函数内对dest重新赋值，不会改变实参，如果需要改变实参，在传引用的情况，只有改变对象指向的内容；

 

而对于C++ 可以通过应用，从函数中带出信息；

比如：

void convert(const std::string src,std::string &dest)

{

       //

 

}

这样在函数中改变dest，是可以改变实参的值的；事实上，java中只有值传递，没有引用传递，传递对象，是对象的拷贝，改变的是对象里面的内容。所以看起来像C++的引用传递。

 

 http://www.codeceo.com/article/top-10-online-compiler.html

3)java中为什么要把main方法定义为一个static方法？而C++没有？

  （1）在类中，变量的前面有修饰符static称为静态变量（类变量），方法的前面有修饰符static称为静态方法（类方法）。静态方法和静态变量是属于某一个类，而不属于类的对象。

  （2）静态方法和静态变量的引用直接通过类名引用。

例如：类Point中有个 static int x;类变量，我们要引用它：Point.x=89;

  （3）在静态方法中不能调用非静态方法和引用非静态的成员变量。反之，则可以。

原因：静态变量和静态方法在类被加载的时候就分配了内存空间，当非静态的方法调用他们的时候，他们已经有了内存空间，当然是可以调用的咯！

  （4）可以用类的对象去调用静态的方法。   

    我们知道，在C/C++当中，这个main方法并不是属于某一个类的，它是一个全局的方法，所以当我们执行的时候，c++编译器很容易的就能找到这个main方法，然而当我们执行一个java程序的时候，因为java都是以类作为程序的组织单元，当我们要执行的时候，我们并不知道这个main方法会放到哪个类当中，也不知道是否是要产生类的一个对象，为了解决程序的运行问题，我们将这个main方法定义为static，这样的话，当我们在执行一个java代码的时候，我们在命令提示符中写：java Point（Point为一个类），解释器就会在Point这个类当中，去调用这个静态的main方法，而不需要产生Point这个类的对象，当我们加载Point这个类的时候，那么main方法也被加载了，作为我们java程序的一个入口。

4）C++和Java的 非静态函数可以访问静态函数，而反过来 不行 ，在C++中静态成员函数需要访问非静态成员，需要传递 this指针；

C++的非静态函数 可以通过类名和类的对象访问，通过对象访问其实就是通过类名访问；

5) Java类成员的四种访问权限

Java中的访问权限控制符有四个. 
作用域         当前类          同一package           子孙类                其他package 
public              √                    √                           √                             √ 
protected         √                    √                            √                            × 
friendly            √                    √                            ×                            × 
private             √                     ×                            ×                             × 

没有时默认为friendly，如构造函数等~这个和C++是不同的，C++默认是私有的，类外无法访问，而java是friendly，在当前类和同一个包内都可以访问。

 
在Java语言中有4种访问修饰符：package（默认）、private、public和protected.
1。package是默认的保护模式，又叫做包访问，没有任何修饰符时就采用这种保护模式。包访问允许域和方法被同一个包内任何类的任何方法访问。（包内访问）
2。private标识的访问模式，表示私有的域和方法只能被同一个类中的其他方法访问，实现了数据隐藏；必要时，可以通过方法访问私有变量。（类内访问）
3。public修饰符用于暴露域和方法，以便在类定义的包外部能访问它们。对包和类中必要的接口元素，也需要使用这个级别；main()方法必须是public的，toString()方法也必须是public的。一般不会用public暴露一个域，除非这个域已经被声明为final。（跨包访问）
4。protected修饰符提供一个从包外部访问包（有限制）的方法。在域和方法前增加protected修饰符不会影响同一个包内其他类和方法对它们的访问。要从包外部访问包（其中含有protected成员的类），必须保证被访问的类是带有protected成员类的子类。也就是说，希望包中的一个类被包之外的类继承重用时，就可以使用这个级别。一般应该慎用。（包中类被包外类继承重用）。

6）java支持C++类似的STL吗？Java中Vector和ArrayList的区别

      首先看这两类都实现List接口，而List接口一共有三个实现类，分别是ArrayList、Vector和LinkedList。List用于存放多个元素，能够维护元素的次序，并且允许元素的重复。3个具体实现类的相关区别如下：

ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。

Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。

LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

     查看Java源代码，发现当数组的大小不够的时候，需要重新建立数组，然后将元素拷贝到新的数组内，ArrayList和Vector的扩展数组的大小不同。

java ArrayList和LinkedList的区别参考如下链接。 http://pengcqu.iteye.com/blog/502676
 7）java和C++ 数组的区别

JAVA里数组的内存分配是在堆里面的，必须用new来分配，而C++里面是在栈里面分配的，定义的时候会自动分配。

java中的数组

1、数组不是集合，它只能保存同种类型的多个原始类型或者对象的引用。数组保存的仅仅是对象的引用，而不是对象本身。数组声明的两种形式：一、int[] arr; 二、int arr[];  推荐使用前者，这是一个int数组对象，而不是一个int原始类型。

2、数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

4、在数组声明中包含数组长度永远是不合法的！如：int[5] arr; 。因为，声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。

5、在数组构造的时候必须指定长度，因为JVM要知道需要在堆上分配多少空间。例：int[] arr = new int[5];

7、一维数组的构造。形如：String[] sa = new String[5];  或者分成两句：String[] sa;  sa = new String[5];

8、原始类型数组元素的默认值。对于原始类型数组，在用new构造完成而没有初始化时，JVM自动对其进行初始化。默认值：byte、short、 int、long--0  float--0.0f double--0.0  boolean--false  char--'"u0000'。（无论该数组是成员变量还是局部变量）

10、对象类型的数组虽然被默认初始化了，但是并没有调用其构造函数。（C++中则会调用）也就是说：Car[] myCar = new Car[10];只创建了一个myCar数组对象！并没有创建Car对象的任何实例！

11、多维数组的构造。float[][] ratings = new float[9][]; 第一维的长度必须给出，其余的可以不写，因为JVM只需要知道赋给变量ratings的对象的长度。

12、数组索引的范围。数组中各个元素的索引是从0开始的，到length-1。每个数组对象都有一个length属性，它保存了该数组对象的长度。（注意和String对象的length()方法区分开来）

13、Java有数组下标检查，当访问超出索引范围时，将产生ArrayIndexOutOfBoundsException运行时异常。注意，这种下标检查不是在编译时刻进行的，而是在运行时！也就是说int[] arr = new int[10];  arr[100] = 100; 这么明显的错误可以通过编译，但在运行时抛出！

Java中的数组中既可以存储基本的值类型，也可以存储对象。对象数组和原始数据类型数组在使用方法上几乎是完全一致的，唯一的差别在于对象数组容纳的是引用而原始数据类型数组容纳的是具体的数值。在讨论关于数组的问题时，一定要先确定数组中存储的是基本值类型还是对象。特别是在调试程序时，要注意这方面。

8)

Java中的抽象函数与C++中的虚函数 转自：http://www.cnblogs.com/yhlx/articles/2177756.html

1：java中没有虚函数的概念，但是有抽 象函数的概念，用abstract关键字表示，java中抽象函数必须在抽象类中，而且抽象 函数不能有函数体，抽象类不能被实例化，只能由其子类实现抽象函数，如果某个抽象类的子类仍是抽象类，那么该子类不需要实现其父类的抽象函数。

2：C++中的有虚函数的概念，用virtual 关键字来表示，每个类都会有一个虚函数表，该虚函数表首先会从父类中继承得到父类的虚函数表， 如果子类中重写了父类的虚函数（不管重写后的函数是否为虚函数），要调用哪个虚函数，是根据当前实际的对象来判断的（不管指针所属类型是否为当前类，有可 能是父类型），指针当前指向的是哪种类型的对象，就调用哪个类型中类定义的虚函数。每个类只有一张虚拟函数表，所有的对象共用这张表。

C++的函数多态就是通过虚函数来实现的。

3：C++中，如果函数不是虚函数，则调用某个函数，是根据当前指针类型来判断的，并不是根据指针所指向对象的类型。

4：Java中，如果函数不是抽象函数，而是一个普通函数，它是默认实现类似C++中虚函数功能的，也就是说，调用某个函数，是根据当前指针所指向对象的类型来判断的，而不是根据指针类型判断。正好与C++中的普通函数相反。即：JAVA里自动实现了虚函数。

C++ Java

虚函数 -------- 普通函数

纯虚函数 -------- 抽象函数

抽象类 -------- 抽象类

虚基类 -------- 接口

纯虚函数： 主要特征是不能被用来声明对象,是抽象类,是用来确保程序结构与应用域的结构据具有直接映射关系的设计工具。带有纯虚函数的类称为抽象类，抽象类能被子类 继承使用，在子类中必须给出纯虚函数的实现，如果子类未给出该纯虚函数的实现，那么该子类也是抽象类，只有在子类不存在纯虚函数时，子类才可以用来声明对 象！抽象类也能用于声明指针或引用，或用于函数声明中。具有抽象类特性的类还有构造函数和析构函数，全部是保护的类。如果没有给出纯虚函数的实现，则在它 所在的类的构造函数或析构函数中不能直接或间接的调用它。纯虚函数的实现可以在类声明外进行定义。

5. C++中一般都是把析构函数声明为虚函数。因为虚函数可以实现动态绑定，也就是到底调用哪个函数是根据指针当前指向哪个对象来确定的，不是根据指针的类型 来确定。如果C++中不把析构函数声明为虚函数，那么其有个子类，重写了虚函数，那么当父类指针指向一个子类对象时，当调用析构函数时，只调用父类的析构 函数，而无法调用子类的析构函数，所以一般情况是把析构函数声明为虚函数，实现动态绑定。当然如果一个类不包含虚函数，这经常预示不打算将它作为基类使 用。当一个类不打算作为基类时，将析构函数声明为虚拟通常是个坏主意。

标准 string 类型不包含虚函数，如果把String作为基类继承得到子类会出问题。

总之：多态基类应该声明虚析构函数。如果一个类有任何虚函数，它就应该有一个虚析构函数；如果不是设计用于做基类或不是设计用于多态，这样的类就不应该声明虚析构函数。

 9)java 串口通信问题

    java串口通有有一个RXTX库，下载链接如下：

 http://fizzed.com/oss/rxtx-for-java

10)eclipse 使用常见问题

10.1）eclipse 中找不到design界面了

在代码中点右键，选择菜单Open with，然后点击熟悉的WindowsBuilder Editor

11）C++ lambda 表达式 

代码如下:

#include<iostream>

using namespace std;

 

int main()

{

    int a = 1;

    int b = 2;

 

    auto func = [=, &b](int c)->int {return b += a + c;};

    return 0;

}

当我第一次看到这段代码时，我直接凌乱了，直接看不懂啊。上面这段代码，如果你看懂了，下面的内容就当时复习了；如果看不懂了，就接着和我一起总结吧。

基本语法

简单来说，Lambda函数也就是一个函数，它的语法定义如下：

复制代码代码如下:

[capture](parameters) mutable ->return-type{statement}

1.[capture]：捕捉列表。捕捉列表总是出现在Lambda函数的开始处。实际上，[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数。捕捉列表能够捕捉上下文中的变量以供Lambda函数使用;

2.(parameters)：参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号“()”一起省略;

3.mutable：mutable修饰符。默认情况下，Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）;

4.->return-type：返回类型。用追踪返回类型形式声明函数的返回类型。我们可以在不需要返回值的时候也可以连同符号”->”一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导;

5.{statement}：函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

与普通函数最大的区别是，除了可以使用参数以外，Lambda函数还可以通过捕获列表访问一些上下文中的数据。具体地，捕捉列表描述了上下文中哪些数据可以被Lambda使用，以及使用方式（以值传递的方式或引用传递的方式）。语法上，在“[]”包括起来的是捕捉列表，捕捉列表由多个捕捉项组成，并以逗号分隔。捕捉列表有以下几种形式：

1.[var]表示值传递方式捕捉变量var；

2.[=]表示值传递方式捕捉所有父作用域的变量（包括this）；

3.[&var]表示引用传递捕捉变量var；

4.[&]表示引用传递方式捕捉所有父作用域的变量（包括this）；

5.[this]表示值传递方式捕捉当前的this指针。

上面提到了一个父作用域，也就是包含Lambda函数的语句块，说通俗点就是包含Lambda的“{}”代码块。上面的捕捉列表还可以进行组合，例如：

1.[=,&a,&b]表示以引用传递的方式捕捉变量a和b，以值传递方式捕捉其它所有变量;

2.[&,a,this]表示以值传递的方式捕捉变量a和this，引用传递方式捕捉其它所有变量。

不过值得注意的是，捕捉列表不允许变量重复传递。下面一些例子就是典型的重复，会导致编译时期的错误。例如：

3.[=,a]这里已经以值传递方式捕捉了所有变量，但是重复捕捉a了，会报错的;

4.[&,&this]这里&已经以引用传递方式捕捉了所有变量，再捕捉this也是一种重复。