面向对象进阶-接口

接口:就是一种规则,是对行为的抽象。

接口的定义和使用

  • 接口用关键字interface来定义 public interface接口名{}

  • 接口不能被实例化

  • 接口和类之间是实现关系,通过implements关键字表示

  • 接口的子类(实现类):要么重写接口中所有的抽象方法要么是抽象类

    注意:

    1.接口和类的实现关系,可以是单实现也可以是多实现。

    2.实现类还可以在继承一个类的同时实现多个接口。

    package oop.a01interface;
    
    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();
    }
    package oop.a01interface;
    
    public interface Swim {
        public abstract void swim();
    }
    package oop.a01interface;
    
    public class Dog extends Animal implements Swim{
        public Dog() {
        }
    
        public Dog(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println("狗再吃骨头");
        }
    
        @Override
        public void swim() {
            System.out.println("狗在狗刨");
        }
    }
    package oop.a01interface;
    
    public class Fog extends Animal implements Swim{
        public Fog() {
        }
    
        public Fog(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println("青蛙吃虫子");
        }
    
        @Override
        public void swim() {
            System.out.println("青蛙在蛙泳");
        }
    }
    package oop.a01interface;
    
    public class Rabbit extends Animal{
        public Rabbit() {
        }
    
        public Rabbit(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println("吃胡萝卜");
        }
    }
    package oop.a01interface;
    
    public class Test {
        public static void main(String[] args) {
            Dog d =new Dog("大黄",12);
            System.out.println(d.getName()+","+d.getAge());
            d.eat();
            d.swim();
            Rabbit r=new Rabbit("小白",2);
            System.out.println(r.getName()+","+r.getAge());
            r.eat();
        }
    }
    

    接口中成员的特点

  • 成员变量:只能是常量,默认修饰符public static final

  • 构造方法:没有

  • 成员方法:只能是抽象方法,默认修饰符 public abstract

  • JDK7以前:接口中只能定义抽象方法

  • JDK8的新特性:接口中可以定义有方法体的方法

  • JDK9的新特性:接口中可以定义私有方法

    package oop.a02interface;
    
    public interface Inter {
        int a=10;
        void method();
    }
    package oop.a02interface;
    
    public class InterImpl implements Inter{
        @Override
        public void method() {
            System.out.println("method");
        }
    }
    package oop.a02interface;
    
    import java.util.Scanner;
    
    public class Test {
        public static void main(String[] args) {
            System.out.println(Inter.a);
            InterImpl ii=new InterImpl();
            ii.method();
            Scanner sc=new Scanner(System.in);
        sc.next();
        }
    }
    

    接口和类之间的关系

  • 类和类之间的关系:继承关系,只能单继承,不能多继承,但可以多层继承

  • 类和接口之间的关系:实现关系,可以单实现也可以多实现,还可以在继承一个类的同时实现多个接口

    package oop.a03interface;
    
    public interface Inter1 {
        public abstract void method1();
        public abstract void method2();
        public abstract void method3();
    }
    package oop.a03interface;
    
    public interface Inter2 {
        public abstract void method4();
        public abstract void method5();
        public abstract void method6();
    }
    package oop.a03interface;
    
    public class InterImpl implements Inter1,Inter2{
        @Override
        public void method1() {
    
        }
    
        @Override
        public void method2() {
    
        }
    
        @Override
        public void method3() {
    
        }
    
        @Override
        public void method4() {
    
        }
    
        @Override
        public void method5() {
    
        }
    
        @Override
        public void method6() {
    
        }
    }

    接口和接口之间的关系:继承关系,可以单继承也可以多继承

    package oop.a04interface;
    
    public interface Inter1 {
        public abstract void method1();
    }
    package oop.a04interface;
    
    public interface Inter2 {
        public abstract void method2();
    }
    package oop.a04interface;
    
    public interface Inter3 extends Inter1,Inter2{
        public abstract void method3();
    }package oop.a04interface;
    
    public class InterImpl implements Inter3{
    
        @Override
        public void method1() {
    
        }
    
        @Override
        public void method2() {
    
        }
    
        @Override
        public void method3() {
    
        }
    }package oop.a04interface;
    
    public class Test {
        public static void main(String[] args) {
          //接口和接口之间是继承关系,可以是单继承也可以是多继承
          //细节:如果实现类是实现了最下面的子接口,那么就需要重写所有的抽象方法
    
        }
    }
    package oop.a05interface;
    
    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;
        }
    }
    package oop.a05interface;
    
    public abstract class Coach extends Person{
        public Coach() {
        }
    
        public Coach(String name, int age) {
            super(name, age);
        }
        public abstract void teach();
    }
    public abstract class Sporter extends Person{
    
        public Sporter() {
        }
    
        public Sporter(String name, int age) {
            super(name, age);
        }
    
        public abstract void study();
    }
    package oop.a05interface;
    
    public interface English {
        public abstract void speakEnglish();
    }
    package oop.a05interface;
    
    public class BasketBallCoach extends Coach{
        public BasketBallCoach() {
        }
    
        public BasketBallCoach(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void teach() {
            System.out.println("篮球教练在教运动员打篮球");
        }
    }
    package oop.a05interface;
    
    public class BasketBallSporter extends Sporter{
    
        public BasketBallSporter() {
        }
    
        public BasketBallSporter(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void study() {
            System.out.println("篮球运动员在学习打篮球");
        }
    }
    package oop.a05interface;
    
    public class PingPangCoach extends Coach implements English{
    
        public PingPangCoach() {
        }
    
        public PingPangCoach(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void speakEnglish() {
            System.out.println("乒乓球教练在说英语");
        }
    
        @Override
        public void teach() {
            System.out.println("乒乓球教练在教运动员打乒乓球");
        }
    }
    package oop.a05interface;
    
    public class PingPangSporter extends Sporter implements English {
        @Override
        public void speakEnglish() {
            System.out.println("乒乓球运动员在说英语");
        }
    
        @Override
        public void study() {
            System.out.println("乒乓球运动员在学习打乒乓球");
        }
    
        public PingPangSporter() {
        }
    
        public PingPangSporter(String name, int age) {
            super(name, age);
        }
    }
    package oop.a05interface;
    
    public class Test {
        public static void main(String[] args) {
            BasketBallSporter bs=new BasketBallSporter("张三",14);
            System.out.println(bs.getName()+","+bs.getAge());
            bs.study();
            PingPangCoach pc=new PingPangCoach("karry",24);
            System.out.println(pc.getName()+","+pc.getAge());
            pc.teach();
            pc.speakEnglish();
        }
    }

你可能感兴趣的:(java,开发语言)