WHCSRL 技术网

CGBTN2109-DAY10总结回顾

DAY10 复习

1.接口的特点:

  1. 我们使用interface关键字定义接口
  2. 我们使用implements关键字建立接口实现类与接口的实现关系
    接口是父级,接口实现类是子级
  3. 接口实现类如果实现部分/不实现接口中的抽象方法,那么实现类是一个抽象类
    接口实现类如果实现了接口所有的抽象方法,那么这个实现类是一个普通类
  4. 抽象类与接口都不可以实例化/创建对象
  5. 接口没有构造函数,实现类使用的super()是父类的无参构造
    如果没有明确指定父类,super()代表的才是Object的无参构造
  6. 接口中都是静态常量,没有成员变量,因为会默认拼接public static final
  7. 接口中都是抽象方法,默认会拼接public abstract
    故此:静态常量与抽象方法默认拼接的部分,可以省略不写
  8. 接口不是类!!!
  9. 接口是用来制定规则的【有哪些功能?方法有参数吗?有返回值吗?】
    方法具体的实现交给接口的实现类去完成

2. 接口与类的关系

1.类与类的关系

继承关系,只支持单继承

2.类与接口的关系

实现关系,可以单实现,也可以多实现
class A implements Inter1{}–单实现
class B implements Inter2,Inter3{}–多实现

3.接口与接口的关系

是继承关系,可以单继承,也可以多继承
interface Inter3 extends Inter1{}–接口的单继承
interface Inter4 extends Inter1,Inter2{}–接口的多继承
注意:如果创建接口实现类的话:
Inter3Impl只需要实现接口3与接口1的抽象方法
Inter4Impl不仅需要实现接口4,还需要实现接口4继承自接口1与接口2的所有功能

3. 抽象类与接口的区别:

  1. 抽象类使用class关键字定义,是类
    接口使用interface关键字定义,是接口
    2.抽象类里可以定义成员变量
    接口里没有成员变量,有的是静态常量,默认会拼接public static final
    3.抽象类里的方法不作限制:全普、全抽、半普半抽
    接口中的方法都是抽象方法,默认会拼接:public abstract
    4.抽象类与接口均不可以实例化/创建对象
    5.抽象类里有构造方法,不是为了自己使用,而是为了子类创建对象时调用
    接口里没有构造方法,接口实现类调用的构造是父类的构造方法,与接口无关
    6.接口可以多继承,也就是说,一个接口可以继承一个接口/多个接口
    抽象类只能单继承,也就是说,一个子类只能有一个父类
    7.抽象是后天重构的结果,接口是先天设计的结果

4. 练习巩固1

设计学校开学招待所案例
身份:老师 学生 学生家长
吃饭:教师食堂 学生食堂 招待所
住宿:学校公寓 学生宿舍 招待所

  1. 完成Person接口
