1. 饰变量：final变量是不可改变的，但它的值可以在运行时刻初始化，也可以在编译时刻初始化，甚至可以放在构造函数中初始化，而不必在声明的时候初始化，所以下面的语句均合法：

   final int i = 1; // 编译时刻
   final int i2 = (int)(Math.Random() * 10); //运行时刻
   final int i3; //构造函数里再初始化
   

   final经常和static一起用，这种用法类似C++的常量，在Java中很常见，比如 static final i = 10;但这里同样也是允许运行时刻初始化的。

2. 修饰类对象：而如果修饰类对象，并不表示这个对象不可更改，而是表示这个这个变量不可再赋成其它对象，这就比较像 C++的 Class const * p了(这样表明这个指向该Class的指针p不能再指向其他对象，指针常量，但是该对象中的值是可以修改的(const Class *p 是常量指针，任何成员变量都不能修改))。

   final Value v = new Value(); 
   v = new Value(); //不允许！ 
   v.some_method(); //允许
   

3. 修饰方法：final修饰的方法是不能被重载的，类似于类中的private方法，所以private方法默认是final的；大致说就是变量不可修改（基本数据类型值不能修改，类类型引用不能修改），方法不可重载，类不可继承，

C++中final只有两种：

1. 修饰类

2. 修饰虚函数

C++中const：

C++中的const用处很多，包括常量声明、变量修饰、常量引用、指针与const的组合、以及常量对象、成员函数。

修饰变量(基本类型变量、成员变量)：

• 修饰基本类型变量

  修饰变量也可以叫作常量的声明，使用const关键字可以修饰变量，一旦初始化后就不能再修改其值。

  const int MAX = 123;
  const double PI = 3.14;
  const int x = 334;
  

  以上的MAX、PI、x将都不能再修改其值；

  const定义的常量和#define宏定义的常量的区别

  const常量有数据类型，define宏定义常量没有，编译器会对const常量可以进行数据类型的安全检查，但是对于define宏定义，编译器只是将其进行字符替换，这样的字符替换很容易出错。

  比如以下代码，如果使用不加括号的宏定义，将不能正确计算(a+b)/5.0，而是变成计算a+(b/5.0)了。

  //define宏定义的做法
  #define a 2.0
  #define b 9.0
  #define c1 a+b   //不好的定义方法
  #define c2 ((a)+(b))  //推荐的定义方法
  void func1(void)
  {
      float d1 = c1/5.0;  //本意是想计算(a+b)/5.0，但字符替换使计算变成了a+b/5.0
      float d2 = c2/5.0;  //正确计算了((a)+(b))/5.0 = (a+b)/5.0
  }
  
  
  //推荐的const常量的做法
  const float a = 2.0;
  const float b = 9.0;
  const float c = a + b;
  void func2(void)
  {
      float d = c/5.0;  //正确计算了(a+b)/5.0
  }
  

• 修饰成员变量：在类中，使用const修饰的成员变量只能在初始化列表中进行初始化，并且不能在构造函数中修改其值。

  class MyClass {
  public:
      const int x;
      MyClass(int value) : x(value) {} // 初始化const修饰的成员变量
  };
  

  这段代码定义了一个类MyClass，其中有一个const修饰的整型成员变量x。在构造函数的初始化列表中对x进行初始化，且只能在初始化列表中初始化，不能在构造函数内部修改其值。

const与引用：

const引用可以绑定到临时对象或字面量，延长其生命周期。

用这种方式声明的引用，不能通过引用对目标变量的值进行修改,从而使引用的目标成为const，达到了引用的安全性。

const int& ref = 10; // 合法
// int& ref2 = 10;   // 非法：非常量引用不能绑定字面量
int x = 10;
const int& a = x;
x = 5;

const与指针："const在*前，数据不能改，const在*后，指针不能改"

• 常量指针：

  形式：const type* ptr(推荐) 或 type const* ptr

  这里可以理解为 const修饰的是type类型的数据：(const type)* ptr 或 (type const)* ptr，也就是说不能通过ptr修改值，但ptr可以指向其他地址。

  int a = 10, b = 20;
  const int* ptr = &a;
  *ptr = 30; // 错误：不能修改指向的数据
  ptr = &b;  // 正确：可以改变指针指向
  

  "const在*前，数据不能改"

• 指针常量：

  形式：type* const ptr

  这里可以理解为const修饰的是ptr：也就是说ptr一旦初始化指向之后就不能指向其他地址，但可以通过指针修改所指向的数据。

  int a = 10, b = 20;
  int* const ptr = &a;
  *ptr = 30; // 正确：可以修改a的值
  ptr = &b;  // 错误：不能改变指针指向
  

  "const在*后，指针不能改"

• 指向常量 的 常量指针：

  形式：const type* const ptr 或type const* const ptr

  既不能修改指针指向，也不能通过指针修改数据。

  int a = 10, b = 20;
  const int* const ptr = &a;
  *ptr = 30; // 错误
  ptr = &b;  // 错误
  

const在函数中的应用：

• const形参：避免函数内意外修改参数，常用于指针或引用传参。

  void print(const int* arr, int size) {
      for (int i = 0; i < size; ++i)
          std::cout << arr[i] << " "; // 只读访问
  }
  

• const成员函数：const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改。

  class MyClass {
      int value;
  public:
      int getValue() const { return value; } // 不会修改对象状态
  };