关于cpp之类与JAVA中类的相似

C++与JAVA：

先丢出一个写有class的头文件：

// stock00.h -- Stock class interface
#ifndef STOCK00_H_
#define STOCK00_H_
#include <string>  
class Stock {
	private:
		std::string company;
		long shares;
		double share_val;
		double total_val;
		void set_tot() {
			total_val = shares * share_val;
		}
	public:
		void acquire(const std::string& co, long n, double pr);
		void buy(long num, double price);
		void sell(long num, double price);
		void update(double price);
		void show();
};
#endif ←

C++的抽象：以上C++类是放在一个.h的头文件中，C++中，class的定义一般是放在单独的.h头文件中，并且都是抽象方法，所以还需要一个实现方法的.cpp文件，这个可以对应JAVA中的抽象——接口interface/抽象abstract，也是需要一个.java文件去实现接口/抽象方法。

C++访问控制：private、protected、public和JAVA里面意义一模一样：private成员或方法只有此类实例的public方法才能访问。就像JAVA中经常提供public的getter/setter方法供访问/修改private成员一样。只是在C++中默认不写就是private修饰，在C++结构中，默认不写就是public。

再看以上抽象代码的实现代码：

// stock00.cpp -- implementing the Stock class
#include <iostream>
#include "stock00.h"
void Stock::acquire(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		std::cout << "Number of shares can't be negative; "
			<< company << " shares set to 0.\n";
		shares = 0;
	}
	else
		shares = n;
	share_val = pr;
	set_tot();
}
void Stock::buy(long num, double price) {
	if (num < 0) {
		std::cout << "Number of shares purchased can't be negative. "
			<< "Transaction is aborted.\n";
	}
	else {
		shares += num;
		share_val = price;
		set_tot();
	}
}
void Stock::sell(long num, double price) {
	using std::cout;
	if (num < 0) {
		cout << "Number of shares sold can't be negative. "
			<< "Transaction is aborted.\n";
	}
	else if (num > shares) {
		cout << "You can't sell more than you have! "
			<< "Transaction is aborted.\n";
	}
	else {
		shares -= num;
		share_val = price;
		set_tot();
	}
}
void Stock::update(double price) {
	share_val = price;
	set_tot();
}
void Stock::show() {
	std::cout << "Company: " << company
		<< "  Shares: " << shares << '\n'
		<< "  Share Price: $" << share_val
		<< "  Total Worth: $" << total_val << '\n';
}

C++实现抽象：(public:) void sell(double price);在.cpp文件中这样去实现：void 类名::sell(double price) {...}（这里类名::相当于命名空间，不然一个.h头文件可能有几个类，如果方法名相同就冲突出问题了），在JAVA中对应public interface JieKou {void sell(double price); }，class JKimpl implements JieKou { void sell(double price) {...} } 或 public abstract ChouXiang { void sell(double price; }，class Spec extends ChouXiang { void sell(double price){...} }

C++创建对象：Stock stock; JAVA:Stock stock = new Stock();

C++对象的访问：用实例+“.”运算符，如:stock.show(); 这和JAVA是一样的。

C++构造函数：构造函数一般就是用来创建对象的。Stock(const string & co, long n, double pr);可以这样初始化Stock food = Stock("World", 250, 1.25);，构造函数可与new一起使用：Stock *pstock = new Stock("World" , 250, 1.25);这时可通过指针来管理该对象。在JAVA中创建对象：Stock food = new Stock("World", 250, 1.25);。C++与JAVA都默认提供了默认构造函数：Stock::Stock() {}; 与 public Stock(){}。关于默认构造函数C++还有些其他的特性和区别，此处不再展开。

C++继承：class RatedStock : public Stock {...}，JAVA继承：class RatedStock extends Stock {...}。对于多重继承原理与格式一样，JAVA可以这样完成多重继承：abstrace class A{}, abstract class B extends A{}, class C extends B。

C++ this关键字：所有的类方法都将this指针设置为调用它的对象的地址，在JAVA中this就是调用它的对象。比如JAVA中常见的public Stock(String name) {this.name = name;}。以上实现代码中void Stock::update(double price){share_val = price;...}就隐藏了this关键字，相当于this->share_val = price;

C++析构函数：C++才有析构函数，释放内存时，其析构函数将自动被调用。在类对象过期时析构函数将自动被调用，因此必须有一个析构函数。如果程序员没有提供析构函数，编译器将隐式地声明一个默认析构函数，并在发现导致对象被删除的代码后，提供默认析构函数的定义。例如可以这样定义类析构函数：Stock::~Stock() {cout << "Bye, " << company << "!\n";}。对于JAVA，有自动垃圾回收机制，如finalize()方法及System.gc()。

C++修改实现：std::cout.setf(std::ios_base::fixed, std::ios_base::floatfield); std::cout.precision(3); 定点表示法并保留3位小数。这其实和JAVA中对对象设置参数性质是一样的，如：
BitmapFactory.Options options = new BitmapFactory.Options(); options.inJustDecodeBounds = true; BitmapFactory.decodeFile(bmFile.getAbsolutePath(), options);

C++静态成员：C++与JAVA的类中如果有静态成员或静态函数，那都是属于类而非某个对象，静态成员函数只能访问静态成员，假如show()方法是静态的：static void Stock::show(){};则调用时直接用类名调用：Stock::show();这与JAVA中Stock.show();一模一样的原理，当然C++或JAVA中的对象也可调用静态show()方法，但有警告，并且调用的结果与用类名直接调用相同。静态成员函数是没有隐形的this指针的，所以静态成员函数里是不能访问非静态成员变量的。

对比一下C++的单例模式与JAVA的单例模式：

JAVA：

public class Singleton {
	private static Singleton sInstance;

	private Singleton () {
	}

	public static Singleton get() {
		if (sInstance == null) {
			sInstance = new Singleton();
		}
		return sInstance;
	}
}

C++：

#include<iostream>
class Singleton {
private:
	static Singleton sInstance;
	Singleton() {};
	Singleton(const Singleton& that) {};
public:
	static Singleton& getInstance() {
		return sInstance;
	}
};
Singleton Singleton::sInstance;

int main() {
	Singleton& s1 = Singleton::getInstance();
	Singleton& s2 = Singleton::getInstance();
	std::cout << "&s1:" << &s1 << ", &s2:" << &s2 << std::endl;
	return 0;
}

C++与结构：

C++对结构进行了扩展，使之具有与类相同的特性。它们之间唯一的区别是，结构的默认访问类型是public，而类为private。

C++初始化Box box(12.3, "盒子"); 结构初始化struct box = {12.3, "盒子"};，它们的初始化方式都相似。

C++程序员通常使用类来实现类描述，而把结构限制为只表示纯粹的数据对象（常被称为普通老式数据（POD，Plain Old Data）结构）。