抽象类和接口

什么是抽象类
一个类中如果有抽象方法，那么这个类就必须是一个抽象类
什么是抽象方法
抽象方法指的是没有具体的方法实现
如何定义抽象类和抽象方法
使用abstract关键字来修饰类和方法

抽象类的特点
1.抽象类和抽象方法必须使用abstract关键字修饰
public abstract class 类名{}
public abstract 返回值类型 方法名();
2.抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类
3.抽象类不能实例化，但是可以通过多态的方式创建子类对象
4.抽象类的子类
要么重写抽象父类中所有的抽象方法
要么子类本身也是一个抽象类

/*
抽象类
 */
public abstract class Animal {
    //抽象方法
    public abstract void eat();
    public void sleep(){
        System.out.println("睡觉");
    }

}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
//        Animal a =new Animal();
        Animal a = new Cat();
        a.eat();
        a.sleep();
    }
}

猫吃鱼
睡觉

需求：
猫狗案例抽象类版重点步骤
1.定义动物类Animal
成员变量：name age
构造方法：无参、带参
成员方法：get/set方法、抽象eat()
2.定义猫类Cat，继承Animal
构造方法：无参、带参
成员方法：重写eat()方法
3.定义狗类Dog，继承Animal
构造方法：无参、带参
成员方法：重写eat()方法
4.定义测试类，创建猫狗对象并赋值。调用方法

   1.定义动物类Animal

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

    public Animal() {
    }

    public Animal(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();
}

2.定义猫类Cat，继承Animal

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃老鼠");
    }

    public Cat() {
    }

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

3.定义狗类Dog，继承Animal

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public Dog() {
    }

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

4.定义测试类，创建猫狗对象并赋值。调用方法

public class AnimalDemo {
    public static void main(String[] args) {
        //多态
        Animal a = new Cat();
        a.setName("加肥猫");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("---------");

        a= new Cat("加肥猫",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------------");
        Animal a1 =new Dog();
        a1.setAge(2);
        a1.setName("金毛");
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();
        System.out.println("=======");
        a1 = new Dog("二哈",2);
        System.out.println(a1.getName()+","+a1.getAge());
        a1.eat();

    }
}

打印结果：

加肥猫,5
猫吃老鼠
---------
加肥猫,5
猫吃老鼠
--------------
金毛,2
狗吃骨头
=======
二哈,2
狗吃骨头

接口
接口就是一种公共的规范标准，只要符合规范标准，都可以使用
java中的接口更多的体现在对行为的抽象
接口的特点
1.如何定义接口
public interface 接口名{}
2.如何实现接口
public class 类名 implements 接口名{}
3.接口不能被实例化，可以通过多态形式创建实现类对象
4.接口的实现类
要么重写接口中所有的抽象方法
要么实现类定义为抽象类
需求：
定义接口Jumping，提供抽象jump方法
定义猫类Cat，实现Jumping接口。重写jump方法
通过多态创建对象，调用方法

//定义了一个接口
public interface Jumpping {
    public abstract void jump();
}

public class Cat implements Jumpping {
    @Override
    public void jump() {
        System.out.println("猫可以挑搞了");
    }
}

public  class Dog implements Jumpping {
    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}

/*
    测试类
 */
public class JumppingDemo {
    public static void main(String[] args) {
        Jumpping j = new Cat();
        j.jump();

        Jumpping j1 = new Dog();
        j1.jump();
    }
}

打印结果：
猫可以挑搞了
狗可以跳高了

接口的成员特点
1.成员变量
只能是常量，默认修饰符为：public static final
2.构造方法
接口中没有构造方法
3.成员方法
接口中可以有抽象方法，默认修饰符为：public abstract
JDK8以后可以有静态方法
JDK9以后可以有默认方法

//接口
public interface Inter {
    public int num = 10;//成员变量
    public final int num2 = 20;//final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
    int num3 = 30;//成员变量
//    public inter(){}   不能1有构造方法
//    public  void  show(){}  接口里不能用非抽象方法
    public abstract void method();//只能1抽象的
    void  show();//接口里的方法默认带有  public abstract 修饰符
}

//接口的实现类
//public class InterImpl implements Inter{
public class InterImpl extends Object implements Inter{
    @Override
    public void method() {
        System.out.println("method");
    }

    @Override
    public void show() {
        System.out.println("show");
    }

    public  InterImpl(){
        super();

    }

}

/*
    测试类
 */
public class InterfaceDemo {
    public static void main(String[] args) {
        Inter i = new InterImpl();
        System.out.println(i.num);

        System.out.println(i.num2);
        System.out.println(Inter.num);

    }
}

结果：

10
20
10

需求：
接口版猫狗案例主要步骤
1.定义接口Jumping，提供抽象方法跳高jump
2.定义动物类Animal
成员变量：name age
构造方法、get和set方法
抽象eat方法
3.定义猫类Cat，继承Animal，实现Jumping
重写两个抽象方法
4.定义狗类Dog，继承Animal，实现Jumping
重写两个抽象方法
5.定义测试类，完成代码测试

1.定义接口Jumping，提供抽象方法跳高jump

public interface Jumpping {
    public abstract void jump();
}

2.定义动物类Anima

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

    public Animal() {
    }

    public Animal(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();
}

3.定义猫类Cat，继承Animal，实现Jumping
重写两个抽象方法

public class Cat extends Animal implements Jumpping {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫可以调高了");
    }