package cn.tedu.oop;
//1.定义一个接口,描述人这一类事物以及共有功能
public interface Person {
    //面向接口编程:接口的设计要方便和后续实现类的统一
    //2.设计出共同的功能
    void eat();//要吃饭
    void sleep();//要睡觉
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  1. 设计不同的角色实现我们规定的接口
    老师类Teacher
 package cn.tedu.oop;
//3.创建接口实现类
public class Teacher implements Person{
    //4.按照角色的特点实现接口中的两个方法
    @Override
    public void eat() {
        System.out.println("老师在教师食堂吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("老师在学校公寓住宿");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

学生类Student

 package cn.tedu.oop;
//5.创建学生实现类实现Person接口
public class Student implements Person{
    @Override
    public void eat() {
        System.out.println("学生在学校食堂吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("学生在宿舍睡觉");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

家长类Parent

package cn.tedu.oop;
//6.创建家长实现类实现Person接口
public class Parent implements Person{
   @Override
   public void eat() {
       System.out.println("家长在招待所吃饭");
   }

   @Override
   public void sleep() {
       System.out.println("家长在招待所休息");
   }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

测试类

package cn.tedu.oop;
//7.创建测试类
public class TestPerson {
    public static void main(String[] args) {
        //8.分别创建3个接口实现类的对象
        Teacher t = new Teacher();
        Student s = new Student();
        Person p = new Parent();
        //9.通过对象调用方法测试
        t.eat();
        t.sleep();
        s.eat();
        s.sleep();
        p.eat();
        p.sleep();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

5. 练习巩固2

  1. 鸟与昆虫具有飞行的共同功能,就可以定义一个父接口FlyAnimal,描述飞行fly()功能
package cn.tedu.oop2;
/*定义一个接口,描述动物会飞这一功能*/
//1.定义父接口,并定义父接口中飞行的功能
public interface FlyAnimal {
    void fly();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  1. 定义父类小鸟类Bird : 腿的数量为2 ,下蛋数量可以自定义 ,还有下蛋layEggs()的功能
package cn.tedu.oop2;
//2.定义父类小鸟类
abstract public class Bird {
    //3.1定义小鸟类的属性
    int legNumbers = 2;//小鸟腿的数量为2
    int eggNumber;//小鸟下蛋的数量

    //3.2定义小鸟类的方法
    public abstract void layEggs();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  1. 定义父类昆虫类Insect : 腿的数量为6,产卵的数量可以自定义,还有产卵spawn()的功能
package cn.tedu.oop2;
//4.定义父类昆虫类
abstract public class Insect {
    //5.1定义昆虫类的属性
    int legNumbers = 6;//定义腿的数量
    int eggNumber;//定义卵的数量

    //5.2定义昆虫类的方法
    public abstract void spwan();
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  1. 定义小鸟类子级:鸽子类Pigeon:它既会飞,也会下蛋
package cn.tedu.oop2;
//6.创建子类鸽子类
public class Pigeon extends Bird implements FlyAnimal{
    @Override//这个是父抽象类中的下蛋方法
    public void layEggs() {
        System.out.println("鸽子的下蛋数为:"+eggNumber);
    }
    @Override//这个是父接口中的飞行方法
    public void fly() {
        System.out.println("鸽子要飞啦~");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  1. 定义小鸟类子级:燕子类Swallow:它既会飞,也会下蛋,还有自己的特有功能筑巢
package cn.tedu.oop2;
//7.定义子类燕子类
public class Swallow extends Bird implements FlyAnimal{
    @Override//这个是父抽象类中的下蛋方法
    public void layEggs() {
        System.out.println("燕子的下蛋数为:"+eggNumber);
    }
    @Override//这个是父接口中的飞行方法
    public void fly() {
        System.out.println("燕子归巢~");
    }
    public void makeNest(){//子类的特有功能
        System.out.println("燕子在筑巢!");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  1. 定义昆虫类子级:蚂蚁类Ant:它既会飞,也会产卵
package cn.tedu.oop2;
//8.定义子类蚂蚁类--子实现类
public class Ant extends Insect implements FlyAnimal{
    @Override//继承子父接口的方法飞行功能
    public void fly() {
        System.out.println("蚂蚁也会飞~");
    }
    @Override//继承自父抽象类的方法产卵
    public void spwan() {
        System.out.println("蚂蚁的产卵数为:"+eggNumber);
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  1. 定义昆虫类子级:蜜蜂类Bee:它既会飞,也会产卵,还有自己的特有功能制作蜂蜜
package cn.tedu.oop2;
//9.定义子类蜜蜂类
public class Bee extends Insect implements FlyAnimal{
    @Override
    public void fly() {
        System.out.println("蜜蜂也飞啦~");
    }
    @Override
    public void spwan() {
        System.out.println("蜜蜂的产卵数为:"+eggNumber);
    }
    public void makeHoney(){
        System.out.println("蜜蜂在产蜂蜜~");
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

8.测试类

package cn.cxy.exec;
/*本类用作动物设计案例的测试类*/
public class TestAnimals {
    public static void main(String[] args) {
        System.out.println("*********我在测试蚂蚁类**********");
        //1.1创建蚂蚁类对象
        Ant a = new Ant();
        //1.2设置产卵的数量
        a.eggNumber = 300;
        //1.3查看腿的条数--父类中的默认值,没有修改,直接获取
        System.out.println("蚂蚁的腿有"+a.legNumbers+"条");
        //1.4 调用实现后的功能 飞行 产卵
        a.fly();
        a.spawn();
        System.out.println("*********我在测试鸽子类**********");
        //2.1创建鸽子类对象
        Pigeon p = new Pigeon();
        //2.2设置下蛋的数量
        p.eggNumber = 3;
        //2.3查看腿的条数--父类中的默认值,没有修改,直接获取
        System.out.println("鸽子的腿有"+p.legNumbers+"条");
        //2.4 调用实现后的功能 飞行 下蛋
        p.fly();
        p.layEggs();
        System.out.println("*********我在测试燕子类**********");
        //3.1创建燕子类对象
        Swallow s = new Swallow();
        //3.2设置下蛋的数量
        s.eggNumber = 6;
        //3.3查看腿的条数--父类中的默认值,没有修改,直接获取
        System.out.println("燕子的腿有"+s.legNumbers+"条");
        //3.4 调用实现后的功能 飞行 下蛋
        s.fly();
        s.layEggs();
        //3.5调用子类的特有功能--筑巢
        s.makeNest();
        System.out.println("*********我在测试蜜蜂类**********");
        //4.1创建蜜蜂类对象
        Bee b = new Bee();
        //4.2设置产卵的数量
        b.eggNumber = 600;
        //4.3查看腿的条数--父类中的默认值,没有修改,直接获取
        System.out.println("蜜蜂的腿有"+b.legNumbers+"条");
        //4.4 调用实现后的功能 飞行 产卵
        b.fly();
        b.spawn();
        //4.5调用子类的特有功能--产蜂蜜
        b.makeHoney();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  1. 最终的测试效果:
    在这里插入图片描述

6. 内部类

  1. 创建内部类对象的格式:
    外部类名.内部类名 对象名 = 外部类对象.内部类对象
  2. 根据内部类所在位置的不同,分为:
    成员内部类(类里方法外)与局部内部类(方法里)
  3. 内部类可以直接使用外部类的资源,包括私有资源!
  4. 外部类如果想要使用内部类的资源,必须先创建内部类的对象,然后通过内部类对象来调用内部类的资源
推荐阅读