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

一、继承

 

继承是所有OOP语言不可缺少的部分，在java中使用extends关键字来表示继承关系。当创建一个类时，总是在继承，如果没有明确指出要继承的类，就总是隐式地从根类Object进行继承。比如下面这段代码：

1 class Person { 2     public Person() { 3           4     } 5 } 6 class Man extends Person { 7     public Man() { 8           9     }10 }

 

类Man继承于Person类，这样一来的话，Person类称为父类（基类），Man类称为子类（导出类）。如果两个类存在继承关系，则子类会自动继承父类的方法和变量，在子类中可以调用父类的方法和变量。在java中，只允许单继承，也就是说 一个类最多只能显示地继承于一个父类。但是一个类却可以被多个类继承，也就是说一个类可以拥有多个子类。

1.子类继承父类的成员变量

　　当子类继承了某个类之后，便可以使用父类中的成员变量，但是并不是完全继承父类的所有成员变量。具体的原则如下：

 

　　1）能够继承父类的public和protected成员变量；不能够继承父类的private成员变量；

　　2）对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员变量，如果在子类中出现了同名称的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽掉父类的同名成员变量。如果要在子类中访问父类中同名成员变量，需要使用super关键字来进行引用。

 

2.子类继承父类的方法

　　同样地，子类也并不是完全继承父类的所有方法。

　　1）能够继承父类的public和protected成员方法；不能够继承父类的private成员方法；

　　2）对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承；否则，子类不能够继承；

　　3）对于子类可以继承的父类成员方法，如果在子类中出现了同名称的成员方法，则称为覆盖，即子类的成员方法会覆盖掉父类的同名成员方法。如果要在子类中访问父类中同名成员方法，需要使用super关键字来进行引用。

 

**注意：隐藏和覆盖是不同的。隐藏是针对成员变量和静态方法的，而覆盖是针对普通方法的。

 

3.构造器

子类是不能够继承父类的构造器，但是要注意的是，如果父类的构造器都是带有参数的，则必须在子类的构造器中显示地通过super关键字调用父类的构造器并配以适当的参数列表。如果父类有无参构造器，则在子类的构造器中用super关键字调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。看下面这个例子就清楚了：

1 class Shape { 2     protected String name; 3     public Shape(){ 4         name = "shape"; 5     } 6     public Shape(String name) { 7         this.name = name; 8     } 9 }10  11 class Circle extends Shape {12     private double radius;13     public Circle() {14         radius = 0;15     }16     public Circle(double radius) {17         this.radius = radius;18     }19     public Circle(double radius,String name) {20         this.radius = radius;21         this.name = name;22     }23 }

 

这样的代码是没有问题的，但是如果把父类的无参构造器去掉，则下面的代码必然会出错，

所以应该修改为：

1 class Shape { 2      3     protected String name; 4     /* 5     public Shape(){ 6         name = "shape"; 7     } 8     */ 9     public Shape(String name) {10         this.name = name;11     }12 }13  14 class Circle extends Shape {15      16     private double radius;17      18     public Circle() {19         super("cicle");20         radius = 0;21     }22      23     public Circle(double radius) {24         super("cicle");25         this.radius = radius;26     }27      28     public Circle(double radius,String name) {29         super("cicle");30         this.radius = radius;31         this.name = name;32     }33 }

 

4.super

　　super主要有两种用法：

　　1）super.成员变量/super.成员方法;

　　2）super(parameter1,parameter2....)

 

第一种用法主要用来在子类中调用父类的同名成员变量或者方法；第二种主要用在子类的构造器中显示地调用父类的构造器，要注意的是，如果是用在子类构造器中，则必须是子类构造器的第一个语句。

二、抽象

 

1、特点：

由abstract修饰，描述类和方法；作为方法的声明，不具体实现

抽象类至少含有一个抽象方法，可有非抽象方法，但不可被实例化，

子类单继承抽象父类，必须实现所有抽象方法才能实例化，否则子类仍为抽象的。

2、细节：

<1.抽象类可以有构造函数，是用于对子类对象的初始化

<2.可定义非抽象方法：抽象类是对事物的描述，只是含有不具体的功能而已，所以抽象类仍需定义属性和行为的。

<3.abstract不可以和final，private，static共存。

<4.抽象类中可不定义抽象方法，抽象的目的是为了不让该类创建对象。

<5.子类继承抽象父类的非抽象方法

例：

1 abstract class fu { 2     private fu() { 3    } // ok 4  5    fu( int a) { 6    } 7     static void show(){}  //ok 8     //abstract int show();  //向上重名 9     abstract int show(int a);  //ok10 }11 12 public class Test01 {13     public static void main(String[] args) {14           //fu f = new fu(); //无法实例化抽象15                       zi z = new zi(1);16           z.show();  //子类继承抽象父类的非抽象方法17    }18 }19 20 //继承21 abstract class zia extends fu{22 23    zia( int a) {24           super(a);25           // TODO Auto-generated constructor stub26    }27    28 }29 30 class zi extends fu{31 32    zi( int a) {33           super(a);34           // TODO Auto-generated constructor stub35    }36 37     @Override38     int show(int a) {39           // TODO Auto-generated method stub40           return 0;41    }42    43 }

 

三、接口

 

接口：初期理解，可以认为是一个特殊的抽象类

     当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类

interface 用于定义接口。

 

接口定义时，格式特点：

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

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

     常量：public static final  接口中的量都终态的

     方法：public abstract

记住：接口中的成员都是public的。

 

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

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

 

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

 

抽象类有构造函数，而接口无构造函数

1 interface A { 2        double a = 1; // 自动加了 终态 public 3        // 常量：public static final 4        public static final double PI = 3.14; 5        //A(){}  //没有 6        void showA();  //自动加了 抽象 public 7 } 8  9 class Test implements A {10        private void show() {11              // a = PI; //不能给a赋值，a默认终态12             System. out.println(a); // ok13       }14        @Override15        public void showA() {16              // TODO Auto-generated method stub17       }18 }19 20 abstract class B implements A{21       B(){} //ok22        double b = PI; //ok23        public void showA() {
   //实现接口的方法 权限必须是 public24       }25 }

 

接口的特点：

l 接口是对外暴露的规则

l 接口是程序的功能拓展

l 接口可以用来多实现

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

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

 

1 abstract class student 2 { 3     abstract void study(); 4     void sleep(){ 5     System.out.printlb("sleep"); 6     } 7 } 8 interface Smoking 9 {10     void smoke();11 }12 class ZhangSan extends Student implements Smoking13 {14     void study(){}15     public void smoke(){}16 }17 class LiSi extends Student18 {19 }20 //基本功能定义在类中，扩展功能定义在接口中21 //需要就实现一下，不需要就算了22 //清楚什么是主体，这么是副业，在体系外就用接口来表示23 abstract class Sporter24 {25     abstract void play();26 }27 interface StudyJava28 {29 }30 class WangWU extends Sporter implements StudyJava31 {32 }33 class StudentDemo 34 {35     public static void main(String[] args) 36     {37         System.out.println("Hello World!");38     }39 }