面向对象特征（2）---继承

继承的含义：

继承是面向对象编程中的一个重要特征，通过继承，一个类可以从另一个类中继承属性和方法。子类可以重用父类的代码，并且可以在不改变父类的情况下进行扩展。这样可以提高代码的复用性和可维护性

 猫和狗 都用有名字,年龄,吃东西的属性和行为.
 
 可以将这些共性的属性和行为进行抽取,这样就不需要在每个类中定义同样属性和行为,
 只需要类与类之间建立继承关系即可.

将他们共有的属性写到一个类里

public class anmlies {
    private String name;
    private  int age;
    public anmlies(){}

    public anmlies(String name,int age){}

    public  void eat(){
        System.out.println("吃东西");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

 在它们的类里就只用写它们共有的属性

比如 猫可以抓老鼠，狗不行，狗可以看家，猫不行

public class dog extends anmlies {
 public void lookhome(){
        System.out.println("看家");

    }
}

 

public class cat extends anmlies{
    public void catcht(){
        System.out.println("抓老鼠");
       
    }
}

总结：子类 使用extends关键字继承另一个类

一个类只能直接继承一个类，间接的可以继承多个类，称为继承的传递，

子类继承父类后，拥有了父亲的成员变量和成员方法，但是不能直接访问父亲私有成员

dog继承animal

dog称为子类

animal称为父类

继承的好处

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

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

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

继承性的细节

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

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

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

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

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

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

方法重写：

当父类中的方法的实现不能满足子类需求时，可以在子类中对父类的方法进行重写（覆盖）

这样调用时，就会调用子类中重写的方法。

方法重写的要求：

子类重写的方法的结构 与 父类方法结构必须一致

注意：构造方法,静态方法不能重写,成员变量不存在重写

@Override使用说明：

@Override是java中定义的注解标签,用来进行标记(进阶部分细讲) 写在方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。 这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。建议保留，这 样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这 是一个重写的方法。

代码举例：

  @Override
    public void eat() {
        System.out.println("狗吃骨头");

    }

    public void lookhome(){
        System.out.println("看家");

    }

 

  public  void eat(){
        System.out.println("吃东西");
    }

因为动物吃东西也存在差异，所以我们可以用方法重写改变狗吃东西这个方法。

super关键字

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

super可用于访问父类中定义的属性 super可用于调用父类中定义的成员方法 super可用于在子类构造器中调用父类的构造器

注意： 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员 super的追溯不仅限于直接父类还可以是父类的父类 super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间 的标识

  public void lookhome(){
        System.out.println("看家");
         super.eat();
    }

public  void eat(){
        System.out.println("吃东西");
    }

总结：   super.成员变量
       super.成员方法(常用) 当子类中重写了父类方法时,
       为了区分调用的是父类中还是子类中重写的方法,使用super调用父类中的.

继承中的构造方法

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

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

如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器 默认调用super()，即调用父类中空参的构造器。

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

public class dog extends anmlies {

    public dog(){
        super();
    }
    public dog(String name,int age){
      super(name,age);
    }}

public class anmlies {
    private String name;
    private  int age;
    public anmlies(){}

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

    }}

 继承中的构造方法的调用:
        总是在子类的构造方法中,会去使用super()调用父类的构造方法.
        为了确保对父类成员进行初始化.    

抽象类

 抽象方法: 只有方法声明(定义 public void test()),没有具体的实现

Animal
   eat(){
      动物吃东西
   }
动物类型很大,在类体系结构位于上层,里面实现与大多数子类实现都可能不一样.   
 在上层类中实现功能,就没有必要了,但是程序设计时,应该在上层定义这一类型应该有什么功能.
 
 然后让子类继承父类,在子类中对抽象方法进行重写

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

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

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

 特点:

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

 抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现 其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否 则，该类也必须声明为抽象类。

package oop03.jcanlimal.cx;

public abstract class Anlimal {
    private String name;
    private  int age;

    public Anlimal() {
    }

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

    public  abstract void eat();
}

public class cxdog extends Anlimal{
    public cxdog(){
        //super();
    }

    public cxdog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class Anlimaltest {
    public static void main(String[] args) {
        cxdog cxdog=new cxdog();
        cxdog.eat();

    }


}

 总结：抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说， 设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并 覆盖抽象方法，实现具体功能。