C++与Java异同
1、指针★★★★★
C C++中的指针，提供了很大的灵活性，但是灵活也带来了危险，对指针操作的不当容易造成内存泄露或是空悬指针等问题。
Java取消了指针。但实际上，java中声明的所有引用数据类型的名称，可以理解为就是一个指针。该名称存储在栈内存上，指向对内存上使用new开辟的空间。
如：
int[] array = new int[10]
整型数组名array在栈内存上，在堆内存上开辟了10*4字节的空间，用array指向该块内存。
可以把array理解为一个指针，里面存放的地址就是new出来的空间。
如：
class Person{
……
}
Person p = new Person() ;
对象名p开辟在栈内存，用new为对象在堆内存开辟空间，对象名p指向该堆内存。
但实际上呢，该名称并不像C++中的指针，特别是在进行参数传递的时候。
java已经声明：参数传递都是值传递。
但是当引用数据类型作为函数参数的时候，把一个已声明的对象p1传进来的时候，其实是产生了一个该对象的副本p2，这个p2指向p1，所以通过p2调用p1的成员时，可以完成修改，等函数调用结束，保留修改。如：
class Person{
public String name ;
public int age ;
public Person(String name ,int age){
this.name = name ;
this.age = age ;
}
}
public class Test{
public static void main(String[] args){
Person p = new Person("张三" , 10) ;
System.out.println("修改前-->姓名："+ p.name+"，年龄："+p.age) ;
changePro(p) ; //对象p传进来，这时产生p的一个副本，假设是p1，它指向p。 //通过这个副本p1，可以调用p的成员。
System.out.println("修改后-->姓名："+ p.name+"，年龄："+p.age) ;
}
public static void changePro(Person p){ //通过副本可以调用原对象的成员
p.name = "李四" ;
p.age = 30 ;
}
}
结果：
修改前-->姓名：张三，年龄：10
修改后-->姓名：李四，年龄：30
但当你把p1传进来之后，产生副本p2，然后试图通过p2来改变p1的指向，显然是不可能的，这时改变的仅仅是p2的指向，函数调用结束之后，p1的指向不变。如：
class Person{
public String name ;
public int age ;
public Person(String name ,int age){
this.name = name ;
this.age = age ;
}
}
public class Test{
public static void main(String[] args){
Person p = new Person("张三" , 10) ;
System.out.println("修改前-->姓名："+ p.name+"，年龄："+p.age) ;
changeObj(p) ; //对象p传进来，这是产生p的一个副本，假设是p1，它指向p。 //在函数中，改变的只是这个副本的指向。
System.out.println("修改后-->姓名："+ p.name+"，年龄："+p.age) ;
}
public static Person newP = new Person("李四", 30) ;
public static void changeObj(Person p){
p = newP ; //企图改变指向，实际改变的是副本的指向，
//函数结束后，原对象的指向不会改变
}
}
结果：
修改前-->姓名：张三，年龄：10
修改后-->姓名：张三，年龄：10
2、内存动态分配
C++中使用new和delete进行内存的动态分配和回收，new是在堆内存上开辟空间，内存使用完毕之后，必须手动使用delete来回收。
Java中只要是声明了引用数据类型，在使用之前，必须使用new进行内存空间的开辟。但是在对象消亡之后，不用手工的进行内存回收。Java自有的内存回收机制会自动回收垃圾对象（所谓垃圾对象，是指之前开辟的对象内存，不再被栈内存所引用了）。当然也可以通过System.gc()方法进行手工的回收。
3、析构函数
C++析构函数（无参，无返回值）的作用是释放à构造函数中动态分配的内存空间，即调用（此调用可以通过对象．析构函数调用，也可以等对象生存期结束时系统自动调用）析构函数。
Java中没有析构函数，通过垃圾回收机制，自动回收垃圾对象。不过可以通过覆写Object类中的fanalize()方法，实现与C++中析构函数一样的效果，当手动或自动销毁对象时，会自动调用fanalize()方法。
4、空类中的内容
C++的空类一定还有4个函数：默认构造函数，默认析构函数，默认拷贝构造函数，
Java的空类中有：默认构造函数，从Object类继承来的方法，如
类中默认属性C++类中的成员访问权限三种：public>protected>private。不声明的话，默认为private权限。
Java类中的成员访问权限四种：public>protected>defalt>private。默认是default权限。
5、类中成员函数的实现
C++中是习惯在．h头文件的类中声明函数；在类外的．cpp文件中实现函数，要#include头文件。
如：
//demo.h
Class Person{
Public:
Void fun() ; //类中声明
}
//demo.cpp
#include “demo.h”
Void Person ：：fun(){ //类外实现
。。。。//实现体
}
Java是类中声明+实现方法。如果不在类中实现，再加上abstract关键字就是抽象方法了。
如：
class Person{
Public void fun(){//类中声明+实现
。。。。//实现体
}
}
6、对象的实例化
class Person{
private ：
int age ;
public ：
Person(){}
Person(int a){
age = a ;
}
void fun(){….}
}
。。。。 //主函数开始
Person p1 ; //调用的是无参的构造函数
Person p2(18) ; //调用带参构造函数
p1.fun() ; //调用成员函数
p2.fun() ;
java中实例化对象，必须使用new关键字。
class Person{
private String name ;
private int age ;
public Person(){}
public Person(String name, int age){
this.name = name ;
this.age = age ;
}
public void fun() {…..}
}
。。。。。//主函数开始
Person p1 = null ;
p1 = new Person() ; //必须使用new关键字开辟内存空间，调用无参构造。
Person p2 = new Person(“张三”, 18) ; //调用带参构造。
p1.fun() ; //调用方法
p2.fun() ;
7、This关键字
C++中叫this指针，实例化一个对象时，会默认产生一个this指针指向这个对象，作用是编译器用来区别同一类的不同对象。即当对象．成员函数时，通过this指针知道是哪个对象，调用成员函数来操作该对象的成员属性。
Java中this有3个用途：
1、表示本类中的属性或方法。如this．方法，this．属性。
2、表示当前对象。
3、调用本类的构造方法。如this()，this(参数1,参数2.。。。)。
【其中用途1、2的作用类似C++中的this指针。】
8、对象成员的调用
C++通过对象．成员函数，或是类指针->成员函数来调用。
Java中只能通过对象．成员函数调用。
二者中Static属性的成员，可以直接通过类名．成员函数直接调用。
9、子类-->父类,构造函数的传参
共同点：子类中的构造函数如果不明确指出调用父类的哪个构造函数时，系统默认去调用父类的无参构造函数。同时，如果父类中自己定义了带参的构造函数，最好再定义一个无参的构造函数。
class Person{
private ：
int age ;
public ：
Person(){}
Person(int a){
age = a ;
}
}
class Student ：public Person{
private ：
int score ;
public ：
Student(int a, int s) ：Person(a){ //向父类构造函数传递
score = s ;
}
}
class Person{
private String name ;
private int age ;
public Person(){}
public Person(String name, int age){
this.name = name ;
this.age = age ;
}
}
class Student extends Person{
private int score ;
public Student(String name, int age, int score){
super(name,age) ; //向父类构造函数传递
this.score = score ;
}
}
10、多态性
C++中的多态性必须靠【虚函数或纯虚函数+子类对虚函数或纯虚函数的覆盖】实现。
虚函数用virtual声明，
如：
virtual void fun() ；//类内声明
void 类名 ：fun() {….}//类外实现
Java通过子类对普通父类中普通方法的覆写、子类对抽象类中普通方法或抽象方法的覆写、子类对接口中抽象方法的覆写。+向上转型。
抽象方法用abstract声明，且没有内容实现。
如：
abstract void fun() ; //类内无实现
11、抽象类
二者的抽象类都不能实例化对象。纯虚函数和抽象方法概念类似，作用类似。
C++中也可以说有抽象类，带有纯虚函数的类。
纯虚函数是没有内容实现，且带有“=0”的虚函数，不能实例化对象。
如：
virtual void fun() = 0 ; //类内声明为=0，类外也不实现。
Java中的抽象类是用abstract关键字声明的类，其中包含了抽象方法。不能实例化对象。
Java中的接口是一种特殊的类，或者说一种特殊的抽象类。是由全部的静态常量和抽象函数构成。
12、访问权限
C++通过3种继承方式来改变子类与父类间成员的访问权限。
class Student ：public Person{
public ：
。。。。。。
Private ：
。。。。。。
}；
class worker ：protected Person{
public ：
。。。。。。
Private ：
。。。。。。
}；
Class farmer ：private Person{
public ：
。。。。。。
Private ：
。。。。。。
}；
Java通过包机制实现不同类之间成员的访问权限。
Package org.tyut.a
class Person{
private …..
private ……
public …….
public ……
}
package org.tuyt.b
class Person{
private …..
private ……
public …….
public ……
}
package org.tuyt.c
class Person{
private …..
private ……
public …….
public ……
}
13、C++预处理&java导入包
二者的思路是一样的：想使用当前类以外的类时，
C++中，在类定义前使用#include预编译指令，将要包含的类库包含进来。
标准类库用尖括号< >，不带h。自定义类库用双引号“”，带h，会先从当前路径查找。
如：
#include <iostream>
#include “demo.h”
Java中，将要使用的类导入进来，使用import命令，要注明类所在的包。
如：
imort java．Lang．* ；
import org．tyut．* ；
