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

发表于 | 分类于
字数统计: 1.4k字

上一篇文章的传送门：关于一些基础的Java问题的解答（三）

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

java中的面向对象的三大基本特征分别是：封装、继承、多态：

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

Override和Overload的含义和区别

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

  1. Override描述子类与父类方法的关系，Overload描述同一个类中方法的关系
  2. Override的方法必须完全相同，权限不少于父类，Overload方法名必须相同，参数必须不同，返回值可同可不同

Interface与abstract类的区别

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

  1. 接口的变量为public static final的编译期常量，抽象类的变量没有限制
  2. 接口中的方法为public abstract的公开抽象方法，抽象类的抽象方法不为private即可，且允许有一般方法
  3. 一个类可以实现多个接口，一个类最多只能继承一个抽象类

Static class 与non static class的区别

首先由于顶级类（top level class）是不能为静态的，因此此处讨论的是内部类（nested class）。
静态内部类和非静态内部类的区别主要有以下几点：

  1. 静态内部类不需要持有指向外部类的引用，但非静态内部类需要持有对外部类的引用
  2. 静态内部类不能访问外部类的非静态成员，只能访问外部类的静态成员，而非静态内部类可以访问外部类所有成员
  3. 静态内部类与非静态内部类创建方法不同，一个非静态内部类不能脱离外部类实体被创建

创建静态内部类和非静态内部类的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test {  
    public static void main(String[] args) {  
        // 创建静态内部类  
        Test.staticClass class1 = new Test.staticClass();  
        // 创建非静态内部类  
        // 不能通过编译！  
//      Test.noStaticClass class2 = new Test.noStaticClass();  
        // 正确创建非静态内部类方法  
        Test.noStaticClass class2 = new Test().new noStaticClass();  
    }  
      
    static class staticClass {};  
    class noStaticClass {};  
}

java多态的实现原理

多态，也叫作动态绑定、后期绑定或运行时绑定，指允许不同类的对象对同一消息作出响应。下面介绍一些和绑定相关的概念：

  1. 绑定：指的是将一个方法调用和一个方法主体关联起来的过程
  2. 前期绑定：在程序执行前进行绑定（一般由编译器和连接程序实现，C++默认为前期绑定）
  3. 后期绑定：也叫作动态绑定或运行时绑定，在程序运行时通过识别对象的类型，从而调用恰当的方法（Java除static和final方法外，其他均为后期绑定。C++通过virtual关键字实现虚函数，从而实现后期绑定）

来看一段Java代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Test {  
    static class A {  
        public void sayHi() {  
            System.out.println("Hi, I am A");  
        }  
    }  
      
    static class B extends A {  
        @Override  
        public void sayHi() {  
            System.out.println("Hi, I am B");  
        }  
    }  
      
    static class C extends A {  
        @Override  
        public void sayHi() {  
            System.out.println("Hi, I am C");  
        }  
    }  
      
    public static void saySomething(A a) {  
        a.sayHi();  
    }  
      
    public static void main(String[] args) {  
        saySomething(new A());  
        saySomething(new B());  
        saySomething(new C());  
    }  
      
}

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