黑马程序员_java面向对-----继承

                               黑马程序员_java面向对-----继承

 

               ---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

一、继承 

关键字，extends 

程序为：

class Person
{
 String name;
 int age;
}
class  Student extends Person............此处即为继承，格式：extends  类名
{
 void study()
 {
  System.out.println("good study");
 }
}

继承：1、提高了代码复用性

            2、让类与类之间产生了关系，有了这个关系，才有了多态的特性。

            3、java中只支持单继承，不支持多继承。多继承就是一个类继承多个类。

            4、java支持多层继承，即c继承b，b继承a。

注意：1、千万不要为了获取其他类的功能，简化代码而继承。

           2、必须是类与类之间有所属关系才可以继承。可以用数学方面来说，就是一个包含另一个，所属关系，包含与被包含。

           3、是找到类的共同之处，然后抽取出来。

如何使用一个继承体系中的功能呢？

想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中共性的功能。

通过了解共性功能，就可以知道该体系的基本功能

那么这个体系就可以使用了。

那么在具体调用时，要创建最子类的对象。一是因为有可能父类不能创建对象，二是创建子类对象可以使用更多的功能，包括基本的也包括特有的。

       简单来说，就是使用时，查阅父类功能，使用子类对象调用。程序：

class Fu............................父类
{
 int num=4;
}
class Zi extends Fu..........子类，同时继承父类
{
 int num=5;
 void show()
 {
  System.out.println(num);.........此时，num是调用这个功能的对象所有的num，即子类里的num=5。
 }                                                如果想此处调用的是父类里的num，那么用关键字super，格式为super.num
}

class  ExtendsDemo
{
 public static void main(String[] args)
 {
  Zi z = new Zi();
  z.show();...................................................注意，此时show函数调用的是子类的num
  System.out.println(z.num1+","+z.num2);
 }
}
关于子父类中的变量：

如果子类中出现非私有的同名变量时，子类要访问本类中的变量，用this，子类要访问父类中同名变量，用关键字super。

关于子父类中的函数：

当子类出现和父类一模一样的函数时，子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。这种情况是函数的另一个特性：重写（覆盖）。

重载：只看参数列表

重写：子父类方法一模一样，类型也必须得一样。

这个特性可以拓展。程序如下

class Tel................................................初始程序
{
 void show()
 {
  System.our.println("number");
 }
}
class NewTel  extends Tel.................后修改程序
{
 void show()
 {
  super.show();
  System.our.println("name");
 }
}

以上程序就是说，当我们现在需要新功能时，不要直接在原有代码上直接进行修改，使用函数重写功能，建立一个子类，继承原有类的功能，同名函数下进行功能的添加，在之后调用函数时就会执行新的函数功能。同时如果需要父类中的功能时，用super关键字。

修改程序，千万别修改原码。

覆盖（重写）注意事项：

1、子类覆盖父类，必须保证子类权限大于父类权限，否则编译失败。

2、静态只能覆盖静态

知识：public 权限大于默认权限（函数前面什么都不加）。

 

子父类的构造函数：

class Fu
{
 Fu()
 {
  System.out.println("fu run");
 }
}
class Zi extends Fu
{
 Zi()
 {
  System.out.println("zi run");
 }
}

class  ExtendsDemo
{
 public static void main(String[] args)
 {
  Zi z = new Zi();
  
 }
} 结果为：fu run     zi   run

 

运行时，父类的构造函数也会运行。

       在对子类对象进行初始化时，父类的构造函数也会进行，那是因为子类构造函数默认第一行有一条隐式的语句super（），这个语句会访问父类中空参数的构造函数，而且子类中所有构造函数都有这条语句，且一定会访问父类的空参数的构造函数。

       为什么子类一定要访问父类中的构造函数？

因为父类中的数据，子类可以直接获取，所以子类对象在建立时，需要查看父类如何对这些数据进行初始化的，所以子类对象在对象初始化时，要想访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过super语句来指定。

  注意：     super语句一定定义在子类构造函数的第一行

二、关键字 final 

作为一个修饰符：

1、可以修饰类，修饰函数，修饰变量

2、被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

3、被final修饰的方法不可以被复写

4、被final修饰的变量时一个常量，只能赋值依次，既可以修饰成员变量，又可以修饰局部变量。

       被修饰常量的名字全部大写，多个单词连接用   _   连接。

 

二、继承 ——抽象类

当多个类中出现相同功能，但功能主题不同，这是可以进行向上抽取的，这是，只抽取功能的定义，而不抽取功能主体。程序如下：

