黑马程序员——java基础日记——继承、接口

      -----------android培训、java培训、java学习型技术博客、期待与您交流！------------

继承

一、继承的概念

             多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，

只要继承那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

             通过extends关键字让类与类之间产生继承关系。如：class B extends A｛｝

注：

1、子类可以直接访问父类中的非私有的属性和行为。
2、子类无法继承父类中私有的内容。
3、父类是从子类共性不断向上抽取而来的。      

class A{int age;public void show(){System.out.println(age);}}class B extends A{public static void main(String[] args) {B b = new B();b.age=10;//通过继承子类可以直接访问父类非私有的属性和行为。b.show();}    }

好处：

继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。

二、继承的特点

     1、 Java只支持单继承，不支持多继承。也就是一个子类只能有一个父类，不能有多个父类。

因为一旦多个父类中拥有相同的方法时，子类就不知道到引用哪个方法。

           虽然不能多继承，不过在java中还有多实现机制可以弥补这个缺陷，在以后的学习中就接触到多实现机制。

       2、Java支持多层继承(继承体系)：

            C继承B，B继承A，就会出现继承体系。

在多层继承中，我们可以通过观察父类的功能，即观察该体系的共性功能，来创建子类的对象就可以使用该体系的功能。

定义继承需要注意：
          不要仅为了获取其他类中某个功能而去继承，类与类之间要有所属("is a")关系。

三、super关键字和函数覆盖

         super关键字的的用法跟this关键字相同，都是表示对类的引用。

不过super表示的是对父类对象的引用（即父类的内存空间的标识），而this表示的是对本类对象的引用。

1、两者用于成员变量时的区别

         当本类的成员和局部变量同名用this区分。
         当子父类中的成员变量同名用super区分父类。

如：

class fu{private int num = 5;//定义父类属性numpublic int getNum(){return num;}}class zi extends fu{private int num = 1;//定义子类属性num     void show(){System.out.println(this.num+"..."+super.getNum());//使用this跟super区分子父类的引用}}class test{public static void main(String[] args) {zi z = new zi();z.show();}} 

2、函数覆盖

             当子父类中出现成员函数一模一样的情况，会运行子类的函数。  这种现象，称为覆盖操作，这是函数在子父类中的特性。 

 在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

             覆盖一般是在子类中需要父类的功能，而子类又有自己特有的内容，这时就可以复写父类的方法，来实现自己特有的内容。

class fu{void show(){//定义父类功能方法System.out.println("fu is run");}}class zi extends fu{     void show(){//覆盖父类的方法，显示子类特有的内容System.out.println("zi is run");}}class test{public static void main(String[] args) {zi z = new zi();z.show();}} 

注：

a)父类中的私有方法不可以被覆盖。
b)父类为static的方法无法覆盖。
c)覆盖时，子类方法权限一定要大于等于父类方法权限。

3、构造函数

      在子类的构造函数中，第一行有一个默认的隐式语句：super();。

如果使用的是super(4);语句调用父类的其他构造函数，那么默认的父类构造函数将不会再被调用。

4、子类的实例化

        子类所有的构造函数默认都会访问父类的空参数的构造函数，因为每个构造函数的第一行都有一句默认的 super();

为什么捏？因为子类继承了父类的各个属性，所以在使用父类属性时，要先了解父类是怎么对自己的各个属性进行初始化的。

注：

         a)当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函
数。
         b)子类构造函数中如果使用this调用了本类构造函数，那么默认的super();就没有了，因为super和this都只
能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。
         c)super语句必须要定义在子类构造函数的第一行！因为父类的初始化动作要先完成。

5、final关键字

       继承使得对象的封装性被打破，数据的调用也变的更随意。当我们需要一些固定数值不变的数据时，我们就用到了final关键字。它可以修饰类，方法，变量。

final修饰常量的写法：

        常量所有字母都大写，多个单词，中间用_连接。

注：

       被final的类不可被继承。

       被final修饰的方法不可以被覆盖。

        被final修饰的常量只能赋值一次。

如：

class test{public static void main(String[] args) {final int x = 3;x=5;}} 

四、抽象类

            抽象与继承中的父类类似，父类是将子类中的共性内容抽取出来，而抽象则是将多个事物的共性内容抽取出来。

例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。

           在抽象类中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的
类就是抽象类。

