就个人银行账户管理程序谈谈C++和Java的异同

4_9

同：

Java和C++都是面向对象的语言。都有数据成员，方法，访问权限的概念。

异：

访问权限上，非private时Java的默认访问权限是包。而C++的默认访问权限是private。Java中：访问权限首先看类前的修饰符，当类的修饰符为public时，

则类可以被所有的类所访问（可以import），当为默认时，

则只能为包中的类所访问。在此前提下，再看属性和方法前的修饰符。类前修饰符为public时，当属性和方法前的修饰符为public时，则该属性可以被所有类访问；当属性和方法前为protected修饰时，对于类定义而言，可以被同包中的类和所有子类访问（子类和父类可以不在同一个包中），也就是B+C范围，但对于对象而言，只能被同一个包的类对象所访问，也就是B的范围；当为默认时，只能被同包中的类所访问（比protected访问权限小）；当为private时，只能被本类内部所访问。
声明访问权限时，C++可以用冒号统一声明，而Java则不行，得一一列举。
Java调用非静态方法和非静态数据成员时，是用对象引用调用的，每个对象引用都需要先new一下，指向对象空间。而C++是用对象实例调用非静态方法和非静态数据成员的。
Java都是一个类为单元，方法和主函数都写在类里面。C++则可以先声明一个类，再在外面具体实现，必须有main函数为入口执行。
Java调用方法和数据成员都是用访问操作符（.）。而C++可以用（.）和（->）。C++中有指针的概念，Java中没有指针的概念。
修饰方法为常量属性时，C++是在方法后加const，如:double accumulate(int date) **const** { return accumulation + balance * (date - lastDate); }。而Java是用final在方法前面添加。如：private **final** double accumulate(int date) { return accumulation + balance * (date - lastDate);}。修饰数据成员为常量属性时，则都在前面添加相应的修饰。
Java每个包的文件名和主类的名字必须相同。而C++则不一定。

5_11

同：

Java和C++类和对象都可以访问静态数据成员和静态方法。

异：

Java中的静态数据成员可以在类中初始化，如果没有初始化，则默认为0；而C++的静态数据成员不能在类中初始化。C++的静态成员函数在类外实现时候无须加static关键字，否则是错误的。
静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；非静态成员函数可以任意地访问静态成员函数和静态数据成员；静态成员函数不能访问非静态成员函数和非静态数据成员；
C++实现自定义多文件，是用include导入，一般用#ifndef DATE_H

define DATE_H，#endif的形式导出。必须导入.h结尾的文件，不过实现可以在一个新的文件中实现。而Java有project、module、package的概念。不同package之间可以通过package a，和import a.类名导入导出实现多文件。导出的类必须声明为public访问权限，否则导出无效，不能被其他文件访问。

6_25

同：

都可以使用对象数组和字符数组。

异：

C++实现对象数组，可以直接用实例对象初始化数组。如：SavingsAccount accounts[] = { SavingsAccount(date, "S3755217", 0.015), SavingsAccount(date, "02342342", 0.015) };而Java必须new出对象初始化对象数组。如：SavingsAccount accounts[] = { new SavingsAccount(date, "S3755217", 0.015), new SavingsAccount(date, "02342342", 0.015)};
Java中的数组声明不可在方括号内指定数组大小，如int[10]arr，但C++可以；
C++中的字符串可以用字符数组实现或者string（小写s）STL类模板。而Java字符串可以用字符数组，还有String（S大写），StringBuffer，StringBuilder类库。
C++里的if括号里的条件判断非0即真，0即假。而Java中的if括号里的条件判断必须为布尔值，而不能为算术值，如while（y--）{x--;}是错误的。
Java中普通数据类型作为参数传递时是值传递，而对象作为参数时，传递的是对象的地址，对象是引用传递。而C++对象实例作为参数传递时是值传递，C++的引用传递需要加上&修饰，变成一个引用类型。

7_10

同：

Java和C++都有封装，继承，多态（重载和覆盖）。
private修饰的属性成员或方法都不能被子类访问。
都有this

异：

C++中继承父类是在子类的声明后面用冒号：的形式继承。如：class SavingsAccount : public Account{};。而Java使用extends关键字实现继承。如：public class SavingsAccount extends Account {}。
C++中分为公有继承，私有继承和保护继承。而Java中，子类继承了父类的所有属性和方法，但只有public、protected的属性和方法在子类是可见的。子类在继承父类的时候，首先应该满足父类可被访问，例如当子类和父类不在同一个包当中时，父类修饰符必为public；在父类能被访问的前提下，凡是修饰符为public或是protected的父类属性成员或是方法能被子类所访问；private的属性成员或是方法则不能被访问。
Java中this有三个用法，1. 表示当前对象引用。2.表示当前对象。3.调用当前类的构造方法。而C++中没有用法3，有用法1,2。
Java中super访问当前类的直接父类。用法有两点。1.子类的数据成员或成员方法与父类的数据成员或成员方法名字相同时，当要调用父类的同名方法或同名数据成员时则可用super来指明。即super.数据成员；super.成员方法。2.super(参数) , 表示调用父类构造方法。如：public CreditAccount(final Date date, final String id, double credit, double rate, double fee){ super(date,id); this.credit=credit; this.rate=rate; this.fee=fee; this.acc=new Accumulator(date,0);}，再如：public void show(){ **super.show();** System.out.println("\tAvailable credit:" + getAvailableCredit());}.

