抽象类，接口，形参和返回值

1.抽象类

1.1抽象类的概述

    当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！

1.2抽象类的特点

（1）抽象类合抽象方法必须使用abstract关键字修饰

public abstract class 类名{}

public abstract void eat();

（2）抽象类中不一定有抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！

（3）抽象类 不能实例化

        抽象类想要实列化，参照多态的方法，通过子类对象实列化，这叫抽象类多态。

（4）抽象的子类

        要么重写抽象类中所有抽象方法，要么时抽象类。

1.3抽象类的成员特点

（1）成员变量（变量或者常量）

（2）构造方法（不能实例化，用抽象类多态）

（3）成员方法（可以有抽象方法：限定子类必须完成某动作）

                       （也可以有非抽象方法：提高代码的复用率）

2.接口

2.1接口的概述

     接口就是一种公共的规范标准，只要符合规范标准，大家都可以使用。

      Java中的接口更多体现在对行为的抽象。

2.2接口的特点

（1）接口用关键字interface修饰

public interface 接口名{}

（2）类实现接口用implements接口名{}

public class 类名implements 接口名{}

（3）接口不能实例化（参照多态的方法，接口多态）

        多态的形式：具体类动态，抽象类多态，接口类多态。

       多态的前提：有继承或者是实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

（4）接口的实现类

        要么重写接口中的所有抽象方法。

       要么是抽象类。

2.3接口的成员特点

（1）成员变量

          只能是常量

          默认修饰符：public static final

（2）构造方法

           接口没有构造方法，因为接口主要是对行为进行抽象的，没有具体存在

           一个类如果没有父类，默认继承Object类。（Object是超类）

（3）成员方法

         只能是抽象方法 

         默认修饰符：public abstract

2.4类和接口的关系

（1）类和类的关系：

          继承关系，只能单继承，但是可以多层继承

（2）类合接口的关系

  

          实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。

（3）接口和接口的关系

          继承关系，可以单继承，也可多继承。

3.抽象类接口的区别

3.1成员区别

   抽象类：变量，常量；有构造方法；有抽象方法，也有非抽象方法。

   接口：常量；抽象方法

3.2关系区别

    类与类：继承，单继承

    类与接口：实现，可以单实现，也可以多实现。

    接口与接口：继承，单继承，多继承。

抽象类是对事物的抽象，而接口是对行为的抽象

4.案例

4.1 运动员和教练

package com.test11;
//抽象人类
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    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 abstract void eat();
}

package com.test11;
//抽象教练类
public abstract class Coach extends Person{
    public Coach() {
    }

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

    //教的抽象方法
    public abstract void teach();


}

package com.test11;
//抽象运动员类
public abstract class Player extends Person{
    public Player() {
    }

    public Player(String name, int age) {
        super(name, age);
    }
    public abstract void study();

}

package com.test11;
//具体的篮球教练类
public class BasketballCoach extends Coach{
    public BasketballCoach() {
    }

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

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }
}

package com.test11;
//具体的篮球运动员类
public class BasketballPlayer extends Player{
    public BasketballPlayer() {
    }

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

    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝羊奶");
    }
}

package com.test11;
//具体乒乓球教练类
public class PingPangCoach extends Coach implements SpeakEnglish{
    public PingPangCoach() {
    }

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

    @Override
    public void teach() {
        System.out.println("乒乓球教练如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练教吃小白菜，喝大米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

package com.test11;
//具体的乒乓球运动员类
public class PingPangPlayer extends Player implements SpeakEnglish{
    public PingPangPlayer() {
    }

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

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃小白菜，喝大米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}

package com.test11;
//说英语的接口
public interface SpeakEnglish {
    //说英语的抽象方法
    void speak();
}

package com.test11;
//测试类
public class PersonDemo {
    public static void main(String[] args) {
        PingPangPlayer ppp = new PingPangPlayer("小白",19);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.study();
        ppp.eat();
        ppp.speak();
        System.out.println("------------");

        PingPangCoach pp = new PingPangCoach("海德堡",30);
        System.out.println(pp.getName()+","+pp.getAge());
        pp.teach();
        pp.eat();
        pp.speak();
        System.out.println("------------");

        BasketballPlayer bbp = new BasketballPlayer("姚明",35);
        System.out.println(bbp.getName()+","+bbp.getAge());
        bbp.study();
        bbp.eat();
        System.out.println("------------");

        BasketballCoach bbc = new BasketballCoach("萨迪克",35);
        System.out.println(bbc.getName()+","+bbc.getAge());
        bbc.teach();
        bbc.eat();
        System.out.println("------------");


    }
}

5.形参和返回值

5.1类名作为形参和返回值

（1）方法的形参是类名，其实需要的是该类的对象。

（2）方法的返回值是类名，其实返回的是该类的对象。

//猫的操作类CatOperator

public void useCat(Cat c){      //相当于Cat c = new Cat();

        c.eat();

}

public Cat getCat(){

        Cat c = new Cat();

        return c;

}

//测试类

CatOperator co = new CatOperator();

        Cat c = new Cat();

        co.useCat(c);

        

        Cat c2 = co. getCat();//     Cat c2 = new Cat()

        c2.eat();

}

5.2抽象类名作为形参和返回值

（1）方法的形参是抽象类名，其实需要的是该抽象类的子类对象

（2）方法的返回值是抽象类名，其实 返回的是该抽象类的子类对象。

5.3接口名作为形参和返回值

（1）方法的形参是接口名，其实需要的是该接口的实现类的对象。

（2）方法的返回值是接口名，其实返回的是该接口的实现类对象。