abstract class Study..........类也得用abstract修饰，即抽象方法和抽象函数
{
abstract  void study();........只抽取功能的定义，不抽取功能的主体，而且用abstract来修饰
}
class BassStudent extends Study
{
 void study()
 {
  System.out.println("base study");
 }
}
class AdvStudent   extends Study
{
 void study()
 {
  System.out.println("adv study");
 }
}

抽象类的特点：

1、抽象方法一定在抽象类中，简单来说必须abstract修饰

2、抽象方法和抽象类必须被abstract关键字修饰

3、抽象类不可用new创建对象，因为调用抽象方法没有意义。

    abstract  void study();抽象类只是用了功能的定义，并没有实际内容，是抽象的，即是建立了对象，也不能做出什么动作。如果是这样abstract  void study(){ }，那就是功能定义和功能主题都有了，已经不是抽象函数了。

4、抽象类中的抽象方法要被使用，必须有子类复写所有抽象方法后，建立子类对象调用。

abstract class Study
{
abstract  void study();
}
class BassStudent extends Study
{
 void study()
 {
  System.out.println("base study");
 }

想类BassStudent中，已经复写了父类的抽象方法，此时建立子类的对象，就可以调用抽象类中的抽象方法。

5、如果子类只覆盖了部分抽象方法，那没该子类环视一个抽象类

相对于4中的程序，改变为一下程序：

abstract class Study
{
abstract  void study();

abstract  void study2();.....................抽象类中，有两个抽象函数
}
class BassStudent extends Study
{
 void student()..................................子类中只复写了抽象类中的一个方法，但因为是继承，所以子类中也一
 {                                                        定继承了方法abstract  void study2()，而抽象函数必须在抽象类中，所
  System.out.println("base study");      此处子类也是抽象函数 abstract class BassStudent extends Study
 }

抽象类中，有抽象类也能有非抽象类，抽象类中可以不定义抽象方法，abstract只能修饰方法和类

三、模板方法模式

      模板方法就是在定义功能时，功能的一部分是确定的，另一部分是不确定的，而确定的部分在使用不确定的部分。那么，这时就将不确定的部分暴露出去，有该类的子类去完成。具体例子程序如下：

abstract class GetTime
{
 public final  void getTime()..............................加入修饰符final，使得此函数不能被子函数复写
 {
  long start = System.currentTimeMillis();
  runcode();.......................................................不确定的部分
  long end = System.currentTimeMillis();
  System.out.println("运行时间（毫秒）："+(end-start));
 }
 public abstract void runcode();.........................抽象函数（就是把不确定的部分暴露出去，让子类完成）
}
class SubTime extends GetTime
{
 void runcode(){  };............................................复写抽象函数，可以写入自己运行的函数。

 }

 

三、接口 interface

接口可以蕾姐为是一个特殊的抽象类，当抽象类中的方法都是抽象的时候，那么该类就可以通过接口形式来进行标示。

接口定义时，格式特点：

1、接口中常见定义：常量，抽象方法

2、接口中的成员都有固定的修饰符

      常量：public static final

      方法：public abstract

注意：接口里面的成员都是public

接口是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类就是一个抽象类。

子类调用接口关键字为：implements

具体程序为：

interface Inter...............................定义接口
{
 public static final int NUM=3;......       格式是固定的
 public abstract void show();........        格式是固定的   抽象方法
}
class Test  implements Inter............注意，此处不是继承extends   而是implements
{
 public void show(){}............................复写父类抽象方法，只有这样子类才可以建立对象，否则也是抽象类
}

 

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

多实现程序：

interface Inter
{
 public static final int NUM=3;
 public abstract void show();
}
interface Inter1
{
 public static final int NUM1=4;
 public abstract void show();
}
class Test  implements Inter,Inter1..........接口可以被类多实现
{
 public void show(){}.............................两个接口类名一样，只需一个就可以覆盖

}

多实现，是因为接口里都是抽象函数，并没有具体内容，而类通过建立对象调用，类本身会有函数覆盖原有接口里的抽象函数，所以，即是两个接口抽象函数一致，对象中函数也会加以覆盖，不会有系统不知道执行哪个函数的情况。如果两个接口函数一样，类中用一个函数就可以进行覆盖。

 

接口与接口之间是继承关系，而且可以多继承，因为都没有方法体，但函数名称不得一样，程序如下：

interface A
{
 void showA();
}
interface B
{
 void showB();
}
interface C  extends A,B  ..............接口与接口之间可以多继承
{
 void showC();
}
class D implements C
{
 void showA(){}
 void showB(){}
 void showC(){}
}

接口特点总结：

接口是对外暴露规则

接口是程序功能的扩展

接口降低程序间的耦合性

接口可以用来多实现

类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口

接口与接口之间可以有继承关系

 

相对于继承来说，接口更多的是功能拓展，而继承更多的是从属。

 

 

 

                ---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------