例如：每个人都会说话，这是共性的内容，我们可以将说话抽取出来定义成一个抽象的方法。但每个人说话的方式和语气都不一样。

特点：

       抽象类和抽象方法必须用abstract关键字来修饰。
       抽象方法只有方法声明，没有方法体，定义在抽象类中。
       格式：修饰符abstract返回值类型函数名(参数列表);
       抽象类不可以被实例化，也就是不可以用new创建对象。

抽象类中没有具体的内容，是不能实例化的。子类必须要覆盖抽象类中所有的抽象方法才能新建对象。否则子类都还是抽象类。

注：

      抽象类不能跟private、static、final这几个关键字共存。

抽象类与一般类的区别

抽象类抽象类描述事物的信息有可能不足。可定义抽象方法，同时也可以定义非抽象方法。不可以被实例化。一般类一般类有足够的信息描述事物。只能定义非抽象方法。可以被实例化。

不过两者都是用来描述事物的，内部都定义了成员。（抽象类内部可以不定义抽象方法）

                            接口

一、接口的概念

            当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。
格式：interface{}

          java中不支持多继承， 接口的出现是java保留“多继承”的一种体现形式，也就是“多实现”。避免了单继承的局限性。

 

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

          成员常量：public  static  final

          成员函数：public  abstract

由此可见接口中的成员都是公开权限的。而且接口中的方法都是没有方法体的，方便实现类覆盖。

接口是对外暴露的规则。
接口是程序的功能扩展。

注：

         1、只要是接口内的成员，public static final abstract这些关键字自动添加，修饰符是固定的。最好写全。

         2、接口本身就是一个特殊的抽象类所以不能实例化，只能由实现了接口中所有的抽象方法的子类来实例化，否则该子类还是抽象类。

         3、类与类之间是继承关系而且可以多继承，类与接口直接是实现关系： 通过 implements关键字。

一个类可以对接口进行多实现，也弥补了多继承带来的安全隐患，所以java对多继承进行了改良。 用多实现方法来体现多继承的特性。
如：

interface A{public void show();}interface B{public void show();}public class C implements A,B{//多实现，解决了java无法多继承的安全隐患。即多个父类中同名方法指向不清的问题。public static void main(String[] args) {C c = new C();c.show();}public void show() {System.out.println("C is run");}

一个类在继承另一个类的同时，还可以实现多个接口。

interface A{public void show();}interface B{public void show();}class C{public void methos(){System.out.println("class C is run");}}abstract class test extends C implements A,B{//test类或者其父类必须要覆盖show（）方法，否则test类还是抽象类。public static void main(String[] args) {}}

接口之间支持多继承。

如：

interface A,interface B 和 interface C

可以 ： interface C extends A,B｛｝
不过interface C 的实现类必须覆盖 interface A,B,C中的所有抽象方法，否则子类还是抽象类。

抽象类和接口的异同点：

抽象类需要被继承，而且只能单继承。可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。抽象类的继承，是is  a关系，定义该体系的基本共性内容。接口接口需要被实现，而且可以多实现。只能定义抽象方法，必须由子类去实现。接口的实现是like  a关系。

两者都是不断向上抽取而来。

                               包

  一、包的概念   

           包也是一种封装形式，通常写在程序的第一行，它能够对类文件进行分层管理，给类提供多层的命名空间。

类名的全称为：包名.类名。

使用方法：

            直接创建包（pack）文件夹，将.class文件放到pack文件夹中，然后执行。

或者通过javac命令直接创建pack文件夹，然后执行。如：

            javac -d  Demo.java

           java packe.Demo

包之间的访问：被访问的包中的类权限必须是public的。被访问的包中的方法也必须是public的。
类中的成员权限：public或者protected。
protected是为其他包中的子类提供的一种权限。

四种权限：

导包关键字：import

二、java压缩包

                 方便项目的携带。方便于使用，只要在classpath设置jar路径即可。
数据库驱动，SSH框架等都是以jar包体现的。

jar包操作：

通过jar.exe工具对jar的操作。
创建jar包：
jar  -cvf   mypack.jar  packa  packb
查看jar包
jar  -tvf  my  pack.jar  [>定向文件]
解压缩
jar  -xvf  mypack.jar

自定义jar包的清单文件
jar  –cvfm  mypack.jar  mf.txt  packa  packb