    public Cat() {
    }

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

4.定义狗类Dog，继承Animal，实现Jumping
重写两个抽象方法

public class Dog extends Animal implements Jumpping {
    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }

    @Override
    public void jump() {
        System.out.println("狗可一套高了");
    }

    public Dog() {
    }

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

5.定义测试类，完成代码测试

public class AnimalDemo {
    public static void main(String[] args) {
        //先用接口
        Jumpping j =new Cat();
        j.jump();

        System.out.println("---");

        Animal a = new Cat("加肥猫",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("=======");
        Cat c = new Cat();
        c.setName("加肥");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
        System.out.println("----------------");
        Jumpping j1 = new Dog();
        j1.jump();
        System.out.println("===");
        Animal a1 = new Dog();
        a1.setName("金毛");
        a1.setAge(5);
        System.out.println(a1.getName()+a1.getAge());
        a1.eat();
        System.out.println("====");
        Dog d = new Dog();
        d.setName("金毛");
        d.setAge(5);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        d.jump();
    }
}

输出结果

猫可以调高了
---
加肥猫,5
猫吃鱼
=======
加肥,5
猫吃鱼
猫可以调高了
----------------
狗可一套高了
===
金毛5
狗吃肉
====
金毛,5
狗吃肉
狗可一套高了

类和类之间的关系
继承关系，可以单继承，不能多继承，但是可以多层继承
类和接口之间的关系
实现关系，可以单实现，也可以多实现
还可以继承一个类的同时，再实现多个接口
接口和接口之间的关系
继承关系，可以单继承、也可以多继承

抽象类和接口的区别
1.成员区别
抽象类：变量、常量、构造方法、普通方法、抽象方法
接口：常量、抽象方法
2.关系区别
类和类：继承关系，单继承
类和接口：实现关系，单实现、多实现
接口和接口：继承关系，单继承、多继承
3.设计理念区别
抽象类：完成的是一些共性功能的抽取
接口：完成的是一些特性功能的抽取

运动员和教练案例的重要步骤
定义说英语接口 成员方法：说英语();
定义抽象人类 成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法，吃饭();
定义抽象教练类，继承人类 构造方法：无参，带参；成员方法：教();
定义抽象运动员类，继承人类 构造方法：无参，带参；成员方法：学习();
定义具体篮球教练类，继承教练类 构造方法：无参，带参；成员方法：重写吃饭(){…}，重写教(){…}
定义具体乒乓球教练类，继承教练类，实现说英语接口
构造方法：无参，带参；成员方法：重写吃饭(){…}，重写教(){…}，重写说英语(){…}
定义具体篮球运动员类，继承运动员类 构造方法：无参，带参；成员方法：重写吃饭(){…}，重写学习(){…}
定义具体乒乓球运动员类，继承运动员类，实现说英语接口
构造方法：无参，带参；成员方法：重写吃饭(){…}，重写学习(){…}，重写说英语(){…}
定义测试类，写代码测试

定义说英语接口 成员方法：说英语();

//说英语的接口
public interface SpeakEnglish {
    public abstract void speak();
}

定义抽象人类 成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set方法，吃饭();

//抽象人类
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();
}

定义抽象教练类，继承人类 构造方法：无参，带参；成员方法：教();

//抽象教练类
public abstract class Coach extends Person {
    public Coach() {
    }

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

    public abstract void teach();
}

定义抽象运动员类，继承人类 构造方法：无参，带参；成员方法：学习();

//抽象运动员类
public abstract class Player extends Person {
    public Player() {
    }

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

    public abstract void study();
}

定义具体篮球教练类，继承教练类 构造方法：无参，带参；成员方法：重写吃饭(){…}，重写教(){…}

public class BaskerballCoach extends Coach {
    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃盒饭");
    }

    public BaskerballCoach() {
    }

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

定义具体乒乓球教练类，继承教练类，实现说英语接口
构造方法：无参，带参；成员方法：重写吃饭(){…}，重写教(){…}，重写说英语(){…}

public class PingPangCoach extends Coach implements SpeakEnglish {
    @Override
    public void teach() {
        System.out.println("乒乓球教练教握拍");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃大餐");
    }

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

    public PingPangCoach() {
    }

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

定义具体篮球运动员类，继承运动员类 构造方法：无参，带参；成员方法：重写吃饭(){…}，重写学习(){…}

public class BasketballPlayer extends Player  {
    @Override
    public void study() {
        System.out.println("篮球运动员学习运球");
    }

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

    public BasketballPlayer() {
    }

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

定义具体乒乓球运动员类，继承运动员类，实现说英语接口构造方法：无参，带参；成员方法：重写吃饭(){…}，重写学习(){…}，重写说英语(){…}

public class PingPangPlayer extends Player implements SpeakEnglish {
    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习握拍");
    }

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

    public PingPangPlayer() {
    }

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

定义测试类，写代码测试

public class Demo {
    public static void main(String[] args) {
        //创建对象
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("马龙");
        ppp.setAge(35);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.speak();
        ppp.eat();
        ppp.study();

        PingPangCoach ppc = new PingPangCoach("刘国梁",50);
        System.out.println(ppc.getName()+","+ppc.getAge());
        ppc.speak();
        ppc.eat();
        ppc.teach();



    }
}

乒乓球运动员学习握拍
刘国梁,50
乒乓球教练学习英语
乒乓球教练吃大餐
乒乓球教练教握拍