标签：
------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); //ok 10 } 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 stub 26 } 27 28 } 29 30 class zi extends fu{ 31 32 zi( int a) { 33 super(a); 34 // TODO Auto-generated constructor stub 35 } 36 37 @Override 38 int show(int a) { 39 // TODO Auto-generated method stub 40 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); // ok 13 } 14 @Override 15 public void showA() { 16 // TODO Auto-generated method stub 17 } 18 } 19 20 abstract class B implements A{ 21 B(){} //ok 22 double b = PI; //ok 23 public void showA() {//实现接口的方法 权限必须是 public 24 } 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 Smoking 13 { 14 void study(){} 15 public void smoke(){} 16 } 17 class LiSi extends Student 18 { 19 } 20 //基本功能定义在类中，扩展功能定义在接口中 21 //需要就实现一下，不需要就算了 22 //清楚什么是主体，这么是副业，在体系外就用接口来表示 23 abstract class Sporter 24 { 25 abstract void play(); 26 } 27 interface StudyJava 28 { 29 } 30 class WangWU extends Sporter implements StudyJava 31 { 32 } 33 class StudentDemo 34 { 35 public static void main(String[] args) 36 { 37 System.out.println("Hello World!"); 38 } 39 }
标签：
原文地址：http://www.cnblogs.com/ZkSnug/p/4457404.html
