正文

关于一些基础的Java问题的解答（四）

IP云
IP云V管理员/4 阅读
09/21
提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

16. Java面向对象的三个特征与含义

java中的面向对象的三大基本特征分别是：封装、继承、多态：
  1. 封装：把过程和数据包围起来，对数据的访问只能通过已定义的界面，主要是方便类的修改
  2. 继承：对象的一个新类可以从现有的类中派生，这个过程称为类继承。通常继承把共性放到父类，特性放到子类。继承性很好的解决了软件的可重用性问题
  3. 多态：指允许不同类的对象对同一消息作出响应，多态性语言具有灵活、抽象、行为共享、代码共享的优势，很好的解决了应用程序函数同名问题
 

17. Override和Overload的含义和区别

Override即重写，也叫覆盖，即在子类中拥有与父类非private方法一模一样的方法（返回值，参数，方法名均相同，在Java SE5中引入了协变类型，协变类型允许覆盖的方法的返回值为原返回值的子类型），且子类方法的访问修饰权限不能少于父类，则对子类调用该方法时会调用子类方法代替父类方法。
Overload即重载，是指在同一类中拥有多个方法名相同，参数不同（参数类型或个数），返回值可相同可不同的方法。调用方法时会根据传入参数选择合适方法。
两者区别：
  1. Override描述子类与父类方法的关系，Overload描述同一个类中方法的关系
  2. Override的方法必须完全相同，权限不少于父类，Overload方法名必须相同，参数必须不同，返回值可同可不同

18. Interface与abstract类的区别

Interface即接口，接口可以有变量，但接口的变量均为public static final的编译期常量，接口中的方法均为public abstract的公开抽象方法，一个类可以实现多个接口。
abstract类即抽象类，抽象类有关键字abstract修饰，抽象类不能实例化只能被继承。抽象类中一般含有抽象方法（为public或protected，private无法继承），其他方面与一般类区别不大。
两者区别：
  1. 接口的变量为public static final的编译期常量，抽象类的变量没有限制
  2. 接口中的方法为public abstract的公开抽象方法，抽象类的抽象方法不为private即可，且允许有一般方法
  3. 一个类可以实现多个接口，一个类最多只能继承一个抽象类
 

19. Static class 与non static class的区别

首先由于顶级类（top level class）是不能为静态的，因此此处讨论的是内部类（nested class）。
静态内部类和非静态内部类的区别主要有以下几点：
  1. 静态内部类不需要持有指向外部类的引用，但非静态内部类需要持有对外部类的引用
  2. 静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员，而非静态内部类可以访问外部类所有成员
  3. 静态内部类与非静态内部类创建方法不同，一个非静态内部类不能脱离外部类实体被创建
创建静态内部类和非静态内部类的代码：
  1. public class Test {
  2. public static void main(String[] args) {
  3. // 创建静态内部类
  4. Test.staticClass class1 = new Test.staticClass();
  5. // 创建非静态内部类
  6. // 不能同编译！
  7. //      Test.noStaticClass class2 = new Test.noStaticClass();
  8. // 正确创建非静态内部类方法
  9. Test.noStaticClass class2 = new Test().new noStaticClass();
  10. }
  11. static class staticClass {};
  12. class noStaticClass {};
  13. }
 

20. java多态的实现原理

多态，也叫作动态绑定、后期绑定或运行时绑定，指允许不同类的对象对同一消息作出响应。下面介绍一些和绑定相关的概念：
  • 绑定：指的是将一个方法调用和一个方法主体关联起来的过程
  • 前期绑定：在程序执行前进行绑定（一般由编译器和连接程序实现，C++默认为前期绑定）
  • 后期绑定：也叫作动态绑定或运行时绑定，在程序运行时通过识别对象的类型，从而调用恰当的方法（Java除static和final方法外，其他均为后期绑定。C++通过virtual关键字实现虚函数，从而实现后期绑定）
来看一段Java代码：
  1. public class Test {
  2. static class A {
  3. public void sayHi() {
  4. System.out.println("Hi, I am A");
  5. }
  6. }
  7. static class B extends A {
  8. @Override
  9. public void sayHi() {
  10. System.out.println("Hi, I am B");
  11. }
  12. }
  13. static class C extends A {
  14. @Override
  15. public void sayHi() {
  16. System.out.println("Hi, I am C");
  17. }
  18. }
  19. public static void saySomething(A a) {
  20. a.sayHi();
  21. }
  22. public static void main(String[] args) {
  23. saySomething(new A());
  24. saySomething(new B());
  25. saySomething(new C());
  26. }
  27. }

看到第23行的方法，从编译器给出的信息我们只能知道a是一个A类的引用，但无法确定a是A类的实例，还是其子类（B或C）的实例（导出类可以通过向上转型，把对自身的引用视为对其基类的引用），因此如果通过前期绑定，我们并不能实现多态。但是如果我们使用的是后期绑定，我们就可以在程序运行时先确定传入实例的具体类型，再根据其具体类型来调用对应的方法，就可以实现多态。