java面向对象（四）

一，继承

1.Java中的继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么，多个类中无需 再定义这些属性和行为，只需要和抽取出来的类构成继承关系。

图片中的猫和狗同属于动物，动物可以有名字，性别等这些共有元素，所以这两类变量就可以视为继承于父类 动物类，而猫吃鱼，狗吃骨头属于猫狗各自的特点，所以吃鱼和吃骨头可以视为二者自己特有的方法，但吃东西也是动物的特点，所以我们就可以认为猫狗类中的吃东西重写了父类 动物类的吃东西方法。如下图所示

2. 继承的好处

    继承的出现减少了代码冗余，提高了代码的复用性。

    继承的出现，更有利于功能的扩展。

    继承的出现让类与类之间产生了is-a的关系，为多态的使用提供了前提。

3. 继承的语法

     通过 extends关键字，可以声明一个类B继承另外一个类A，定义格式如下：

     [修饰符] class 类A {

     ...

                                     }

     [修饰符] class 类B extends 类A {

     ...

                                     }

     类B，称为子类/派生类

     类A，称为父类/基类

4.继承性的细节

   ● 子类会继承父类所有的实例变量和实例方法

   ● 子类不能直接访问父类中私有的(private)的成员变量和方法

   ● 在Java 中，继承的关键字用的是“extends”，表示子类是对父类的扩展

   ● Java支持多层继承(继承体系)

   ● 一个父类可以同时拥有多个子类

   ● Java只支持单继承，不支持多重继承

5.Object类

       类 java.lang.Object,是类层次结构的根类，即所有其它类的父类。每个类

  都使用 Object作为超类。

       当一个类没有显示的继承其他类时,默认继承Object类。

6.方法的重写

      

当父类的方法功能实现不能满足子类需求时 , 可以对方法进行重写 ( override).

子类可以对从父类中继承来的方法进行改造，我在程序执行时，子类的方法

将覆盖父类的方法。们称为方法的重写也称为方法的覆盖。

注意：构造方法 , 静态方法不能重写 , 成员变量不存在重写 面向对象特征 -- 继承

● 方法重写的规则

1. 子类重写的方法必须和父类被重写的方法名称,参数列表相同。

2. 子类重写的方法的返回值类型与父类保存一致。

3. 子类重写的方法使用的访问权限不能小于父类被重写方法的访问权限。

注意：① 父类私有方法不能重写 ② 跨包的父类默认权限的方法也不能重写

4. 子类方法抛出的异常不能大于父类被重写方法的异常

比如动物，猫狗的关系，猫狗的eat与动物不同，所以猫狗的eat需要进行方法的重写

例如：

package jicheng;

public class Animal {
    String name;
    int age;
    public Animal()
    {

    }
public Animal(String name,int age)
{
this.age=age;
this.name=name;
}

    public String getName() {
        System.out.println("名字是"+name);
        return name;
    }

    public void setName(String name) {
        this.name = name;

    }

    public int getAge() {
        System.out.println(age+"岁");
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void gongyou()
    {
        System.out.println("大耳朵");
        System.out.println("四条腿");
        System.out.println("chu生");
    }
}

上面这是一段父类  animal的代码

package jicheng;

public class doggod extends Dog{

    public doggod()
    {
        super();
        System.out.println("dog无参构造方法");
    }
    public doggod(String name,int age)
    {
        super(name,age);
    }

    public void fly()
    {
        System.out.println("腾云驾雾");
    }
    public void skill()
    {
        System.out.println("地爆天星");
        System.out.println("安装爆能器");
        System.out.println("手搓核弹");
    }
    @Override
public void eatshit()
{
    super.eatshit();
    this.fly();
    System.out.println(" 吃高级shi");
}
}

这是一段子类doggod继承于animal的代码，可以看到其中用到了@Override重写了方法eatshit

l @Override使用说明：

@Override是java中定义的注解标签,用来进行标记(进阶部分细讲)

写在方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。

这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。建议保留，这

样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这

是一个重写的方法。 面向对象特征 -- 继承

l super 关键字

在 Java 类中使用 super 来调用父类中的指定操作：

super 可用于访问父类中定义的属性

super 可用于调用父类中定义的成员方法

super 可用于在子类构造器中调用父类的构造器

注意：

尤其当子父类出现同名成员时，可以用 super 表明调用的是父类中的成员

super 的追溯不仅限于直接父类还可以是父类的父类

super 和 this 的用法相像， this 代表本类对象的引用， super 代表父类的内存空间

的标识 面向对象特征 -- 继承

误区: 不要把super误认为是父类对象,在创建子类对象时,不会创建父类对象.

只会将父类中的信息加载到子类对象中存储. 面向对象特征 -- 继承

● 继承中的构造方法

l 子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)”

的方式调用父类指定的构造方法。

l 规定super(形参列表)，必须声明在构造器的首行。

l 如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器

默认调用super()，即调用父类中空参的构造器。

l 这么做是为了保证先对父类成员进行初始化。

开发中常见错误：

l 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参

的构造器，则编译出错。

二，抽象类

l 抽象方法

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现 .

抽象方法必须用 abstract 关键字进行修饰 . 抽象类

● 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

● 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和

构造方法。

● 用 abstract 修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须

定义成抽象类。

● 特点 :

• 抽象类不能被实例化，但可以有构造方法 , 因为抽象类中含有无具体实现的方法，

所以不能用抽象类创建对象。

• 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现

其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否

则，该类也必须声明为抽象类。 抽象类

l 使用关键字 abstract 定义抽象类，一般语法：

[访问权限] abstract class 类名 {

成员列表

}

public abstract class Shapes {

public abstract void draw();

} 抽象类

● 抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，

设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并

覆盖抽象方法，实现具体功能

package choux;

public abstract class abstractman extends Person{
    public abstractman(){}
    public abstract void behavior();

}

这是一个absstractman抽象父类，可以看到这个类里面只有一个无参构造方法和一个没有具体实现功能的方法 behavior；

package choux;

public class sunxiaochuan extends abstractman{
    String name;
    int age;
    public sunxiaochuan(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    public void behavior()
    {
        System.out.println("网恋被骗8000块");
    }

}

这里可以看到子类sunxiaochuan继承于父类abstractman并把具体的成员变量和方法behavior内容补完

package choux;

public class testchouxx {
    public static void main(String[] args) {


        sunxiaochuan xiaosun = new sunxiaochuan("孙笑川",158);

        xiaosun.behavior();
        System.out.println(xiaosun.name+xiaosun.age);
        System.out.println("年龄:"+xiaosun.age);
    }
}

这里是main函数内实例化对象后调用sunxiaochuan类的方法

这里是具体运行的结果