【转】【面试题】Java三大特性封装继承多态总结
本文内容总结于多篇博客，参考到的地方在文中都会一一列出
http://www.cnblogs.com/ibalintha/p/3897821.html
1.封装
封装的定义：
- 首先是抽象，把事物抽象成一个类，其次才是封装，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系
为什么需要封装：
- 封装符合面向对象设计原则的第一条：单一性原则，一个类把自己该做的事情封装起来，而不是暴露给其他类去处理，当内部的逻辑发生变化时，外部调用不用因此而修改，他们只调用开放的接口，而不用去关心内部的实现
举例：
-
public
class Human
-
{
-
private
int age;
-
private String name;
-
-
public int getAge()
-
{
-
return age;
-
}
-
-
public void setAge( int age ) throws Exception
-
{
-
//封装age的检验逻辑，而不是暴露给每个调用者去处理
-
if( age >
120 )
-
{
-
throw
new Exception(
“Invalid value of age” );
-
}
-
this.age = age;
-
}
-
-
public String getName()
-
{
-
return name;
-
}
-
-
public void setName( String name )
-
{
-
this.name = name;
-
}
-
}
2. 继承
Java的类可以分为三类：
- 类：使用class定义，没有抽象方法
- 抽象类：使用abstract class定义，可以有也可以没有抽象方法
- 接口：使用inerface定义，只能有抽象方法
在这三个类型之间存在如下关系：
- 类可以extends：类、抽象类（必须实现所有抽象方法），但只能extends一个，可以implements多个接口（必须实现所有接口方法）
- 抽象类可以extends：类，抽象类（可全部、部分、或者完全不实现父类抽象方法），可以implements多个接口（可全部、部分、或者完全不实现接口方法）
- 接口能extends多个接口（//这里原博主中有错误，已经修正）
继承以后子类可以得到什么：
- 子类拥有父类非private的属性和方法（//这里其实我是持怀疑态度，之前听到过一种说法，子类继承了父类所有的成员，也包括private修饰的，只是 不能够调用罢了，如果有人知道，欢迎留言讨论）
- 子类可以添加自己的方法和属性，即对父类进行扩展
- 子类可以重新定义父类的方法，即多态里面的覆盖，后面会详述
关于构造函数：
- 构造函数不能被继承，子类可以通过super()显示调用父类的构造函数
- 创建子类时，编译器会自动调用父类的 无参构造函数
- 如果父类没有定义无参构造函数，子类必须在构造函数的第一行代码使用super()显示调用
类默认拥有无参构造函数，如果定义了其他有参构造函数，则无参函数失效，所以父类没有定义无参构造函数，不是指父类没有写无参构造函数。看下面的例子，父类为Human，子类为Programmer。
-
public
class Human
-
{
-
//定义了有参构造函数，默认无参构造函数失效
-
public Human(String name)
-
{
-
}
-
}
-
public
class Programmer
-
extends
Human
-
{
-
public Programmer()
-
{
-
//如不显示调用，编译器会出现如下错误
-
//Implicit super constructor Human() is undefined. Must explicitly invoke another constructor
-
super(
"x" );
-
}
-
}
为什么需要继承：
- 代码重用是一点，最重要的还是所谓想上转型，即父类的引用变量可以指向子类对象，这是Java面向对象最重要特性多态的基础
3. 多态
在了解多态之前，首先需要知道方法的唯一性标识即什么是相同/不同的方法：
- 一个方法可以由：修饰符如public、static+返回值+方法名+参数+throw的异常 5部分构成
- 其中只有方法名和参数是唯一性标识，意即只要方法名和参数相同那他们就是相同的方法
- 所谓参数相同，是指参数的个数，类型，顺序一致，其中任何一项不同都是不同的方法
何谓重载：
- 重载是指一个类里面（包括父类的方法）存在方法名相同，但是参数不一样的方法，参数不一样可以是不同的参数个数、类型或顺序
- 如果仅仅是修饰符、返回值、throw的异常 不同，那这是2个相同的方法，编译都通不过，更不要说重载了
-
//重载的例子
-
public
class Programmer
-
extends
Human
-
{
-
public void coding() throws Exception
-
{
-
-
}
-
-
public void coding( String langType )
-
{
-
-
}
-
-
public String coding( String langType, String project )
-
{
-
return
"";
-
}
-
}
-
//这不是重载，而是三个相同的方法，编译报错
-
public
class Programmer
-
extends
Human
-
{
-
public void coding() throws Exception
-
{
-
-
}
-
-
public void coding()
-
{
-
-
}
-
-
public String coding()
-
{
-
return
"";
-
}
-
}
何谓覆盖/重写：
- 覆盖描述存在继承关系时子类的一种行为
- 子类中存在和父类相同的方法即为覆盖，何谓相同方法请牢记前面的描述，方法名和参数相同，包括参数个数、类型、顺序
-
public
class Human
-
{
-
public void coding( String langType )
-
{
-
-
}
-
}
-
public
class Programmer
-
extends
Human
-
{
-
//此方法为覆盖/重写
-
public void coding( String langType )
-
{
-
-
}
-
-
//此方法为上面方法的重载
-
public void coding( String langType, String project )
-
{
-
-
}
-
}
覆盖/重写的规则：（两同两小一大原则）
- 子类不能覆盖父类private的方法，private对子类不可见，如果子类定义了一个和父类private方法相同的方法，实为新增方法
- 重写方法的修饰符一定要大于被重写方法的修饰符(public > protected > default > private)
- 重写抛出的异常需与父类相同或是父类异常的子类，或者重写方法干脆不写throws
- 重写方法的返回值必须与被重写方法一致，否则编译报错
- 静态方法不能被重写为非静态方法，否则编译出错
理解了上述知识点，是时候定义多态了：
- 多态可以说是“一个接口，多种实现”或者说是父类的引用变量可以指向子类的实例，被引用对象的类型决定调用谁的方法，但这个方法必须在父类中定义
- 多态可以分为两种类型：编译时多态（方法的重载）和运行时多态（继承时方法的重写），编译时多态很好理解，后述内容针对运行时多态
- 运行时多态依赖于继承、重写和向上转型
上例子：
-
class Human
-
{
-
public void showName()
-
{
-
System.out.println(
"I am Human" );
-
}
-
}
-
-
//继承关系
-
class Doctor
-
extends
Human
-
{
-
//方法重写
-
public void showName()
-
{
-
System.out.println(
"I am Doctor" );
-
}
-
}
-
-
class Programmer
-
extends
Human
-
{
-
public void showName()
-
{
-
System.out.println(
"I am Programmer" );
-
}
-
}
-
-
public
class Test
-
{
-
//向上转型
-
public Human humanFactory( String humanType )
-
{
-
if(
"doctor".equals( humanType ) )
-
{
-
return
new Doctor();
-
}
-
if(
"programmer".equals( humanType ) )
-
{
-
return
new Programmer();
-
}
-
return
new Human();
-
}
-
-
public static void main( String args[] )
-
{
-
Test test =
new Test();
-
Human human = test.humanFactory(
"doctor" );
-
human.showName();
//Output:I am Doctor
-
human = test.humanFactory(
"programmer" );
-
human.showName();
//Output:I am Programmer
-
//一个接口的方法，表现出不同的形态，意即为多态也
-
}
-
}
向上转型的缺憾：
- 只能调用父类中定义的属性和方法，对于子类中的方法和属性它就望尘莫及了，必须强转成子类类型
总结概括：
- 当超类对象引用变量引用子类对象时，被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法，但是这个被调用的方法必须是在超类中定义过的，也就是说被子类覆盖的方法，但是它仍然要根据继承链中方法调用的优先级来确认方法，该优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)
稍微复杂的例子：
-
class Human {
-
-
public void fun1() {
-
System.out.println(
"Human fun1");
-
fun2();
-
}
-
-
public void fun2() {
-
System.out.println(
"Human fun2");
-
}
-
}
-
-
class Programmer extends Human {
-
-
public void fun1(String name) {
-
System.out.println(
"Programmer's fun1");
-
}
-
-
public void fun2() {
-
System.out.println(
"Programmer's fun2");
-
}
-
}
-
-
public
class Test {
-
public static void main(String[] args) {
-
Human human =
new Programmer();
-
human.fun1();
-
}
-
/*
-
* Output:
-
* Human fun1
-
* Programmer's fun2
-
*/
-
}
- Programmer中的fun1(String name) 和Human中的fun1()，只是方法名相同但参数不一样，所以是重载关系
- Programmer中的fun2()和Human中的fun2()是相同的方法，即Programmer重写了Human的fun2()方法
- 把Programmer的对象向上转型赋值个Human后，human.fun1()会调用父类中的fun1()方法，子类的fun1(String name)是不同的方法
- 在human的fun1()中又调用了fun2()方法，该方法在Programmer中被重写，实际调用的是被引用变量Programmer中的fun2()方法
-
package test;
-
-
class A {
-
public void func() {
-
System.out.println(
"func in A");
-
}
-
}
-
-
class B extends A {
-
public void func() {
-
System.out.println(
"func in B");
-
}
-
}
-
-
class C extends B {
-
public void func() {
-
System.out.println(
"func in B");
-
}
-
}
-
-
public
class Bar {
-
public void test(A a) {
-
a.func();
-
System.out.println(
"test A in Bar");
-
}
-
-
public void test(C c) {
-
c.func();
-
System.out.println(
"test C in Bar");
-
}
-
-
public static void main(String[] args) {
-
Bar bar =
new Bar();
-
A a =
new A();
-
B b =
new B();
-
C c =
new C();
-
bar.test(a);
-
bar.test(b);
-
bar.test(c);
-
/*
-
func in A
-
test A in Bar
-
func in B
-
test A in Bar
-
func in B
-
test C in Bar
-
*/
-
}
-
}
最近看腾讯的一道多态面试题：（转载自：http://blog.csdn.net/qq_27258799）
-
public
class A {
-
public
int a =
0;
-
public void fun(){
-
System.out.println(
"-----A-----");
-
}
-
}
-
-
public
class B extends A{
-
public
int a =
1;
-
public void fun(){
-
System.out.println(
"-----B-----");
-
}
-
-
public static void main(String[] args){
-
A classA =
new B();
-
System.out.println(classA.a);
-
classA.fun();
-
}
-
}
答案是：
-
0
-
-----B-----
解析：
java中变量不能重写，可以按如下口诀记忆：
变量多态看左边，
方法多态看右边，
静态多态看左边。
这里补充一下接口和抽象类的相关知识：（部分把内容转载自：http://www.importnew.com/18780.html）
一.抽象类
在了解抽象类之前，先来了解一下抽象方法。抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法的声明格式为：
|
1
|
abstract
void
fun();
|
抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
下面要注意一个问题：在《Java编程思想》一书中，将抽象类定义为“包含抽象方法的类”，但是后面发现如果一个类不包含抽象方法，只是用abstract修饰的话也是抽象类。也就是说抽象类不一定必须含有抽象方法。个人觉得这个属于钻牛角尖的问题吧，因为如果一个抽象类不包含任何抽象方法，为何还要设计为抽象类？所以暂且记住这个概念吧，不必去深究为什么。
|
1
2
3
|
[
public
]
abstract
class
ClassName {
abstract
void
fun();
}
|
从这里可以看出，抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。
包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：
1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。
2）抽象类不能用来创建对象；
3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。
在其他方面，抽象类和普通的类并没有区别。
二.接口
接口，英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数。从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。在Java中，定一个接口的形式如下：
-
-
[修饰符]
interface 接口名 [extends 父接口名列表]{
-
-
[
public] [
static] [
final] 常量;
-
[
public] [
abstract] 方法;
-
}
接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法（用其他关键字，比如private、protected、static、 final等修饰会报编译错误），并且接口中所有的方法不能有具体的实现，也就是说，接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别，接口是一种极度抽象的类型，它比抽象类更加“抽象”，并且一般情况下不在接口中定义变量。
要让一个类遵循某组特地的接口需要使用implements关键字，具体格式如下：
|
1
2
|
class
ClassName
implements
Interface1,Interface2,[....]{
}
|
可以看出，允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口，就必须实现该接口中的所有方法。对于遵循某个接口的抽象类，可以不实现该接口中的抽象方法。
三.抽象类和接口的区别
1.语法层面上的区别
1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；
2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；
3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；
4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。
2.设计层面上的区别
1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 “是不是”的关系，而 接口 实现则是 “有没有”的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。
2）设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。
下面看一个网上流传最广泛的例子：门和警报的例子：门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：
|
1
2
3
4
|
abstract
class
Door {
public
abstract
void
open();
public
abstract
void
close();
}
|
或者：
|
1
2
3
4
|
interface
Door {
public
abstract
void
open();
public
abstract
void
close();
}
|
但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路：
1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；
2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。
从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
interface
Alram {
void
alarm();
}
abstract
class
Door {
void
open();
void
close();
}
class
AlarmDoor
extends
Door
implements
Alarm {
void
oepn() {
//....
}
void
close() {
//....
}
void
alarm() {
|