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 中, 覆盖需要注意的地方:
子类的访问修饰符权限应等于或大于父类
同名的 static 方法和非 static 方法不能相互覆盖
方法前有 final 修饰符, 此方法不能在子类方法中进行覆盖
在 JDK 中, 很多父类的方法被子类重新覆盖, 赋予了不同的含义, 如 Object 类中的 boolean equals(Object obj)方法
抽象类中如果存在抽象方法, 则具体子类必须对抽象方法进行覆盖
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, 认知有限):
从控制台接收一个字符, 然后将其打印出来
- 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);
- }
从控制台接收一个字符串, 然后将其打印出来. 在这个题目中, 我们需要用到 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);
- }
第三中方法, 感觉最为方便适用性最大, 就是用 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