疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java面向对象之继承


 

 
继承
介绍
  继承是从已有的类中派生出新的类,新的类能吸收已有类的数据属性和行为,并能扩展新的能力。继承即常说的is-a关系。子类继承父类的特征和行为,使得子类具有父类的各种属性和方法。或子类从父类继承方法,使得子类具有父类相同的行为。
 
 例子:
  比如可以先定义一个类叫车,车有以下属性:车体大小,颜色,方向盘,轮胎,而又由车这个类派生出轿车和卡车两个类,为轿车添加一个小后备箱,而为卡车添加一个大货箱。
 
 继承所表达的就是一种对象类之间的相交关系,它使得某类对象可以继承另外一类对象的数据成员和成员方法。若类B继承类A,则属于B的对象便具有类A的全部或部分性质(数据属性)和功能(操作),我们称被继承的类A为基类、父类或超类,而称继承类B为A的派生类或子类。
 
 表示父类和子类的术语:父类和子类、超类和子类、基类和派生类,他们表示的是同一个意思。
 
为什么需要继承
 
  开发动物类,其中动物分别为企鹅以及老鼠,要求如下:
  企鹅:属性(姓名,id),方法(吃,睡,自我介绍)
  老鼠:属性(姓名,id),方法(吃,睡,自我介绍)
企鹅和老鼠都是动物我们是不是可以写一个动物类,这样代码是不是简洁了许多。有的人说我就想单独建两个类写这个属性,我只能告诉你可以,但这好比,你父亲给你了几百万,你偏不要,把这些钱扔了非要自己去挣,你想这样我也没办法。既然java给我们提供了继承我们就要好好用这样会大大提高我们的开发效率,比如:维护性提高了,代码也更加简洁,提高代码的复用性也提高了(复用性指可以多次使用,不用再多次写同样的代码)。
 
 作用:
 
  1、继承可以减少重复的代码。比如父类已经提供的方法,子类可以直接使用,不必再去实现。
 
  2、继承是多态性的前提。当然使用继承的同时也提高了类的耦合度。
 
  当你不需要父类的属性时,可以覆盖调原属性。
 
Java继承分类
 
  继承分为单继承和多重继承。单继承是指一个子类最多只能有一个父类。多继承是一个子类可以有二个以上的父类。由于多继承会带来二义性,在实际应用中应尽量使用单继承。Java语言中的类只支持单继承,而接口支持多继承。Java中多继承的功能是通过接口(interface)来间接实现的。
 
继承实现
  继承可以使用 extends 和 implements 这两个关键字来实现继承,而且所有的类都是继承于 java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。
 
继承的初始化顺序:
 
  父类—>父类的初始化对象中的属性—>父类的构造方法—>子类—>子类的初始化对象中的属性—>子类的构造方法
 
  若有构造方法:则先执行属性,再执行构造方法
 
  若构造方法中没有对name属性进行赋值,则name的值为类属性所赋的值
 
extends关键字
 
在 Java 中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以 extends 只能继承一个类。
 
 
/*动物类*/
public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
 
/*企鹅是动物,所以可以继承动物类*/
public class Penguin  extends  Animal{ 
//企鹅继承了动物类,所以拥有了动物类的属性和方法
}
implements关键字
 
  使用 implements 关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。
 
public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}
 
super 与 this 关键字
 
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
 注:
  1.只能在构造方法或实例方法内使用super关键字,而在静态方法和静态代码块内不能使用super关键字
 
  2.如果父类中的成员变量和方法被定义为private类型,那么子类永远无法访问它们,如果试图采用super.var的形式去访问父类的private类型的var变量,就会导致编译错误
 