8_8

同：

C++和Java中在多态中都有重载，覆盖（重写）的概念。

异：

C++中，几个概念的区别：即重载，重写（覆盖），以及重定义（同名隐藏）。 重载：指在同一作用域中允许有多个同名函数，而这些函数的参数列表不同，包括参数个数不同，类型不同，次序不同，需要注意的是返回值相同与否并不影响是否重载。重写（覆盖）和重定义（同名隐藏）则有点像，区别就是在写重写的函数是否是虚函数，只有重写了虚函数的才能算作是体现了C++多态性，否则即为重定义，在之前的代码中，我们看到子类继承了基类的函数，若是子类(派生类)没有函数，依旧会调用基类的函数，若是子类已重定义，则调用自己的函数，这就叫做同名隐藏。 1. 1. 虚函数:是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

2.纯虚函数：想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。
Java中，多态是指一个程序中同名的不同方法共存的情况。提供两种多态的机制：重载（overloading）与覆盖（overriding）。重载：方法名称相同，参数类型或个数不同。注意：若方法名称相同，参数相同，仅有返回类型不同，则编译不能通过。
```
//重载
class Parent{
    public int getScore(){
        return 3;
    }
    public int getScore(int i){
        return i;
    }
 }
```
覆盖：子类对父类的同名方法（方法名称相同，参数相同，返回类型相同）重新进行定义，即在子类中定义与父类中已定义的同名而内容不同的方法。

覆盖与重载的区别：

覆盖：方法名称相同，参数相同，返回类型相同

重载：方法名称相同，参数类型或个数不同
在Java中，覆盖需要注意的地方：
1. 子类的访问修饰符权限应等于或大于父类
2. 同名的static方法和非static方法不能相互覆盖
3. 方法前有final修饰符，此方法不能在子类方法中进行覆盖
4. 在JDK中，很多父类的方法被子类重新覆盖，赋予了不同的含义，如Object类中的boolean equals(Object obj)方法
5. 抽象类中如果存在抽象方法，则具体子类必须对抽象方法进行覆盖

9_16

同：

C++引入类模板的概念，编译器从类模板可以自动生成多个类，避免了程序员的重复劳动。而与之对应的，Java中也有泛型的概念。

异：

此系统中，C++自己实现了一个模板类Array，而Java可以直接用ArratList的泛型类。 ArrayList相当于C++ 的vector，用于存储对象。与数组不同，数组一旦创建，长度固定，但是ArrayList的长度是动态的，不受限制，可以存储任意多的对象，但是只能存储对象，不能存储原生数据类型例如int。
```
 ArrayList <Account> accounts=new ArrayList();
 accounts.add(new SavingsAccount(date, id, rate));
 accounts.add(new CreditAccount(date, id, credit,rate,fee));
```
从键盘中输入的区别， C++给我们提供的cin()获取键盘输入值的现成函数，Java中三种方法（作者刚入门Java，认知有限）：
1. 从控制台接收一个字符，然后将其打印出来
```
import java.io.*;
public static void main(String [] args) throws IOException{ 
   System.out.print("Enter a Char:"); 
   char i = (char) System.in.read(); 
   System.out.println("your char is :"+i); 
} 
```
2. 从控制台接收一个字符串，然后将其打印出来。在这个题目中，我们需要用到BufferedReader类和InputStreamReader类
```
import java.io.*;

public static void main(String [] args) throws IOException{ 
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
      String str = null; 
      System.out.println("Enter your value:"); 
      str = br.readLine(); 
      System.out.println("your value is :"+str); 

}
```
3. 第三中方法，感觉最为方便适用性最大，就是用Scanner类
```
import java.util.Scanner;

public static void main(String [] args) { 
     Scanner sc = new Scanner(System.in); 
     System.out.println("请输入你的姓名："); 
     String name = sc.nextLine(); 
     System.out.println("请输入你的年龄："); 
     int age = sc.nextInt(); 
     System.out.println("请输入你的工资："); 
     float salary = sc.nextFloat(); 
     System.out.println("你的信息如下："); 
     System.out.println("姓名："+name+"\n"+"年龄："+age+"\n"+"工资："+salary); 
}
```
  next()和nextLine()的区别：
  
  在java中，next()方法是不接收空格的，在接收到有效数据前，所有的空格或者tab键等输入被忽略，若有有效数据，则遇到这些键退出。nextLine()可以接收空格或者tab键，其输入应该以enter键结束。
  
  在执行nextInit()函数之后，敲击了enter回车键，回车符会被 nextLine()函数吸收，实际上是执行了nextLine()函数吸收了输入的回车符（并不是没有执行nextLine函数），前面讲到和 nextLine()功能一样的函数next(),他们的区别就在于:next()函数不会接收回车符和tab，或者空格键等，所以在使用 nextLine()函数的时候，要注意敲击的回车符有个被其吸收，导致程序出现BUG

来源：https://www.cnblogs.com/He-Fan/p/11717108.html

标签

date函数

重载函数

函数调用

方法重载

date

数组