精华内容
下载资源
问答
  • java抽象类和接口详解

    2021-03-01 10:24:12
    抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。抽象类我们都知道在面向...

    接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。

    抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。

    一、抽象类

    我们都知道在面向对象的领域一切都是对象,同时所有的对象都是通过类来描述的,但是并不是所有的类都是来描述对象的。如果一个类没有足够的信息来描述一个具体的对象,而需要其他具体的类来支撑它,那么这样的类我们称它为抽象类。比如new Animal(),我们都知道这个是产生一个动物Animal对象,但是这个Animal具体长成什么样子我们并不知道,它没有一个具体动物的概念,所以他就是一个抽象类,需要一个具体的动物,如狗、猫来对它进行特定的描述,我们才知道它长成啥样。

    在面向对象领域由于抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能实例化的。

    同时,抽象类体现了数据抽象的思想,是实现多态的一种机制。它定义了一组抽象的方法,至于这组抽象方法的具体表现形式有派生类来实现。同时抽象类提供了继承的概念,它的出发点就是为了继承,否则它没有存在的任何意义。所以说定义的抽象类一定是用来继承的,同时在一个以抽象类为节点的继承关系等级链中,叶子节点一定是具体的实现类。

    在使用抽象类时需要注意几点:

    1、抽象类不能被实例化,实例化的工作应该交由它的子类来完成,它只需要有一个引用即可。

    2、抽象方法必须由子类来进行重写。

    3、只要包含一个抽象方法的抽象类,该方法必须要定义成抽象类,不管是否还包含有其他方法。

    4、抽象类中可以包含具体的方法,当然也可以不包含抽象方法。

    5、子类中的抽象方法不能与父类的抽象方法同名。

    6、abstract不能与final并列修饰同一个类。

    7、abstract 不能与private、static、final或native并列修饰同一个方法。、

    实例:

    定义一个抽象动物类Animal,提供抽象方法叫cry(),猫、狗都是动物类的子类,由于cry()为抽象方法,所以Cat、Dog必须要实现cry()方法。如下:public abstract class Animal {

    public abstract void cry();

    }

    public class Cat extends Animal{

    @Override

    public void cry() {

    System.out.println("猫叫:喵喵...");

    }

    }

    public class Dog extends Animal{

    @Override

    public void cry() {

    System.out.println("狗叫:汪汪...");

    }

    }

    public class Test {

    public static void main(String[] args) {

    Animal a1 = new Cat();

    Animal a2 = new Dog();

    a1.cry();

    a2.cry();

    }

    }

    --------------------------------------------------------------------

    Output:

    猫叫:喵喵...

    狗叫:汪汪...

    创建抽象类和抽象方法非常有用,因为他们可以使类的抽象性明确起来,并告诉用户和编译器打算怎样使用他们.抽象类还是有用的重构器,因为它们使我们可以很容易地将公共方法沿着继承层次结构向上移动。(From:Think in java )

    二、接口

    接口是一种比抽象类更加抽象的“类”。这里给“类”加引号是我找不到更好的词来表示,但是我们要明确一点就是,接口本身就不是类,从我们不能实例化一个接口就可以看出。如new Runnable();肯定是错误的,我们只能new它的实现类。

    接口是用来建立类与类之间的协议,它所提供的只是一种形式,而没有具体的实现。同时实现该接口的实现类必须要实现该接口的所有方法,通过使用implements关键字,他表示该类在遵循某个或某组特定的接口,同时也表示着“interface只是它的外貌,但是现在需要声明它是如何工作的”。

    接口是抽象类的延伸,java了保证数据安全是不能多重继承的,也就是说继承只能存在一个父类,但是接口不同,一个类可以同时实现多个接口,不管这些接口之间有没有关系,所以接口弥补了抽象类不能多重继承的缺陷,但是推荐继承和接口共同使用,因为这样既可以保证数据安全性又可以实现多重继承。

    在使用接口过程中需要注意如下几个问题:

    1、个Interface的方所有法访问权限自动被声明为public。确切的说只能为public,当然你可以显示的声明为protected、private,但是编译会出错!

    2、接口中可以定义“成员变量”,或者说是不可变的常量,因为接口中的“成员变量”会自动变为为public static final。可以通过类命名直接访问:ImplementClass.name。

    3、接口中不存在实现的方法。

    4、实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。

    5、不能使用new操作符实例化一个接口,但可以声明一个接口变量,该变量必须引用(refer to)一个实现该接口的类的对象。可以使用 instanceof 检查一个对象是否实现了某个特定的接口。例如:if(anObject instanceof Comparable){}。

    6、在实现多接口的时候一定要避免方法名的重复。

    三、抽象类与接口的区别

    尽管抽象类和接口之间存在较大的相同点,甚至有时候还可以互换,但这样并不能弥补他们之间的差异之处。下面将从语法层次和设计层次两个方面对抽象类和接口进行阐述。

    3.1语法层次

    在语法层次,java语言对于抽象类和接口分别给出了不同的定义。下面已Demo类来说明他们之间的不同之处。

    使用抽象类来实现:public abstract class Demo {

    abstract void method1();

    void method2(){

    //实现

    }

    }

    使用接口来实现interface Demo {

    void method1();

    void method2();

    }

    抽象类方式中,抽象类可以拥有任意范围的成员数据,同时也可以拥有自己的非抽象方法,但是接口方式中,它仅能够有静态、不能修改的成员数据(但是我们一般是不会在接口中使用成员数据),同时它所有的方法都必须是抽象的。在某种程度上来说,接口是抽象类的特殊化。

    对子类而言,它只能继承一个抽象类(这是java为了数据安全而考虑的),但是却可以实现多个接口。

    3.2设计层次

    上面只是从语法层次和编程角度来区分它们之间的关系,这些都是低层次的,要真正使用好抽象类和接口,我们就必须要从较高层次来区分了。只有从设计理念的角度才能看出它们的本质所在。一般来说他们存在如下三个不同点:

    1、 抽象层次不同。抽象类是对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。

    2、 跨域不同。抽象类所跨域的是具有相似特点的类,而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分,然后泛化成抽象类,子类继承该父类即可,但是接口不同。实现它的子类可以不存在任何关系,共同之处。例如猫、狗可以抽象成一个动物类抽象类,具备叫的方法。鸟、飞机可以实现飞Fly接口,具备飞的行为,这里我们总不能将鸟、飞机共用一个父类吧!所以说抽象类所体现的是一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在"is-a" 关系,即父类和派生类在概念本质上应该是相同的。对于接口则不然,并不要求接口的实现者和接口定义在概念本质上是一致的, 仅仅是实现了接口定义的契约而已。

    3、 设计层次不同。对于抽象类而言,它是自下而上来设计的,我们要先知道子类才能抽象出父类,而接口则不同,它根本就不需要知道子类的存在,只需要定义一个规则即可,至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里,如果你这是就抽象成一个动物类,是不是设计有点儿过度?我们起码要有两个动物类,猫、狗在这里,我们在抽象他们的共同点形成动物抽象类吧!所以说抽象类往往都是通过重构而来的!但是接口就不同,比如说飞,我们根本就不知道会有什么东西来实现这个飞接口,怎么实现也不得而知,我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的,接口是自顶向下设计出来的。

    为了更好的阐述他们之间的区别,下面将使用一个例子来说明。

    我们有一个Door的抽象概念,它具备两个行为open()和close(),此时我们可以定义通过抽象类和接口来定义这个抽象概念:

    抽象类:abstract class Door{

    abstract void open();

    abstract void close();

    }

    接口interface Door{

    void open();

    void close();

    }

    至于其他的具体类可以通过使用extends使用抽象类方式定义Door或者Implements使用接口方式定义Door,这里发现两者并没有什么很大的差异。

    但是现在如果我们需要门具有报警的功能,那么该如何实现呢?

    解决方案一:给Door增加一个报警方法:clarm();abstract class Door{

    abstract void open();

    abstract void close();

    abstract void alarm();

    }

    或者interface Door{

    void open();

    void close();

    void alarm();

    }

    这种方法违反了面向对象设计中的一个核心原则 ISP (Interface Segregation Principle)—见批注,在Door的定义中把Door概念本身固有的行为方法和另外一个概念"报警器"的行为方 法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为"报警器"这个概念的改变而改变,反之依然。

    解决方案二

    既然open()、close()和alarm()属于两个不同的概念,那么我们依据ISP原则将它们分开定义在两个代表两个不同概念的抽象类里面,定义的方式有三种:

    1、两个都使用抽象类来定义。

    2、两个都使用接口来定义。

    3、一个使用抽象类定义,一个是用接口定义。

    由于java不支持多继承所以第一种是不可行的。后面两种都是可行的,但是选择何种就反映了你对问题域本质的理解。

    如果选择第二种都是接口来定义,那么就反映了两个问题:1、我们可能没有理解清楚问题域,AlarmDoor在概念本质上到底是门还报警器。2、如果我们对问题域的理解没有问题,比如我们在分析时确定了AlarmDoor在本质上概念是一致的,那么我们在设计时就没有正确的反映出我们的设计意图。因为你使用了两个接口来进行定义,他们概念的定义并不能够反映上述含义。

    第三种,如果我们对问题域的理解是这样的:AlarmDoor本质上Door,但同时它也拥有报警的行为功能,这个时候我们使用第三种方案恰好可以阐述我们的设计意图。AlarmDoor本质是们,所以对于这个概念我们使用抽象类来定义,同时AlarmDoor具备报警功能,说明它能够完成报警概念中定义的行为功能,所以alarm可以使用接口来进行定义。如下:abstract class Door{

    abstract void open();

    abstract void close();

    }

    interface Alarm{

    void alarm();

    }

    class AlarmDoor extends Door implements Alarm{

    void open(){}

    void close(){}

    void alarm(){}

    }

    这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实抽象类表示的是"is-a"关系,接口表示的是"like-a"关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。

    批注:ISP(Interface Segregation Principle):面向对象的一个核心原则。它表明使用多个专门的接口比使用单一的总接口要好。一个类对另外一个类的依赖性应当是建立在最小的接口上的。 一个接口代表一个角色,不应当将不同的角色都交给一个接口。没有关系的接口合并在一起,形成一个臃肿的大接口,这是对角色和接口的污染。

    四、总结

    1、 抽象类在java语言中所表示的是一种继承关系,一个子类只能存在一个父类,但是可以存在多个接口。

    2、 在抽象类中可以拥有自己的成员变量和非抽象类方法,但是接口中只能存在静态的不可变的成员数据(不过一般都不在接口中定义成员数据),而且它的所有方法都是抽象的。

    3、抽象类和接口所反映的设计理念是不同的,抽象类所代表的是“is-a”的关系,而接口所代表的是“like-a”的关系。

    抽象类和接口是java语言中两种不同的抽象概念,他们的存在对多态提供了非常好的支持,虽然他们之间存在很大的相似性。但是对于他们的选择往往反应了您对问题域的理解。只有对问题域的本质有良好的理解,才能做出正确、合理的设计。

    展开全文
  • 接口和内部类为我们提供了种将接口与实现分离的更加结构化的方法抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大...

    接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法

    抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。

    一、抽象类

    我们都知道在面向对象的领域一切都是对象,同时所有的对象都是通过类来描述的,但是并不是所有的类都是来描述对象的。如果一个类没有足够的信息来描述一个具体的对象,而需要其他具体的类来支撑它,那么这样的类我们称它为抽象类。比如new Animal(),我们都知道这个是产生一个动物Animal对象,但是这个Animal具体长成什么样子我们并不知道,它没有一个具体动物的概念,所以他就是一个抽象类,需要一个具体的动物,如狗、猫来对它进行特定的描述,我们才知道它长成啥样。

    在面向对象领域由于抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能实例化的。

    同时,抽象类体现了数据抽象的思想,是实现多态的一种机制。它定义了一组抽象的方法,至于这组抽象方法的具体表现形式有派生类来实现。同时抽象类提供了继承的概念,它的出发点就是为了继承,否则它没有存在的任何意义。所以说定义的抽象类一定是用来继承的,同时在一个以抽象类为节点的继承关系等级链中,叶子节点一定是具体的实现类。

    在使用抽象类时需要注意几点:

    抽象类不能被实例化,实例化的工作应该交由它的子类来完成,它只需要有一个引用即可。

    抽象方法必须由子类来进行重写。

    只要包含一个抽象方法的抽象类,该方法必须要定义成抽象类,不管是否还包含有其他方法。

    抽象类中可以包含具体的方法,当然也可以不包含抽象方法。

    子类中的抽象方法不能与父类的抽象方法同名。

    abstract不能与final并列修饰同一个类。

    abstract 不能与private、static、final或native并列修饰同一个方法。

    实例:

    定义一个抽象动物类Animal,提供抽象方法叫cry(),猫、狗都是动物类的子类,由于cry()为抽象方法,所以Cat、Dog必须要实现cry()方法。如下:

    public abstract class Animal {

    public abstract void cry();      }

    public class Cat extends Animal{

    @Override

    public void cry() {

    System.out.println("猫叫:喵喵...");        }

    }

    public class Dog extends Animal{

    @Override

    public void cry() {

    System.out.println("狗叫:汪汪...");

    }

    }

    public class Test {

    public static void main(String[] args) {          Animal a1 = new Cat();

    Animal a2 = new Dog();

    a1.cry();

    a2.cry();

    }

    }

    --------------------------------------------------------------------

    Output:

    猫叫:喵喵...

    狗叫:汪汪...

    创建抽象类和抽象方法非常有用,因为他们可以使类的抽象性明确起来,并告诉用户和编译器打算怎样使用他们,抽象类还是有用的重构器,因为它们使我们可以很容易地将公共方法沿着继承层次结构向上移动。(From: Think in java)

    二、接口

    接口是一种比抽象类更加抽象的“类”。这里给“类”加引号是我找不到更好的词来表示,但是我们要明确一点就是,接口本身就不是类,从我们不能实例化一个接口就可以看出。如new Runnable();肯定是错误的,我们只能new它的实现类。

    接口是用来建立类与类之间的协议,它所提供的只是一种形式,而没有具体的实现。同时实现该接口的实现类必须要实现该接口的所有方法,通过使用 implements关键字,他表示该类在遵循某个或某组特定的接口,同时也表示着“interface只是它的外貌,但是现在需要声明它是如何工作的”。

    接口是抽象类的延伸,java了保证数据安全是不能多重继承的,也就是说继承只能存在一个父类,但是接口不同,一个类可以同时实现多个接口,不管这些接口之间有没有关系,所以接口弥补了抽象类不能多重继承的缺陷,但是推荐继承和接口共同使用,因为这样既可以保证数据安全性又可以实现多重继承。

    在使用接口过程中需要注意如下几个问题:

    个Interface的方所有法访问权限自动被声明为public。确切的说只能为public,当然你可以显示的声明为protected、private,但是编译会出错!

    接口中可以定义“成员变量”,或者说是不可变的常量,因为接口中的“成员变量”会自动变为为public static final。可以通过类命名直接访问:ImplementClass.name。

    接口中不存在实现的方法。

    实现接口的非抽象类必须要实现该接口的所有方法。抽象类可以不用实现。

    不能使用new操作符实例化一个接口,但可以声明一个接口变量,该变量必须引用(refer to)一个实现该接口的类的对象。可以使用 instanceof 检查一个对象是否实现了某个特定的接口。例如:if(anObject instanceof Comparable){}。

    在实现多接口的时候一定要避免方法名的重复。

    三、抽象类与接口的区别

    尽管抽象类和接口之间存在较大的相同点,甚至有时候还可以互换,但这样并不能弥补他们之间的差异之处。下面将从语法层次和设计层次两个方面对抽象类和接口进行阐述。

    3.1语法层次

    在语法层次,java语言对于抽象类和接口分别给出了不同的定义。下面已Demo类来说明他们之间的不同之处。

    使用抽象类来实现:

    public abstract class Demo {

    abstract void method1();      void method2(){

    //实现

    }

    }

    使用接口来实现

    interface Demo {

    void method1();      void method2();

    }

    抽象类方式中,抽象类可以拥有任意范围的成员数据,同时也可以拥有自己的非抽象方法,但是接口方式中,它仅能够有静态、不能修改的成员数据(但是我们一般是不会在接口中使用成员数据),同时它所有的方法都必须是抽象的。在某种程度上来说,接口是抽象类的特殊化。

    对子类而言,它只能继承一个抽象类(这是java为了数据安全而考虑的),但是却可以实现多个接口。

    3.2设计层次

    上面只是从语法层次和编程角度来区分它们之间的关系,这些都是低层次的,要真正使用好抽象类和接口,我们就必须要从较高层次来区分了。只有从设计理念的角度才能看出它们的本质所在。一般来说他们存在如下三个不同点:

    抽象层次不同。抽象类是对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。

    跨域不同。抽象类所跨域的是具有相似特点的类,而接口却可以跨域不同的类。我们知道抽象类是从子类中发现公共部分,然后泛化成抽象类,子类继承该父类即可,但是接口不同。实现它的子类可以不存在任何关系,共同之处。例如猫、狗可以抽象成一个动物类抽象类,具备叫的方法。鸟、飞机可以实现飞Fly接口,具备飞的行为,这里我们总不能将鸟、飞机共用一个父类吧!所以说抽象类所体现的是一种继承关系,要想使得继承关系合理,父类和派生类之间必须存在”is-a” 关系,即父类和派生类在概念本质上应该是相同的。对于接口则不然,并不要求接口的实现者和接口定义在概念本质上是一致的, 仅仅是实现了接口定义的契约而已。

    设计层次不同。对于抽象类而言,它是自下而上来设计的,我们要先知道子类才能抽象出父类,而接口则不同,它根本就不需要知道子类的存在,只需要定义一个规则即可,至于什么子类、什么时候怎么实现它一概不知。比如我们只有一个猫类在这里,如果你这是就抽象成一个动物类,是不是设计有点儿过度?我们起码要有两个动物类,猫、狗在这里,我们在抽象他们的共同点形成动物抽象类吧!所以说抽象类往往都是通过重构而来的!但是接口就不同,比如说飞,我们根本就不知道会有什么东西来实现这个飞接口,怎么实现也不得而知,我们要做的就是事前定义好飞的行为接口。所以说抽象类是自底向上抽象而来的,接口是自顶向下设计出来的。

    为了更好的阐述他们之间的区别,下面将使用一个例子来说明。该例子引自:http://blog.csdn.net/ttgjz/article/details/2960451

    我们有一个Door的抽象概念,它具备两个行为open()和close(),此时我们可以定义通过抽象类和接口来定义这个抽象概念:

    抽象类:

    abstract class Door{

    abstract void open();

    abstract void close();

    }

    接口

    interface Door{

    void open();    void close();

    }

    至于其他的具体类可以通过使用extends使用抽象类方式定义Door或者Implements使用接口方式定义Door,这里发现两者并没有什么很大的差异。

    但是现在如果我们需要门具有报警的功能,那么该如何实现呢?

    解决方案一:

    给Door增加一个报警方法:clarm();

    abstract class Door{

    abstract void open();

    abstract void close();

    abstract void alarm();

    }

    或者

    interface Door{

    void open();

    void close();

    void alarm();

    }

    这种方法违反了面向对象设计中的一个核心原则 ISP (Interface Segregation Principle)—见批注,在Door的定义中把Door概念本身固有的行为方法和另外一个概念”报警器”的行为方 法混在了一起。这样引起的一个问题是那些仅仅依赖于Door这个概念的模块会因为”报警器”这个概念的改变而改变,反之依然。

    解决方案二:

    既然open()、close()和alarm()属于两个不同的概念,那么我们依据ISP原则将它们分开定义在两个代表两个不同概念的抽象类里面,定义的方式有三种:

    两个都使用抽象类来定义。

    两个都使用接口来定义。

    一个使用抽象类定义,一个是用接口定义。

    由于java不支持多继承所以第一种是不可行的。后面两种都是可行的,但是选择何种就反映了你对问题域本质的理解。

    如果选择第二种都是接口来定义,那么就反映了两个问题:

    我们可能没有理解清楚问题域,AlarmDoor在概念本质上到底是门还报警器。

    如果我们对问题域的理解没有问题,比如我们在分析时确定了AlarmDoor在本质上概念是一致的,那么我们在设计时就没有正确的反映出我们的设计意图。因为你使用了两个接口来进行定义,他们概念的定义并不能够反映上述含义。

    第三种,如果我们对问题域的理解是这样的:AlarmDoor本质上Door,但同时它也拥有报警的行为功能,这个时候我们使用第三种方案恰好可以阐述我们的设计意图。AlarmDoor本质是们,所以对于这个概念我们使用抽象类来定义,同时AlarmDoor具备报警功能,说明它能够完成报警概念中定义的行为功能,所以alarm可以使用接口来进行定义。如下:

    abstract class Door{

    abstract void open();

    abstract void close();

    }

    interface Alarm{

    void alarm();

    }

    class AlarmDoor extends Door implements Alarm{

    void open(){}

    void close(){}

    void alarm(){}

    }

    这种实现方式基本上能够明确的反映出我们对于问题领域的理解,正确的揭示我们的设计意图。其实抽象类表示的是”is-a”关系,接口表示的是”like-a”关系,大家在选择时可以作为一个依据,当然这是建立在对问题领域的理解上的,比如:如果我们认为AlarmDoor在概念本质上是报警器,同时又具有Door的功能,那么上述的定义方式就要反过来了。

    批注:

    ISP(Interface Segregation Principle):面向对象的一个核心原则。它表明使用多个专门的接口比使用单一的总接口要好。

    一个类对另外一个类的依赖性应当是建立在最小的接口上的。

    一个接口代表一个角色,不应当将不同的角色都交给一个接口。没有关系的接口合并在一起,形成一个臃肿的大接口,这是对角色和接口的污染。

    四、总结

    抽象类在java语言中所表示的是一种继承关系,一个子类只能存在一个父类,但是可以存在多个接口。

    在抽象类中可以拥有自己的成员变量和非抽象类方法,但是接口中只能存在静态的不可变的成员数据(不过一般都不在接口中定义成员数据),而且它的所有方法都是抽象的。

    抽象类和接口所反映的设计理念是不同的,抽象类所代表的是“is-a”的关系,而接口所代表的是“like-a”的关系。

    抽象类和接口是java语言中两种不同的抽象概念,他们的存在对多态提供了非常好的支持,虽然他们之间存在很大的相似性。但是对于他们的选择往往反应了您对问题域的理解。只有对问题域的本质有良好的理解,才能做出正确、合理的设计。

    来源:chenssy

    链接:http://www.cnblogs.com/chenssy/p/3376708.html

    展开全文
  • 要求定义一个抽象的动物类,该类中有一个抽象的捕食方法,和一个非抽象的进食方法。在进食方法中调用捕食方法。定义3个不同的动物类,分别是老虎、猴子和狼,这些类继承抽象的动物类。 实现思路:定义抽象类动物...

    返回本章节

    返回作业目录

    需求说明:

    不同的动物都有进食的行为,但是在进食前需要捕获到食物后才可以进食。

    要求定义一个抽象的动物类,该类中有一个抽象的捕食方法,和一个非抽象的进食方法。在进食方法中调用捕食方法。

    定义3个不同的动物类,分别是老虎、猴子和狼,这些类继承抽象的动物类。

    09a65f223f580c6becf286c1a0d237f0.png

    实现思路:

    定义抽象类动物Animal,在其中定义捕食抽象方法predation()和非抽象进食方法eat(),并在进食方法中调用捕食方法。

    创建3个动物类,分别是老虎类Tigger、猴子类Monkey和狼类Wolf,定义动物抽象父类,在这三个动物类中重写捕食方法。

    创建测试类Test,在该类主方法中创建不同的动物对象,并调用它们的进食方法。

    实现代码:

    抽象类动物Animal:

    public abstract class Animal {

    //定义捕食抽象方法

    public abstract void predation();

    //定义非抽象进食方法

    public void eat() {

    System.out.println("嚼碎食物,讲嚼碎食物咽进肚子里。。。。");

    }

    }

    老虎类Tigger:

    public class Tigger extends Animal{

    //继承重写predation()方法

    @Override

    public void predation() {

    System.out.println("老虎单枪匹马作战发现猎物一击致命");

    }

    }

    猴子类Monkey:

    public class Monkey extends Animal{

    //继承重写predation()方法

    @Override

    public void predation() {

    System.out.println("猴子优哉游哉的爬到树上采摘香蕉");

    }

    }

    狼类Wolf:

    public class Wolf extends Animal{

    //继承重写predation()方法

    @Override

    public void predation() {

    System.out.println("狼王有组织的安排不是进攻计划");

    }

    }

    测试类Test:

    public class Test {

    public static void main(String[] args) {

    Animal tigger = new Tigger();

    tigger.predation();

    tigger.eat();

    Animal monkey = new Monkey();

    monkey.predation();

    monkey.eat();

    Animal wolf = new Wolf();

    wolf.predation();

    wolf.eat();

    }

    }

    展开全文
  • 创建一个抽象类动物类以及以下几个接口:进食的接口、睡觉的接口、思考的接口、说话的接口。分别定义猫类、人类、鸟类继承动物类并选择实现上述的接口,并创建实例验证。 上代码 package ThirdDay; public abstract...

    创建一个抽象类动物类以及以下几个接口:进食的接口、睡觉的接口、思考的接口、说话的接口。分别定义猫类、人类、鸟类继承动物类并选择实现上述的接口,并创建实例验证。

    上代码

    package ThirdDay;
    
    public abstract class Animal {
         public abstract void eat();
         public abstract void sleep();
         public abstract void think();
         public abstract void speak();
    }
    
    class Cat extends Animal{
        public Cat() {
        }
    
        @Override
        public void eat() {
            System.out.println("喵星人吃猫粮");
        }
    
        @Override
        public void sleep() {
            System.out.println("喵星人成天睡觉");
        }
    
        @Override
        public void think() {
            System.out.println("喵星人可以思考,也可以思考怎样抓你");
        }
    
        @Override
        public void speak() {
            System.out.println("喵星人喵~~");
        }
    }
    class Bird extends Animal{
        public Bird() {
        }
    
        @Override
        public void eat() {
            System.out.println("鸟能吃");
        }
    
        @Override
        public void sleep() {
            System.out.println("鸟可以睡觉");
        }
    
        @Override
        public void think() {
            System.out.println("鸟可以思考迁徙");
        }
    
        @Override
        public void speak() {
            System.out.println("鸟能渣渣叫");
        }
    }
    class Human extends Animal{
        public Human() {
        }
    
        @Override
        public void eat() {
            System.out.println("人是杂食动物");
        }
    
        @Override
        public void sleep() {
            System.out.println("人能睡觉");
        }
    
        @Override
        public void think() {
            System.out.println("人的可以思考,大脑十分活跃");
        }
    
        @Override
        public void speak() {
            System.out.println("人类的语言有许多种");
        }
    }
    
    class All{
        public static void main(String[] args) {
         Human human=new Human();
         human.eat();
         human.sleep();
         human.speak();
         human.think();
         Cat cat=new Cat();
         cat.eat();
         cat.sleep();
         cat.speak();
         cat.think();
         Bird bird=new Bird();
         bird.eat();
         bird.think();
         bird.speak();
         bird.sleep();
        }
    }
    

    运行结果如下

    人类的语言有许多种
    人的可以思考,大脑十分活跃
    喵星人吃猫粮
    喵星人成天睡觉
    喵星人喵~~
    喵星人可以思考,也可以思考怎样抓你
    鸟能吃
    鸟可以思考迁徙
    鸟能渣渣叫
    鸟可以睡觉
    
    展开全文
  • java抽象类求解

    2021-03-01 10:24:03
    publicclassDoTest{publicstaticvoiddoThis(Dodo_){//用抽象类做参数do_.doWhat();}publicstaticvoidmain(Stringargs[]){Doa=newDoA();Dob=newDoB();doThis(a);d...package testAbstract;public class ...
  • JAVA 抽象类,抽象方法

    千次阅读 2021-04-22 21:18:22
    一个抽象类Animal中有一个抽象方法run.public class Animal{public abstract void run();}那么他的子类必须要实现run这个方法。不是实现的话编译就会报错。public class Dog{@Overridepublic void r...
  • 使用Java定义一个动物类

    千次阅读 2021-09-02 16:21:19
    定义一个动物类 属性:name 方法:enjoy() 注:表示宠物开心后的行为 定义一个继承于动物类 包含的属性:furColor 重写enjoy()方法 定义一个继承与动物类 包含的属性:eyesColor 重写enjoy()方法 定义一个...
  • JAVA 抽象类

    千次阅读 2021-03-01 08:03:17
    一、抽象类的概念C extends B, B extends A 在继承过程中,形成了一个继承金字塔。位于金字塔底部的类越来越具体(强大),位于金字塔顶部的类越来越抽象(简单)。例如:人类继承于(属于)动物类,鱼类继承于(属于)动物...
  • Java抽象类概述

    千次阅读 2020-12-31 11:28:47
    抽象类的定义抽象类是为子类提供一个规范,这就必须联系到继承;抽象类的制定就是让子类继承的;public abstract 类名{//类体//抽象方法修饰符 abstract 返回值类型 方法名(参数列表);}*抽象方法没有方法体:public...
  • Java抽象类模仿动物的叫声

    千次阅读 2019-09-29 22:06:48
    接口:Animal public interface Animal { public void cry(); public String getAnimalName(); } Cat; public class Cat implements Animal { @Override public void cry() { System.out.println(...
  • Java抽象类\多态

    2021-02-13 01:32:36
    1抽象类什么时候使用?当某个父类只是知道子类应该包含怎么样的方法,但是无法准确知道子类如何实现这些方法。比如一个图形类应该有一个求周长的方法,但是不同的图形求周长的算法不一样。那该怎么办呢?(分析事物时...
  • /*** 抽象类继承* 用abstract修饰类就是抽象类* 用abstract修饰方法就是抽象方法(一般使用比较少)* 抽象类不能被实例化*/public classMain {public static voidmain(String[] args) {Animal an= newCat();...
  • 定义一个抽象的"Role",有姓名,年龄,性别等成员变量 1)要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有), 再通过Getter()和Setter()方法对各变量进行读写。具有一个抽象的play()方法, ...
  • java 抽象类和接口

    2021-03-08 21:28:30
    抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。抽象类我们都知道在面向...
  • 一个饲养员给动物喂食物的例子体现JAVA中的面向对象思想,接口(抽象类)的用处interface Animal{//动物的接口 public void eat(Food food);//接口中只有抽象的方法和静态常量!这里void前面省略了abstract。同样,...
  • Java 抽象类与接口

    2021-03-05 19:54:16
    抽象类与接口是 Java 语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予 Java 强大的面向对象的能力。他们两者之间对抽象概念的支持有很大的相似,甚至可以互换,但是也有区别。抽象类我们都知道在...
  • 1)对组对象进行更高层次级抽象时,形成抽象的类,就可以定义为抽象类 2)抽象类不能实例化对象,抽象类的引用需要赋值子类对象
  • 狮子拥有动物的一切基本特性,但同时又拥有自己的独特的特性,这就是"继承"关系的重要特性:通常简称为"IS_A"关系,UML类图可以这么表示:继承的语法class 子类名 extends 父类名 {……}注意:父类(parent class)和...
  • 一、多态性多态是指一个对象可以拥有多种不同的形态,继承是实现多态的基础。1.1 引用多态和方法多态引用多态:父类引用可以指向本的对象,也可以指向子类的对象方法多态:1、创建对象时,调用的方法为本...
  • 抽象类语法规则:首先我们来看段代码:class Shape{public void draw(){}}class Cycle extends Shape{@Overridepublic void draw(){System.out.println("⚪");}}class Rect extends Shape {@Overridepublic void ...
  • JAVA抽象类及接口使用方法解析抽象类可以有自己的成员变量,继承抽象类的对象共用成员变量,也可以修改成员变量的值。可以有非抽象的方法。接口只能有static final的成员变量(一般不使用),只能有抽象的方法。public...
  • 抽象类 定义:抽象类就是含有抽象方法的类,在解决实际问题时,一般将父类定义为抽象类,需要使用这父类进行继承与多态处理,回想继承和多态的原理,继承树越是在上方的类越抽象。抽象类无法通过创建对象来实现...
  • Java抽象类Animal和Cat

    千次阅读 2018-11-09 13:58:31
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类抽象类除了不能实例化对象之外,...
  • 、抽象(abstract)的使用当父类的某些方法不确定时,可以用abstract关键字来修饰该方法[抽象方法],用abstract来修饰该类[抽象类]。我们都知道,父类是将子类所共同拥有的属性和方法进行抽取,这些属性和方法中,有...
  • 原文:http://blog.csdn.net/sunboard/article/details/3831823 1....合理时,你底层的具体实现需要考虑的Java抽象类与接口都可以实现功能与实现的分离,都对多态提供了很好的支持,那么我们什么时候应该使用抽象...
  • Java抽象类

    2021-05-30 15:26:05
    java抽象类介绍一、抽象类的...比如new Animal(),我们都知道这个是产生一个动物Animal对象,但是这个Animal具体长成什么样子我们并不知道,它没有一个具体动物的概念,所以他就是一个抽象类,需要一个具体的动物,如
  • 定义抽象类animal ,从中派生3具体类:Dog,Cat,Duck,每子类覆盖父类的抽象方法。每种动物发出的声音为串字符串。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,802
精华内容 5,920
关键字:

创建一个动物抽象类java

java 订阅