java基础-3-面向对象（3）-继承、抽象类、接口与多态

------- android培训、java培训、期待与您交流！ ----------

继承

        继承，就是承袭来自父辈的资产。java中，继承的特点是，子继父类，但是子类可以有新的特性，或是重写、覆盖一些没有限定的父类参数、动作特征。这里就需要简要的说明一下什么事子类，什么是父类。子类就是继承其他类的部分特性，并有一定自己特性的类，相较于其继承类而言，我们称之为子类。同样的，父类就是指被其他类继承了特性的类，相较于继承它的类，我们称之为父类。

        继承的关键字是extends，后跟父类名。因为定义绕口的缘故，我们以例子来做说明：

class  ExtendsShow
{
       public static void main(String[] args)
       {
              //建立父类对象，并调用父类show方法
              Father f = new Father();
              f.show();
 
              //建立子类对象，并调用子类覆盖的show方法
              Son s = new Son();
              s.show();
       }
}
 
//父类定义：
class Father
{
       //设置父类的i监测参数
       int i = 1;
       //父类构造方法
       void Father(){}
       //父类的show方法
       public void show()
       {
              System.out.println("i'mfather! "+i);
       }
}
 
class Son extendsFather
{
       //设置子类的i监测参数
       int i = -1;
       //子类构造方法
       void Son(){}
       //子类的覆盖show方法，我们让它调用父类show，然后在输出点别的
       public void show()
       {
              super.show();
              System.out.println("sorry..hidad~ "+i);
       }
}

        运行上面的程序，我们有结果：

               i'm father! 1

               i'm father! -1

               sorry..hi dad~ -1

        我们可以发现，子类可以继承父类的方法。但是，如果方法、参数被覆盖，则按照子类的定义来实现。

        那么什么情况下，子类无法覆盖父类的参数、方法呢？这就有一些特殊的情况了。通常，如果父类中有final关键字修饰的方法或参数，那么这个方法或参数，就是不能被修改的。final的意义，代表着“最终”。注意，只要没有被final修饰，那么父类中的静态成员，也是能被子类覆盖的。如上例中的show方法，如果是下面这种样子，就是不能覆盖的：

<span style="white-space:pre">	</span>final public voidshow(){...}   //不能覆盖，不能覆盖。——计算机

 

抽象类与关键字abstract

        抽象类是指由关键字abstract修饰的类，该类有一个特点就是不能生成对象。抽象类中可以定义具有具体内容的方法来构成模版，或者是直接作为工具类使用。被用于模版的抽象类，我们称之为模板类。这也是模版方法模式的关键一环。当抽象类中有只需声明的方法、参数时，我们只需要在声明前加上关键字abstract即可，我们称这种方法为抽象方法。

        当一个抽象类的子类中有没有覆盖的抽象方法、参数时，这个子类一样是个抽象类。只有当一个子类将父类中的所有抽象方法、参数，覆盖干净之后。这个子类才是一个可以建立对象的正常类。

        我们来看一个例子：

class AbstractDemo
{
       public static void main(String[] args)
       {
              //建立子类B的对象b，并调用其方法，检验
              B b = new B();
              B.fire();
              B.see();
       }
}
 
abstract class A
{
       //建立抽象类A的fire方法声明
       abstract void fire();
 
       //建立模版方法see
       public void see()
       {
              System.out.println("go tosee!");
       }
}
 
//抽象类A的子类B，实现类的实体化
class B extends A
{
       //覆盖父类A的抽象方法fire
       public void fire()
       {
              System.out.println("fire!");
       }
}

        上例结果为：        fire!

                                       go to see!

        很明显，抽象类和一般的类其实并没有太大的不同。抽象类的定义是为了就如何描述一个事物，提供一个可行的思路模版；或者是为了对一些其他的类对象进行操作，而定义的一套工具。

        我们发现，有时候，抽象类的使用仅仅只是为了提供一个类似于接口或者相似于标签的作用，这时候在使用abstract的机制，就会显得较为繁琐，且占用资源。于是，我们有了接口类及接口类关键字interface。

 

接口类与类关键字interface

        接口类及关键字interface的作用，从本质上讲，可以看作是抽象类与关键字abstract的简化版。利用关键字interface，我们能够建立一个绝对的抽象类接口，这个接口类中绝对不包含已经定义好的方法。接口类中的方法及参数一定是抽象的，即只有声明，而没有详细的定义。而接口类的作用，就是提供接口或者相似于标签的标记功能，例如接口Serializable。与抽象类使用extends继承不同的是，接口使用implements来实现。如：

//myObj实现Serializable
class myObj implementsSerializable
{
       //serialVersionUID如果不自己设定，就会自动生成，详见java中级-IO
       public static final long serialVersionUID= 142L;
 
}

        这个类实现的接口Serializable接口类，起的作用就是标记实现它的类的作用，用于分段。其他用法便不用举例了。

 

多态

        多态是一种通过父类来创建子类对象，或者用子类对象来向父类类型变量赋值的技术手段。多态的好处是能够提高代码的灵活性，和代码效率。同时，多态的使用对我们提高程序兼容性，也有着间接的作用。

        我们根据多态操作的特点将它分为两种类型：向上转型和向下转型。

                1.向上转型是将子类通过父类建立来实现对象的创建，这样的多态操作；

                2.向下转型是将父类通过强制转换，来转换为子类对象，来实现对子类成员的使用的多态操作。

        我们来看一个例子：

classTransformationDemo
{
       public static void main(String[] args)
       {
              //向上转型
              A a = new B();
              a.i();
              a.show();
 
              //向下转型
              B b = (B) a;
              b.i();
              b.show();
              b.catchMe();
       }
}
 
//父类A：
class A
{
       //设定监控参数i
       int i = 1;
       //父类定义的show方法
       public void show()
       {
              System.out.println("A!!");
       }
       //父类定义显示i监控参数的方法i()
       public void i()
       {
              System.out.println(i);
       }
}
 
//继承A的子类B
class B extends A
{
       //设定监控参数i
       int i = 2;
       //子类覆盖父类定义的show方法
       public void show()
       {
              System.out.println("B!!");
       }
       //子类定义的特有方法catchMe方法
       public void catchMe()
       {
              System.out.println("catch!!");
       }
}

        上例的结果是：   1

                                        B!!

                                        1

                                        B!!

                                        catch!!

        从结果上不难看出，不论是向上转型还是向下转型，转型后方法与参数的调用是以父类为准的，而方法则是以子类为主的。

        向上转型后的类对象a，它只能调用A类有的方法和变量，但是方法从子类而来，参数从父类自身而来；向下转型后，对应的类对象b，它除了可以使用B类的特殊方法外，并没有和a有其他的区别。需要注意的是，向下转型的适用范围仅限于经过向上转型而得的类型变量，例如上例中的a。

        从这里，我们就不难发现，我们经常使用多台，来作为一些方法的参数，以提高兼容性。例如最典型的就是toString(Object obj)这样的使用方式。

------- android培训、java培训、期待与您交流！ ----------