this关键字:指向自己的引用,表示当前正在调用此方法的对象引用。
 
 注:
  1.当具多个重载的构造器时,且一个构造器需要调用另外一个构造其,在其第一行使用this(param)形式调用,且只能在第一行;
 
  2.当对象中一个方法需要调用本对象中其他方法时,使用this作为主调,也可以不写,实际上默认就是this作为主调;
 
  3.当对象属性和方法中的局部变量名称相同时,在该方法中需要显式的使用this作为主调,以表示对象的属性,若不存在此问题,可以不显式的写this。
 
  其实,其牵涉到的一个问题就是变量的查找规则:先局部变量 => 当前类中定义的变量 => 其父类中定义的可以被子类继承的变量 => 父类...
 
这块要完全理解需要看上面我写的“继承的初始化顺序”从这里可以看到程序是如何初始化的。
 
/**
 * 父类
 * @author gacl
 *
 */
class FatherClass {
    public int value;
    public void f() {
        value=100;
        System.out.println("父类的value属性值="+value);
    }
}
 
/**
 * 子类ChildClass从父类FatherClass继承
 */
class ChildClass extends FatherClass {
    /**
     * 子类除了继承父类所具有的valu属性外,自己又另外声明了一个value属性,
     * 也就是说,此时的子类拥有两个value属性。
     */
    public int value;
    /**
     * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现,即重写了f()方法的方法体。
     */
    public void f() {
        super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法
        value=200;//这个value是子类自己定义的那个valu,不是从父类继承下来的那个value
        System.out.println("子类的value属性值="+value);
        System.out.println(value);//打印出来的是子类自定义的那个value的值,这个值是200
        /**
         * 打印出来的是父类里面的value值,由于子类在重写从父类继承下来的f()方法时,
         * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法,
         * 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值,由0变了100。
         * 所以这里打印出来的value值是100。
         */
        System.out.println(super.value);
    }
}
 
/**
 * 测试类
 */
public class TestInherit {
    public static void main(String[] args) {
        ChildClass cc = new ChildClass();
        cc.f();
    }
}
运行结果:
  父类的value属性值=100
  子类的value属性值=200
  200
  100
 
分析:
  执行   ChlidClass cc = new ChlidClass();
 
  首先在栈空间里面会产生一个变量cc,cc里面的值是什么这不好说,总而言之,通过这个值我们可以找到new出来的ChlidClass对象。由于子类ChlidClass是从父类FatherClass继承下来的,所以当我们new一个子类对象的时候,这个子类对象里面会包含有一个父类对象,而这个父类对象拥有他自身的属性value。这个value成员变量在FatherClass类里面声明的时候并没有对他进行初始化,所以系统默认给它初始化为0,成员变量(在类里面声明)在声明时可以不给它初始化,编译器会自动给这个成员变量初始化,但局部变量(在方法里面声明)在声明时一定要给它初始化,因为编译器不会自动给局部变量初始化,任何变量在使用之前必须对它进行初始化。
 
  子类在继承父类value属性的同时,自己也单独定义了一个value属性,所以当我们new出一个子类对象的时候,这个对象会有两个value属性,一个是从父类继承下来的value,另一个是自己的value。在子类里定义的成员变量value在声明时也没有给它初始化,所以编译器默认给它初始化为0。即(父类的value为0,子类的value为0;)
 
  执行第二句话:   cc.f();
 
  当new一个对象出来的时候,这个对象会产生一个this的引用,这个this引用指向对象自身。如果new出来的对象是一个子类对象的话,那么这个子类对象里面还会有一个super引用,这个super指向当前对象里面的父对象。所以相当于程序里面有一个this,this指向对象自己,还有一个super,super指向当前对象里面的父对象。
 
  这里调用重写之后的f()方法,方法体内的第一句话:“super.f();”是让这个子类对象里面的父对象自己调用自己的f()方法去改变自己value属性的值,父对象通过指向他的引用super来调用自己的f()方法,所以执行完这一句以后,父对象里面的value的值变成了100。接着执行“value=200;”这里的vaule是子类对象自己声明的value,不是从父类继承下来的那个value。所以这句话执行完毕后,子类对象自己本身的value值变成了200。