黑马程序员--继承、抽象、接口（Java）

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、继承（面向对象特征之一）
1.概述：
       1）、多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。
       2）、多个类可以称为子类，单独这个类称为父类或者超类。
       3）、子类可以直接访问父类中的非私有的属性和行为。
       4）、通过extends 关键字让类与类之间产生继承关系。

2.好处：
       1）、提高了代码的复用性。
       2）、让类与类之间产生了关系，提供了另一个特征多态的前提。

3.特点：
       1）、Java只支持单继承，不支持多继承。（因为当一个类同时继承两个父类时，两个父类中有相同的功能，那么子类对象调用该功能时，运行哪一个呢）。
       2）、Java支持多层继承。

4.总结：对于一个继承体系的使用，查阅顶层父类中的内容（父类中定义的是该体系中的共性功能），创建最底层子类的对象（创建子类对象可以使用更多的功能，基本的和特有的）。

 

5.子父类出现后，类中的成员都有了哪些特点：
                                         1)   、成员变量：如果子类中出现非私有的同名成员变量时，子类访问本类中的变量用this，访问父类中同名变量用super。
                                         2）、成员函数：当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法，好像父类中的方法被覆盖掉一样。
                                                   所以这种情况是函数的另一个特性：覆盖(复写，重写)。
                                                   什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现。
                                                   覆盖注意事项：覆盖时，子类方法权限一定要大于等于父类方法权限；静态只能覆盖静态。
                                         3）、构造函数：在对子类对象进行初始化时，父类的构造函数也会运行。因为子类的每一个构造函数默认第一行有一条隐式的语句super()；
                                                   注意：子类中所有的构造函数都会默认访问父类中的空参数的构造函数，因为每一个子类构造内第一行都有默认的语句super();
                                                   如果父类中没有空参数的构造函数，那么子类的构造函数内，必须通过super（有参数）语句指定要访问的父类中的构造函数。
                                                   如果子类构造函数用this来指定调用子类自己的构造函数，那么被调用的构造函数也一样会访问父类中的构造函数。

6.重载与重写区别：
                 1）、重载：只看同名函数的参数列表。
                 2）、重写：子父类方法要一模一样。

7.super()和this()用法注意：
                          1）、super()和this()是否可以同时出现在构造函数中？两个语句只能有一个定义在第一行，所以只能出现其中一个。
                          2）、super()或者this():为什么一定要定义在第一行？因为super()或者this()都是调用构造函数，构造函数用于初始化，因为初始化的动作要先完成。

8.final关键字：
             1.特点：
                   1）、final:最终，作为一个修饰符。可以修饰类，函数，变量。
                   2）、被final修饰的类不可以被继承。为了避免被继承，被子类复写功能；
                   3）、被final修饰的方法不可以被复写；
                   4）、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。
             2.原因：
                   其实这样的原因的就是给一些固定的数据起个阅读性较强的名称。
             3.规则：
                   加了final，程序更为严谨。常量名称定义时，有规范，所有字母都大写，如果由多个单词组成，中间用 _ 连接。

 

 

二、抽象类

1.抽象类由来：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

2.抽象定义：（看不懂）抽象就是从多个事物中将共性的，本质的内容抽取出来。

3.抽象类的特点：
              1）、抽象方法一定在抽象类中。
              2）、抽象方法和抽象类都必须被abstract关键字修饰。（被abstract修饰的函数不能同时被private、final、static修饰）。
              3）、抽象类不可以用new创建对象，因为调用抽象方法没意义。
              4）、抽象类中的抽象方法要被使用，必须由子类复写所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

4.抽象类与一般类的区别：
                      1）、抽象类和一般类没有太大的不同。该如何描述事物，还是如何描述事物。只不过，该事物中出现了一些不知道具体内容的方法部分。这些不确定的部分，也是该

                           事物的功能，需要明确出来，但是无法定义主体。通过抽象方法来表示。
                      2）、抽象类比一般类多了个抽象函数。就是在类中可以定义抽象方法。
                      3）、抽象类不可以实例化。
                      4）、抽象类虽然不能创建对象，但是也有构造函数。供子类实例化调用。
                      5）、抽象类中可以不定义抽象方法，这样做是不让类创建对象。

5.抽象类练习（代码）：
/*
假如我们在开发一个系统时需要对员工进行建模，员工包含3个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另外
还有奖金属性，请使用继承的思想设计出员工类和经理类。
*/
class AbstractTest
{
 public static void main(String[] args)
 {
  jingli j = new jingli("lisi",111,3000,500);
  j.work();
 }
}

abstract class yuangong
{
 private String name;
 private int id;
 private double pay;
 yuangong(String name,int id,double pay)
 {
  this.name = name;
  this.id = id;
  this.pay = pay;
 }
 public abstract void work();

}

class jingli extends yuangong
{
 private int bonus;
 jingli(String name,int id,double pay,int bonus)
 {
  super(name,id,pay);
  this.bonus = bonus;
 }
 public void work()
 {
  System.out.println("jingli work");
 }
}

 6.模板方法设计模式：解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

7.模板方法练习（代码）：
/*
需求：获取一段程序运行的时间。
原理：获取程序开始和结束的时间并相减即可。
获取时间：System.currentTimeMillis();
*/
abstract class GetTime
{
 public final void getTime()
 {
  long start = System.currentTimeMillis();
   
  runcode();
   
  long end = System.currentTimeMillis();
  
  System.out.println("毫秒："+(end-start));
 }
 public abstract void runcode();

}
class SubTime extends GetTime
{
 public void runcode()
 {
  for(int x=0;x<2000;x++)
   System.out.print(x);
 }
}
class TemplateTest
{
 public static void main(String[] args)
 {
  SubTime gt = new SubTime();
  gt.getTime();
 }
}

 

三、接口

1.初期理解：可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

2.格式：
      1）、是用关键字interface定义的， interface 接口名{}。   子类名 implements接口名{}。
      2）、接口中包含的成员，最常见的有全局常量、抽象方法。
           注意：接口中的成员都有固定的修饰符。
  成员变量：public static final   （公共的静态的不可以变的常量）
  成员方法：public abstract   （公共的抽象的方法。没有方法体只有方法名）
      3）、接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

3.特点：
      1）、接口是对外提供的规则。
      2）、接口是功能的扩展。
      3）、接口的出现降低了耦合性。

4.抽象类和接口的区别：
                    1）、抽象类只能被继承，而且只能单继承；接口需要被实现，而且可以多实现。
                    2）、抽象类中可以定义非抽象方法，子类可以直接继承使用；接口中都有抽象方法，需要子类（全部）实现。
                    3）、抽象类使用的是  is a 关系；接口使用的 like a 关系。
                    4）、抽象类的成员修饰符可以自定义；接口中的成员修饰符是固定的。全都是public的。

4.知识拓展：
耦合性：开发之前先定义规则，A和B分别开发，A负责实现这个规则，B负责使用这个规则。至于A是如何对规则具体实现的，B不需要知道。这样这个接口的出现就降低了A和B直接耦合性。