Day09JavaSE——多态 & 抽象类 & 接口
Day09JavaSE——面向对象之多态 & 抽象类 & 接口
文章目录
- Day09JavaSE——面向对象之多态 & 抽象类 & 接口
- 多态
- 概述与代码体现
- 成员变量 & 成员方法的访问
- ==在多态中记住：成员方法多态，成员变量不多态==
- ==在创建对象的时候要进行类的初始化，过程如下：==
- 多态的作用
- 多态的弊端以及多态中向上转型和向下转型
- 弊端
- 案例分析
- 抽象类
- 概述 & 特点
- 抽象类的成员特点
- 案例分析
- 接口
- 概述 & 特点
- 接口的成员特点
- 类与类,类与接口,接口与接口的关系
- 抽象类和接口的区别
- 猫狗案例加入跳高功能分析及其代码实现
多态(动态绑定机制)
多态的概述
多态的成员访问特点
多态的好处和弊端
向上转型和向下转型
多态内存图
抽象类
抽象类的概述
抽象类的成员特点
抽象类的案例
接口
接口的概述
接口的成员特点
类与类,类与接口,接口与接口的关系
抽象类与接口的区别
接口的案例
多态
概述与代码体现
public class Test {
public static void main(String[] args) {
//面向对象的三大特征：封装、继承、多态
/*多态：指同一种实物在不同时期所表现出的不同状态
* 猫 一只猫 一只动物
* Cat cat = new Cat();
* Animal an = new Cat();*/
//多态的前提：要有继承，如果没有继承多态无从谈起
//多态要有方法重写，当然不重写语法不会报错，但是失去了多态的意义
/*在此处为了便于理解引入两个概念：静态绑定和动态绑定
* 静态绑定：任何成员方法在对象中最后都会有一个调用地址
* 静态方法在类加载的时候就有了，而成员方法要到运行的时候才会绑定地址
* 动态绑定：所有的成员方法在编译的时候是不知道地址的，即在方法表中，指向方法表中方法的地址指针值为null
* 只有运行的时候，因为方法重写的缘故，当父类和子类的成员方法一样时（此处的一样指方法名，形参个数和形参类型都一样）
* 方法表中的指针都指向子类的方法。*/
//父类引用指向子类对象
Cat cat = new Cat();
Animal an = new Cat();
}
}
class Animal {
public void eat(){
System.out.println("eat");
}
}
class Cat extends Animal {
@Override
public void eat() {
System.out.println("eat fish");
}
}
成员变量 & 成员方法的访问
-
在多态中记住：成员方法多态，成员变量不多态
-
在创建对象的时候要进行类的初始化，过程如下：
1、执行静态代码块；
2、执行父类的非静态代码块（包括成员变量的初始化，成员变量和构造代码块同级别）
3、执行父类的构造方法；
4、执行子类的非静态代码块；
5、执行子类的构造函数；
在用多态的形式调用成员方法的时候，系统会自动发生动态绑定，将父类与子类的同名方法（此处指方法名，形参个数和形参类型都一样的方法）都绑定在子类的成员方法上，所以用多态调用同名成员方法，都会去执行子类的成员方法（方法重写的缘故）
而在用多态的形式调用同名成员变量的时候则都会调用父类的成员变量
public class Test {
public static void main(String[] args) {
//采用多态的形式，去访问成员变量与成员方法
//成员变量不多态，成员方法多态
Father fu=new Son();
System.out.println(fu.num);
//此处调用的是子类的show
fu.show();
}
}
class Father{
int num=20;
public void show(){
System.out.println("父类中的show");
}
}
class Son extends Father {
int num=200;
int a=10;
public void show(){
System.out.println("子类中的show");
}
}
多态的作用
public class Test {
public static void main(String[] args) {
/*多态通俗理解：所有继承了同一父类的子类，都可以成为父类类型的数据类型引用
* 例如Animal an；中an变量的数据类型都是Animal类，所有子类都可以送给an*/
/*多态的好处
* 以本例来说明，当发生多态的时候，你只需要知道有一个Animal这个父类
* 然后知道这个父类所包含的子类中的功能成员方法的名字
* 你就可以通过这个父类的对象名去直接调用子类的方法*/
/*所以多态的作用只是为了可以使用父类的类名去访问子类的成员方法
* 这样就可以在封装对象时简化流程，将所有的子类的不同的功能方法都以继承的方式
* 抽取到父类中，这样在调用子类的功能方法时就不需要知道到底有哪些子类
* 例如Java中提供的Math包，直接用Math就可以调用所有的方法体*/
//多态的好处：提高代码的复用性a:提高了代码的维护性(继承保证)
// b:提高了代码的扩展性(由多态保证)
Animal animal1 = new Cat();
Animal animal2 = new Dog();
Animal animal3 = new Rabbit();
Animal animal4 = new Tigger();
Animal animal5 = new Panda();
animal1.eat();
animal2.eat();
animal3.eat();
animal4.eat();
animal5.eat();
}
}
public class Animal {
public void eat(){
System.out.println("吃饭");
}
}
public class Panda extends Animal{
@Override
public void eat() {
System.out.println("我爱吃竹子");
}
}
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("我爱吃鱼");
}
}
public class Dog extends Animal{
@Override
public void eat() {
System.out.println("我爱吃肉");
}
}
public class Rabbit extends Animal{
@Override
public void eat() {
System.out.println("我爱吃草");
}
}
public class Tigger extends Animal{
@Override
public void eat() {
System.out.println("我爱吃所有的小动物");
}
}
多态的弊端以及多态中向上转型和向下转型
弊端
public class Test {
public static void main(String[] args) {
/*多态的弊端：不能直接调用子类特有的功能
即父类和子类中都有的同名成员方法才能多态调用*/
Father f = new Son();
f.show();
//如果要调用子类特有的方法，我们可以将对象向下转型
//以下是两种向下转型的语法，效果都一样
Son zi=(Son) f;
zi.show2();
((Son) f).show2();
//向上转型：把子类型，转换成父类型。多态就是向上转型。
}
}
class Father{
public void show(){
System.out.println("父类的show方法");
}
}
class Son extends Father{
public void show(){
System.out.println("子类的show方法");
}
public void show2(){
System.out.println("子类中特有的show方法");
}
}
public class MyTest {
public static void main(String[] args) {
Animal an=new Cat();
an.eat();
Cat cat= ((Cat) an); //向下转型
cat.catchMouse();
System.out.println("======================");
an = new Dog();
//an.eat();
Dog dog = (Dog) an;
// ClassCastException 类型转换异常
dog.lookDoor();
}
}
class Animal{
public void eat(){
System.out.println("吃饭");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void lookDoor(){
System.out.println("狗看门");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void catchMouse(){
System.out.println("抓老鼠");
}
案例分析
案例一：孔子装爹
public class Practice {
public static void main(String[] args) {
/*案例演示：孔子装爹
* 孔子爹是一个Java讲师，讲课很有名。有一天张三慕名前来，把孔子爹请到家里去讲Java去了。
* 家里就孔子一个人在玩游戏，这个李四，也想学Java，也来请孔子爹，孔子爹不在家，孔子不想失去这个学员。
* 孔子就乔装打扮，装扮成他爹的模样去给李四讲课，其实孔子讲的是论语，孔子好不容易讲完了，
他说装爹太累了，所以卸下装扮，做回他自己，愉快的玩了一把游戏。*/
kongZiFather k = new kongZi();
//成员变量不发生多态，输出父类的60
System.out.println(k.age);
//成员方法发生多态，输出子类的teach
k.teach();
//向下转型，调用子类的特有方法与同名的成员变量
System.out.println(((kongZi) k).age);
((kongZi) k).playGame();
}
}
class kongZiFather{
int age=60;
public void teach(){
System.out.println("我会教Java");
}
}
class kongZi extends kongZiFather{
int age=30;
@Override
public void teach() {
System.out.println("讲论语");
}
public void playGame(){
System.out.println("play game");
}
}
案例二：看下面程序是否有问题，如果没有，说出结果
class Fu {
public void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
public void show() {
System.out.println("zi show");
}
public void method() {
System.out.println("zi method");
}
}
class DuoTaiTest3 {
public static void main(String[] args){
Fu f = new Zi();
f.method();
f.show();
}
}
以上代码有错误，当用多态创建对象时，想要访问该对象所对应的子类所特有的方法或要访问父类与子类同名的在子类中的成员变量，需要将对象向下转型才能访问
所以21行代码应该改为-->
((Zi) f).method;
或者改为
Zi zi=(Zi) f;
运行结果：
zi method
zi show
案例三：看下面程序是否有问题，如果没有，说出结果
class A {
public void show() {
show2();
}
public void show2() {
System.out.println("我");
}
}
class B extends A {
public void show2() {
System.out.println("爱");
}
}
class C extends B {
public void show() {
super.show();
}
public void show2() {
System.out.println("你");
}
}
public class DuoTaiTest4 {
public static void main(String[] args) {
A a = new B();
a.show();
B b = new C();
b.show();
}
}
根据成员变量不多态，成员方法多态
运行结果：
爱
你
抽象类
概述 & 特点
抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
d:抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
public class Test {
public static void main(String[] args) {
/*抽象类：*/
/*抽象类不能直接new对象*/
//Animal animal = new Animal();
//用多态的形式间接的初始化父类
Cat cat = new Cat(); //这里会去初始化父类
Animal an=new Cat(30); //多态的形式初始化父类
System.out.println(cat.num);
System.out.println(an.num);
cat.sleep();
an.sleep();
}
}
public abstract class Animal {
int num=20;
public Animal(){
System.out.println("父类空参构造执行了");
}
public Animal(int num){
this.num=num;
System.out.println(num + "父类的有参构造执行了");
}
public abstract void sleep();//父类知道所有子类都有睡觉功能。但是父类不给出睡觉功能的具体实现
}
public class Cat extends Animal {
int num=50;
public Cat(){
//super访问父类的构造方法，有参访问有参构造，无参访问空参构造
super(80);
System.out.println("Cat的空参构造执行了");
}
public Cat(int num){
//super();这句在缺省时是默认的
//要访问父类的有参构造，需要手动在子类的构造函数中写super(50);否则默认访问空参构造
this.num=num;
System.out.println(num + "子类的有参构造执行了");
}
//继承的父类是抽象类，非抽象类的子类必须重写父类中的抽象类或者将子类声明成抽象类
@Override
public void sleep() {
System.out.println("猫的睡觉习惯");
}
}
抽象类的成员特点
A:抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。
b:构造方法：有。
用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
B:抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。
public class Test {
public static void main(String[] args) {
/*一个抽象类里面可以不用定义抽象方法*/
// 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
//AA aa = new AA(); 报错，因为AA是抽象的，无法实例化
//利用多态去初始化AA
AA b = new BB();
System.out.println(b.num);
b.aa();
}
}
public abstract class AA{
/*一旦一个类，里面定义了抽象方法，此类必须为抽象类*/
int num=200;
public AA(){
System.out.println("aa的构造");
}
public abstract void aa();
}
class BB extends AA{
public BB(){
System.out.println("BB的构造");
}
@Override
public void aa() {
System.out.println("重写了父类的方法");
}
}
案例分析
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.sleep();
dog.lookDoor();
dog.playGame();
System.out.println("=========================");
Cat cat = new Cat();
cat.eat();
cat.sleep();
cat.catchMouth();
cat.playGame();
System.out.println("=========================");
Animal an = new Dog();
an.eat();
an.sleep();
//多态调用子类的特有功能要向下转型
((Dog) an).lookDoor();
an.playGame();
System.out.println("=========================");
an=new Cat();
an.eat();
an.sleep();
//多态调用子类的特有功能要向下转型
((Cat) an).catchMouth();
an.playGame();
// 一个类如果没有抽象方法，可不可以定义为抽象类 ? 如果可以，有什么意义 ?
//可以 。外界不能创建该类对象。
// abstract不能和哪些关键字共存 ?
//private 冲突。矛盾。abstract 强制子类重写。但是private 是私用的，子类都不能继承何谈重写
//final 冲突，矛盾，final修饰的方法，子类不能重写 但是abstract 强制子类重写
//static 没有意义。static 方法不参与重写 但是abstract 强制子类重写
}
}
abstract class Animal{
public abstract void eat();
public abstract void sleep();
public void playGame(){
System.out.println("play game");
/* 冲突。矛盾。abstract 强制子类重写。*/
//但是private 是私用的，子类都不能继承何谈重写
// private abstract void hehe();
//final 冲突，矛盾，final修饰的方法，子类不能重写 但是abstract 强制子类重写
// public final abstract void haha();
// public static abstract void aa();
}
}
class Dog extends Animal{
public void lookDoor(){
System.out.println("狗看门");
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void sleep() {
System.out.println("狗晚上不睡觉");
}
}
class Cat extends Animal{
public void catchMouth(){
System.out.println("猫抓老鼠");
}
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫晚上也不睡觉");
}
}
以上代码补充
A:面试题1
一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
答案: 可以 . 不能创建对象.
B:面试题2
abstract不能和哪些关键字共存?
private 冲突abstract强制子类重写，private是私有的，子类都不能继承何来重写
final 冲突final修饰的方法，子类不能重写，abstract强制子类重写
static 不能共存 无意义 static方法属于类不参与重写
案例演示
假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。
然后定义工作的方法.
请使用继承的思想设计出员工类和经理类。
接口
概述 & 特点
A:接口概述
继续回到我们的猫狗案例，我们想想狗一般就是看门，猫一般就是作为宠物了。
但是，现在有很多的驯养员或者是驯兽师，可以训练出：猫钻火圈，狗跳高，狗做计算等。
而这些额外的动作，并不是所有猫或者狗一开始就具备的，这应该属于经过特殊的培训训练出来的。
所以，这些额外的动作定义到动物类中就不合适，也不适合直接定义到猫或者狗中，因为只有部分猫狗具备这些功能。
所以，为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可
B:接口特点
a:接口用关键字interface表示 格式: interface 接口名 {}
b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
c:接口不能实例化
那么，接口如何实例化呢?
按照多态的方式来实例化。
d:接口的子类
a:可以是抽象类。但是意义不大。
b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)
public class Test {
public static void main(String[] args) {
//接口不能创建对象
//FireInterface f=new FireInterface(); 报错
//子类Dog 实现implements FireInterface父接口
//使用多态的形式来调用子类重写过后的方法
Dog dog = new Dog();
dog.fire();
dog.math();
System.out.println("==============================");
//父类接口指向子类对象
FireInterFace fireInterFace=new Dog();
fireInterFace.fire();
fireInterFace.math();
System.out.println("==============================");
fireInterFace = new Cat();
fireInterFace.math();
fireInterFace.fire();
}
}
class Dog implements FireInterFace{
/*//钻火圈，后天的并非天生，放到类中不合适，类中放天生的属性和行为
public void fire(){}*/
//重写接口的抽象方法
@Override
public void fire() {
System.out.println("狗学会了钻火圈");
}
@Override
public void math() {
System.out.println("狗学会了做数学");
}
}
class Cat implements FireInterFace{
@Override
public void fire() {
System.out.println("猫学会了钻火圈");
}
@Override
public void math() {
System.out.println("猫学会了做数学");
}
}
接口的成员特点
A:接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。
public class MyTest {
public static void main(String[] args) {
//接口的特点
//1.接口中只能定义常量不能定义变量 并且还是公共的静态常量 因为存在默认修饰符 public static final
//2.接口中没有构造方法
//3.接口中的全部是抽象方法，没有非抽象方法 方法前面有默认修饰符 public abstract
System.out.println(MyInterface.NUM);
System.out.println(DD.NUM);
MyInterface myInterface = new DD();
System.out.println(myInterface.NUM);
DD dd = new DD();
System.out.println(dd.NUM);
}
}
//接口的特点
interface MyInterface{
public static final int NUM=200;
//成员变量前面的默认修饰符是 public static final
public static final int a=20;
//方法前面存在默认修饰符 public abstract
public abstract void show1();
int show2();
/* public void test(){
}*/
}
class DD implements MyInterface{
@Override
public void show1() {
}
@Override
public int show2() {
return 0;
}
}
类与类,类与接口,接口与接口的关系
public class Test {
public static void main(String[] args) {
/*类与类：extends继承关系，并且是单继承，支持多层继承
* 类与接口：implement实现关系，可以多实现是，一个类可以实现多个接口*/
/* 一个类在继承一个父类的时候，也可以去实现多个接口
* 接口与接口：可以单继承，也可以多继承*/
}
}
interface AA{
void aa();
}
interface BB{
void bb();
}
interface CC{
void cc();
}
abstract class Father{
public abstract void father();
}
/* 一个类在继承一个父类的时候，也可以去实现多个接口
* 接口与接口：可以单继承，也可以多继承*/
class MyClass extends Father implements AA,BB,CC {
@Override
public int hashCode() {
return super.hashCode();
}
@Override
public void aa() {
}
@Override
public void bb() {
}
@Override
public void cc() {
}
@Override
public void father() {
}
}
//一个接口可以继承多个接口
interface AInterFace{
public abstract void aa();
public abstract void aa1();
}
interface BInterFace{
public abstract void bb();
public abstract void bb1();
}
interface MyInterFace extends AInterFace,BInterFace{
@Override
void aa();
@Override
void aa1();
@Override
void bb();
@Override
void bb1();
}
抽象类和接口的区别
public class Test {
public static void main(String[] args) {
/*抽象类和接口的区别
* 抽象类可以定义成员变量，还可以定义常量
* 接口中定义的都是公共的静态常量
* 抽象类中有构造方法，接口中没有构造方法
* 抽象类中既可以定义抽象方法，也可以定义非抽象方法
* 抽象类中定义的是共性功能，接口定义的是继承体系的扩展功能*/
}
}
abstract class AA{
int num;
public static final int AA=200;
public void show(){
}
public void show2(){}
}
interface BB{
public static final int AA=200;
public abstract void show();
}
public class Test {
public static void main(String[] args) {
//Java中类与类只能单继承
}
}
interface MyInterFace{
void hehe();
//Jdk1.8之后可以在接口中定义default修饰的方法，就可以定义非抽象方法，就可以给出方法的具体实现
//Jdk1.8之后也可以定义静态方法
public default void haha(){
}
}
猫狗案例加入跳高功能分析及其代码实现
public class Teat {
public static void main(String[] args) {
/* A:
案例演示
动物类：姓名，年龄，吃饭，睡觉。
动物培训接口：跳高
猫继承动物类
狗继承动物类
部分猫继承猫类并实现跳高接口
部分狗继承狗类并实现跳高接口
通过抽象类测试基本功能。
通过接口测试扩展功能。*/
/*SaMoYe saMoYe = new SaMoYe();
Dog cat=saMoYe;这句话的效果就是多态创建对象*/
Dog smy=new SaMoYe();
smy.name="萨摩耶";
smy.age=5;
System.out.println("品种"+smy.name);
System.out.println("年龄"+smy.age);
smy.eat();
smy.sleep();
//子类特有的方法需要向下强制转换才能调用
((SaMoYe) smy).jump();
((SaMoYe) smy).lookDoor();
System.out.println("==============================");
Dog hb = new HeiBei();
hb.name="黑背";
hb.age=7;
System.out.println("品种"+hb.name);
System.out.println("年龄"+hb.age);
hb.eat();
hb.sleep();
((HeiBei) hb).jump();
((HeiBei) hb).lookDoor();
System.out.println("==============================");
Cat bo = new BuOu();
bo.name="布偶";
bo.age=2;
System.out.println("品种"+bo.name);
System.out.println("年龄"+bo.age);
bo.eat();
bo.sleep();
((BuOu) bo).jump();
((BuOu) bo).catchMouth();
System.out.println("==============================");
Cat yd = new YingDuan();
yd.name="英短";
yd.age=2;
System.out.println("品种"+yd.name);
System.out.println("年龄"+yd.age);
yd.eat();
yd.sleep();
((YingDuan) yd).jump();
((YingDuan) yd).catchMouth();
}
}
public interface JumpInterFace {
void jump();
}
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫白天睡觉");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void sleep() {
System.out.println("狗晚上睡觉");
}
}
public abstract class Animal {
public String name;
public int age;
public abstract void eat();
public abstract void sleep();
}
public class SaMoYe extends Dog implements JumpInterFace{
@Override
public void eat() {
System.out.println("萨摩耶吃狗粮");
}
@Override
public void sleep() {
System.out.println("萨摩耶睡床");
}
@Override
public void jump() {
System.out.println("萨摩耶学会了跳高");
}
public void lookDoor(){
System.out.println("萨摩耶不会看门");
}
}
public class HeiBei extends Dog implements JumpInterFace{
@Override
public void eat() {
System.out.println("黑背吃肉");
}
@Override
public void sleep() {
System.out.println("黑背睡狗窝");
}
@Override
public void jump() {
System.out.println("黑背学会了跳高");
}
public void lookDoor(){
System.out.println("黑背不仅会看门，还会放羊");
}
}
public class BuOu extends Cat implements JumpInterFace{
@Override
public void eat() {
System.out.println("布偶猫吃小鱼干");
}
@Override
public void sleep() {
System.out.println("布偶猫睡沙发");
}
@Override
public void jump() {
System.out.println("布偶猫很懒，不会跳高");
}
public void catchMouth(){
System.out.println("布偶猫不会抓老鼠");
}
}
public class YingDuan extends Cat implements JumpInterFace{
@Override
public void eat() {
System.out.println("英短猫吃鸡胸肉");
}
@Override
public void sleep() {
System.out.println("英短猫睡猫窝");
}
@Override
public void jump() {
System.out.println("英短猫学会了跳高");
}
public void catchMouth(){
System.out.println("英短猫会抓老鼠");
}
}
ln(“黑背睡狗窝”);
}
@Override
public void jump() {
System.out.println(“黑背学会了跳高”);
}
public void lookDoor(){
System.out.println(“黑背不仅会看门，还会放羊”);
}
}
```java
public class BuOu extends Cat implements JumpInterFace{
@Override
public void eat() {
System.out.println("布偶猫吃小鱼干");
}
@Override
public void sleep() {
System.out.println("布偶猫睡沙发");
}
@Override
public void jump() {
System.out.println("布偶猫很懒，不会跳高");
}
public void catchMouth(){
System.out.println("布偶猫不会抓老鼠");
}
}
public class YingDuan extends Cat implements JumpInterFace{
@Override
public void eat() {
System.out.println("英短猫吃鸡胸肉");
}
@Override
public void sleep() {
System.out.println("英短猫睡猫窝");
}
@Override
public void jump() {
System.out.println("英短猫学会了跳高");
}
public void catchMouth(){
System.out.println("英短猫会抓老鼠");
}
}