精华内容
下载资源
问答
  • 需求说明: 不同的动物都有进食的行为,但是在进食前需要捕获到食物后才可以进食。 要求定义一个抽象的动物,该中有... 创建3个动物类,分别是老虎Tigger、猴子Monkey和狼Wolf,定义动物抽象父类,在这.

    返回本章节

    返回作业目录


    需求说明:

    • 不同的动物都有进食的行为,但是在进食前需要捕获到食物后才可以进食。
    • 要求定义一个抽象的动物类,该类中有一个抽象的捕食方法,和一个非抽象的进食方法。在进食方法中调用捕食方法。
    • 定义3个不同的动物类,分别是老虎、猴子和狼,这些类继承抽象的动物类。

    实现思路:

    1. 定义抽象类动物Animal,在其中定义捕食抽象方法predation()和非抽象进食方法eat(),并在进食方法中调用捕食方法。
    2. 创建3个动物类,分别是老虎类Tigger、猴子类Monkey和狼类Wolf,定义动物抽象父类,在这三个动物类中重写捕食方法。
    3. 创建测试类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();
    		
    	}
    
    }
    

     

    展开全文
  • Java抽象类

    2018-04-19 21:30:56
    抽象类的特点比如我们在定义一个动物类的时候我们先给他定义一个eat的方法,这个方法不需要有实际的功能在他的子类猫、狗等等中我们再具体去实现他的功能这个时候父类中就可以定义抽象类抽象类需要用abstract修饰...

    抽象类的特点

    1. 比如我们在定义一个动物类的时候我们先给他定义一个eat的方法,这个方法不需要有实际的功能在他的子类猫、狗等等中我们再具体去实现他的功能这个时候父类中就可以定义抽象类。
    2. 抽象类需要用abstract修饰,同样抽象的方法也是。
    3. 抽象类不能被实例化,就是不能创建对象,只有抽象类的具体化子类才能创建对象。
    4. 抽象类的子类必须去实现抽象类中的抽象方法,就是要重写父类中抽象的方法。
    5. 抽象类的子类也可以是抽象类但是没有实际的意义,所以实际开发中子类必须将抽象类的所有抽象方法重写
    6. 抽象类只是事先声明一下这个方法,没有实际的内容。
    7. 抽象类中不一定有抽象的方法但是只要包含一个抽象的方法这个类必定是抽象类。
    8. 抽象类对成员变量没有限制,既可以是变量也可以是常量。
    9. 不能抽象构造方法,构造方法是对类的初始化,不能继承。

    抽象类的定义方式如下:

    abstract class Animal {
    	public abstract void eat(); // 抽象的方法,只需要声明即可。
    
    	public void sleep() { // 抽象类也可以有具体的方法,会被子类继承
    		System.out.println("睡觉");
    	}
    }
    
    class Cat extends Animal {
            @Override        
            public void eat() { // 子类对父类抽象方法的实现
    		System.out.println("猫吃鱼");
    	}
    
    }
    
    public class Text {
    	public static void main(String[] args) {
    		Animal a = new Cat(); // 多态,抽象父类的引用指向子类的对象
    		a.eat();
    		a.sleep();
    	}
    }
    /**
    输出为:
    猫吃鱼
    睡觉
     */
    

    抽象类的实例化实际上均是由多态来实现的:如上代码中实例化过程:

    Animal a = new Cat();

    注意:

    因为抽象类中的抽象方法必须通过子类重写去实现,所以abstroct和以下关键字冲突:

    final,被final修饰的方法是最终的不能被继承所以也不能被重写。

    private,被private修饰的方法子类是无法直接去访问的,所以就不能实现父类的抽象方法

    static,被static修饰的方法是相对于类的,可以被继承,但是不能被重写,子类中如果定义相同的静态方法此时继承的父类静态方法会被隐藏而不是被重写。

    @Override

    @Override表示重写,是伪代码,没有具体的功能,可以不写,但是写上有它的好处:

    1. @Override需要写在重写的方法上面,紧挨着重写的方法,不能写在方法体内。
    2. 当加上@Override的时候编译器会检查@Override下面方法重写是否正确,如果方法名拼写错误编译器会报错,相反如果不加@Override编译器会认为是一个新的方法。
    3. 增加程序的阅读性,直观告诉阅读者这是一个重写的方法。

    抽象类的作用

    • 当父类中的某个方法需要被他所有的子类重写时就可以将这个方法定义为抽象方法。
    • 一个类中没有抽象方法但却定义为抽象类的作用之一是 可以限制不让该类创建对象。
    • 抽象类因为不能创建对象所以抽象类的构造方法只能通过子类去访问。
    展开全文
  • “他并不喜欢你,只是喜欢被你喜欢,偶尔会对你示好,是怕你不喜欢他,怕突然失去被你爱慕的那种虚荣,就像狗跑远了主人会叫一下它的名字一样。”——网易云音乐热评《人设》java ...class Animal//创建一个动物类{ ...

    “他并不喜欢你,只是喜欢被你喜欢,偶尔会对你示好,是怕你不喜欢他,怕突然失去被你爱慕的那种虚荣,就像狗跑远了主人会叫一下它的名字一样。”

    ——网易云音乐热评《人设》

    fe1dc400bed07be07488ca0a1830ca38.pnge07043ede7ab50156120c7f13f2461d0.pngjava -- 抽象类8498ee92423350aa71d72cc6c0289ab5.png
    • 目录

      • 抽象类

        • 概念

        • 特点

        • 案例

      • 抽象类的用法

        • 构造函数

        • 成员变量

        • 成员方法

        • 案例

    fe1dc400bed07be07488ca0a1830ca38.png

    e07043ede7ab50156120c7f13f2461d0.png8498ee92423350aa71d72cc6c0289ab5.png为什么要有抽象类?我们先来啰嗦几句。举一个简单的例子。先看一下下列代码。
    class Animal            //创建一个动物类{  String name;  int age;  public void cry()    //动物会叫  {    System.out.println("叫啥呢?");    //怎么个叫法  }}class Dog extends Animal    //狗继承了动物类{  @Override  public void cry()    //狗类重写了方法  {    System.out.println("汪!汪!");  }}class Cat extends Animal    //猫继承了动物类{  @Override  public void cry()    //猫类重写了方法  {    System.out.println("喵!喵!");  }}
    从上述的代码可以看到,子类重写了父类的cry() 方法。父类方法就没有意义了。所以各个子类中的这个方法肯定会有不同,所以没有必要再父类里写。而解决这类问题可以用抽象类/接口解决,这章我们着重抽象类。抽象类64001abe9afa70ee8efa7e3d8222a644.png
    • 概念

             java中可以定义没有方法体的方法,该方法由其子类来具体的方法我们称之为抽象方法,含有抽象方法的类我们称之为抽象类。

              抽象类可以理解为是一个只有方法声明却没有方法体的特殊类。

              格式:修饰符 abstract 返回值 方法名(参数列表);

    • 特点

      • 通过java关键字 abstract 实现 

      • 可以修饰方法或者类

      • 抽象类中可以没有抽象方法(由子类实现)

      • 如果抽象类中有抽象方法,那该类必须定义为一个抽象类。

      • 子类继承了抽象类以后,要么还是一个抽象类,要么必须把所有抽象方法都重写。

      • 多用于多态中

      • 抽象类不可以实例化

    • 案例

                                       ( 一 )

    //继承:把子类的共有功能,向上提取到父类中//抽象类,当子类继承父类以后,子类可能需要重写。这时,父类就如上文 序 中说所说父类的实现就没有用会被重写(覆盖)abstract class Animal  //创建一个动物抽象类{  String name;  int age;  public void cry();    //没有方法体就是抽象方法  }class Dog extends Animal    //狗继承了动物抽象类{  @Override  public void cry()    //狗类重写了方法  {    System.out.println("汪!汪!");  }}class Cat extends Animal    //猫继承了动物类{  @Override  public void cry()    //猫类重写了方法  {    System.out.println("喵!喵!");  }}

                                                           ( 二 )

    public class Abstract {  public static void main(String[] args) {    //创建多态对象    Fu f=new Zi();    //编译看左边,实现看右边    f.sleep();    f.eat();  }}//抽象类中可以有普通方法,也可以有抽象方法//抽象方法只能出现在抽象类中 abstract class Fu{  public void sleep() {    System.out.println("sj");  }  //没有方法体{},需要被abstract修饰  public abstract void eat();} //子类可以继承抽象类; //要把抽象类中的抽象方法全部重写,否则子类还是抽象类class Zi extends Fu{  public void eat() {    System.out.println("chichi");  }}
    fe1dc400bed07be07488ca0a1830ca38.pnge07043ede7ab50156120c7f13f2461d0.png抽象类的用法8498ee92423350aa71d72cc6c0289ab5.png
    • 构造函数

      常用于子类的实例化。

    //测试抽象类的用法public class Abstract {  public static void main(String[] args) {    Fu f =new Zi();    }  }abstract class Fu{  //抽象类自己是不能创建对象的,即 new  //因为子类创建对象时会调用构造函数中的super()  //所以抽象类中的构造方法用来给子类创建对象  //抽象类中的构造方法  public Fu() {    System.out.println(1);  }}class Zi extends Fu{  public Zi() {    super();    System.out.println(2);  }}
    • 成员变量

       既可以有变量,也可以有常量

    public class Abstract {  public static void main(String[] args) {    // TODO Auto-generated method stub    Fu f=new Zi();    System.out.println(f.name);    System.out.println(f.name1);    System.out.println(f.name2);  }}//在抽象类中可以有变量也可以有常量            abstract class Fu{  String name;  String name1="wrr";  final String name2="大黄";  }class Zi extends Fu{  }
    • 成员方法

        可以有普通方法也可以有抽象方法

    public class Test5_Abstract {  public static void main(String[] args) {    // TODO Auto-generated method stub    //Fu f=new Fu();抽象类不能创建对象//实例化    //创建多态对象    Fu f =new Zi();    f.eat();    f.sleep();      }}abstract class Fu{  //普通方法  public void sleep() {System.out.println("sleep");}  //抽象方法 --方法的声明/签名  abstract public void eat();}class Zi extends Fu{  public void eat() {    System.out.println("chichi");  }}
    • 案例

    public class Abstract {  public static void main(String[] args) {    // TODO Auto-generated method stub    Teacher t =new MathTeacher();    t.teach();//调用父类功能,使用子类实现    System.out.println(t.name);    t.ready();    Teacher t1 =new EnglishTeacher();    t1.teach();    System.out.println(t.name);    t1.ready();  }}abstract class Teacher{  String name;  int age;  abstract public void teach();  abstract public void ready();  }class MathTeacher extends Teacher{  @Override//重写  public void teach() {    System.out.println("数学");  }  @Override //重写  public void ready() {    System.out.println("备课数学");  }}class EnglishTeacher extends Teacher{  @Override //重写  public void teach() {    System.out.println("英语");  }  @Override //重写  public void ready() {    System.out.println("备课");  }}
    4a445f66957097e70c3cfd5e13448f7d.png扫码关注fe1dc400bed07be07488ca0a1830ca38.png以上就是这次所有关于 java--初识抽象类 的内容,后续笔记将会陆续发出,欢迎大家关注我们,一起交流、共同进步。我们是一秋攻防,网络安全爱好者,旨在细微、专注。文章若有错误,欢迎指正!谢谢!--by 布布e5eefa267114789f7f9db86fef379863.png好看的人都点了在看
    展开全文
  • (动物园真的有一个动物叫Animal吗?没有 但是你为了某种操作创建了Animal 那么此时程序就有一个bug分析:1 Animal这个来存来仅仅是用来产生多态,但是为了多态而导致能创建Animal对象这显然是不合理的,所以我们希望...

    packagecom.aaa.zxf.ajax.test;/**一、java中的 抽象

    Animal这个类 存在的意义是什么?

    (动物园真的有一个动物叫Animal吗?没有 但是你为了某种操作创建了Animal 那么此时程序就有一个bug

    分析:

    1 Animal这个来存来仅仅是用来产生多态,但是为了多态而导致能创建Animal对象这显然是不合理的,

    所以我们希望:Animal这个类得存在,但是不能通过new 创建对象

    2 Animal的eat有用,在编译的时候 如果Animal没有eat函数 编译不会通过,但是我们运行的时候 是调用的真实类型的eat()所以Animal的eat不会被调用。

    Animal的eat方法得有 但是方法体没什么用。

    所以我们希望:Animal中的eat函数 只声明 不写实现(因为没必要写)。

    3 Animal的子类必须要有各自的eat函数,但是我们做的练习 eat可以不写,此时会去调用父类的eat函数。所以我们希望:子类必须实现eat()函数

    解决方案:将Animal这个类变成抽象类

    二、声明一个抽象类

    三、java中抽象类中构造函数使用

    1. 构造函数是对象的基本,没有构造函数就没有对象。

    2. 父类抽象类中写了有参数的构造函数,子类继承是就必须写一个构造函数来调用父类的构造函数

    四、匿名内部类*/

    public classJavaDuoTai {public static voidmain(String[] args) {//继承多态

    Animal02 h = newHourse();//h 代表了两个对象。

    h.sleep(); //调用父类抽象类中的普通方法 sleep

    h.eat(); //调用子类中的方法 eat。

    Hourse hourse= new Hourse("张三", 45);

    System.out.println(" name="+hourse.name +" age="+hourse.age);/*** 抽象类无法通过new 来创建对象。 因为是抽象的。

    * 我是匿名内部类 实现它的抽象方法。

    * 这种写法*/Animal02 animal02= newAnimal02() {

    @Overridepublic voideat() {

    System.out.println("我是匿名内部类");//多一个T$1.class,这个class就是匿名内部类的原型,//所以new针对的还是普通的class(虽然内部类和普通类有很大不一样),只不过这个class的写法稍有不同,它是编译器帮我们从匿名内部类中提取的。

    System.out.println("获得class的对象"+this.getClass());

    }

    };//执行 匿名内部类

    animal02.eat();

    }

    }classAnimal01{public intid;publicString name;private intage;voidrun(){

    System.out.println("动物要吃饭");

    }

    }class Dog01 extendsAnimal01{publicString food;

    @Overridevoidrun(){

    System.out.println("狗吃骨头");

    }

    }class Cat01 extendsAnimal01{publicString color;

    @Overridevoidrun(){

    System.out.println("猫吃鱼");

    }

    }/*** 二、 声明一个抽象类

    *

    * 1. 关键字 abstract 用来修饰类 和 方法。

    *

    *

    * 2. 抽象类的特征?

    * A 抽象方法不需要写方法体

    * B 抽象方法必须在抽象类中

    * The type Animal must be an abstract class to define abstract methods

    * C 抽象类中不一定要有抽象方法 (抽象类可以有抽象方法 普通方法 成员方法)

    * D 子类继承了一个抽象父类并且父类中有抽象方法 那么子类必须去重写抽象方法----》抽象方法由子类负责实现

    * E 抽象类不能通过new创建对象 但是 有构造函数 (

    * 这个构造函数是用来让子类调用的

    **/

    //定义一个抽象类。

    abstract classAnimal02{publicString name;public intage;publicAnimal02() {

    }//有参数的构造函数 这个构造函数是用来让子类调用的

    public Animal02(String name, intage) {this.name =name;this.age =age;

    }public abstract void eat(); //1.抽象方法不需要写方法体 2.抽象方法必须在抽象类中//抽象类中不一定要有抽象方法 普通方法

    public voidsleep(){

    System.out.println("睡觉!");

    }

    }//子类 继承抽象类 需要重写父类的方法

    class Hourse extendsAnimal02{publicHourse() {

    }//让子类调用父类的 构造函数 关键字 super

    public Hourse(String name, intage) {super(name, age);

    }

    @Overridepublic voideat() {

    System.out.println("马飞飞。");

    }

    }

    展开全文
  • Java抽象类和接口

    2020-11-24 20:44:00
    例如,我们去动物园之前首先创建一个抽象类Animal,我们知道动物园中有狗,猫,狮子,老鹰等等动物,但我们还不 知道会遇到哪一只,所以我们先将将它们共有的特性作为抽象类中的方法。 当我们去了动物园,首先...
  • java抽象类与接口整理

    2020-08-11 16:02:04
    抽象类 一、什么是抽象类?...(3)如果要实现一个抽象类创建一个子类去继承这个抽象类, (4)子类继承抽象类以后,必须重写抽象类的所有方法(前提子类不是抽象类) (5)抽象类里面可以定义普通方法
  • Java抽象类

    2019-10-26 10:17:50
    抽象类 public abstract class Animal//抽象类 { public String food; public abstract void eat();//抽象方法 ...比如现实中:不能说创建一个动物,必须具体到创建猪等等) 其它功能与普通类一...
  • Java学习之抽象类

    2016-05-11 18:46:24
    前面所讲的猫狗案例中,提取出了一个动物类,也创建了具体的动物对象,但其实是不对的。如果我说动物,你就不知道我具体说的是什么动物,只有给了具体的动物你才知道是什么动物,所以说动物不是一个具体的事物,...
  • java中的抽象类

    2019-09-29 18:15:52
    ... (动物园真的有一个动物叫Animal吗?没有 但是你为了某种操作创建了Animal 那么此时程序就有一个bug 分析: 1 Animal这个来存来仅仅是用来产生多态,但是为了多态而导致能创建A...
  • 28.Java抽象类

    2020-02-18 14:58:38
    我们创建一个动物类,并且在这个中创建动物对象,但是当你提到动物,你并不知道我说的是什么动物,只有看到了具体的动物,你才知道这是什么动物,所以说动物本身并不是一个具体的事物,而是一个抽象的事物。...
  • 回想前面我们的猫狗案例,提取出一个动物类,并且我们在前面也创建了动物对象,其实这是不对的!为什么呢? 因为我说动物,你知道我说的是什么动物吗?只有看到了具体的动物,你才知道,这是什么动物。所以说,动物...
  • ​ 我们之前应该也做过类似猫与狗都属于动物类似的练习吧,其实我们都知道,猫和狗都是动物,他们都具有动物所具有的共同的属性和功能,所以便会提取出一个动物类。并且我们也创建过了动物对象,其实呢,这是不对的...
  • Java基础抽象类与接口

    2017-01-05 16:50:01
    抽象类的概述回想前面我们的猫狗案例,提取出了一个动物类。并且我们在前面也创建过了动物对象,其实这是不对的。为什么呢?因为,我说动物,你知道我说的是什么动物吗?只有看到了具体的动物,你才知道,这是什么动物...
  • 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类抽象类往往用来表征对问题领域...
  • 回想前面我们的猫狗案例,提取出了一个动物类。并且我们在前面也创建过了动物对象,其实这是不对的。 为什么呢?因为,我说动物,你知道我说的是什么动物吗?只有看到了具体的动物,你才知道,这是什么动物。 ...
  • 一个类中,将某个功能给出一个声明(抽象方法:没有方法体的方法),那么该类定义为抽象类 举例: 动物--->本身是一个抽象的事物 给出能吃的功能--->将eat方法:没有方法体{} 关键字:abstract:修饰类、修饰...
  • 回想前面我们的猫狗案例,提取出了一个动物类。并且我们在前面也创建过了动物对象,其实这是不对的。 为什么呢?因为,我说动物,你知道我说的是什么动物吗?只有看到了具体的动物,你才知道,这是什么动物。 所以说...
  • 什么是抽象类? 个人理解: ...举例说明:对于狗,猫,老虎,狮子,它们都一个共同的特征,即都是哺乳类动物,所以,在定义狗、猫、老虎、狮子这四种动物的类的时候就可以先定义一个抽象类——...
  • java多态、抽象类作业

    2020-04-22 13:30:04
    一、选择 1.C 2.C 3.A 4.C 5.A 6.B 7.D 8.AD 9.B ...应用继承和多态的思想,编写动物类,成员方法是动物叫声。写三个具体的(猫、狗、羊), ...定义一个父类Animal 属性:kind(种类) 方法:创建带参(kind为...
  • Java----抽象类,接口

    2019-09-10 01:53:14
    抽象类可以将设计与实现分离,当子类拥有一个共同的行为但各自的实现方式又不同时(例如动物吃饭),父类在此时就不需要先实现这种行为再让子类去重写,可以通过声明一种抽象方法,让子类自己去实现 2.抽象类的...
  • 抽象 1.抽象的概念 图形一定可以计算面积,但是计算面积方法不确定;动物一定要吃东西,但是吃东西的方法不确定...不能直接创建new抽象类对象。 * 2.必须用一个子类来继承抽象父类。 * 3.子类必须覆盖重写抽象父类当中
  • 抽象类

    2021-04-10 22:09:23
    抽象类不能直接创建对象,必须用一个子类来继承它,子类必须重写父类所有的抽象方法(抽象子类除外,若子类也是抽象的则无此限制) 抽象类中可以没有抽象方法 当我们在做子类共性功能抽取时,有些方法在父类中并没有...
  • 比如动物,自然界没有动物这个物种,但却有无数的继承自动物的物种,那么动物本身可以是一个抽象类抽象类使用规则: 抽象类不可以被创建,不能有实例。 抽象类不可以是 final 的,因为 final 类不能被继承,...
  • 回想前面我们的猫狗案例,提取出了一个动物类。并且我们在前面也创建过了动物对象,其实这是不对的。 为什么呢?因为,我说动物,你知道我说的是什么动物吗?只有看到了具体的动物,你才知道,这是什么动物。 所以说,...
  • Java中为什么要有抽象类的概念?

    千次阅读 多人点赞 2018-05-23 14:18:04
    首先你要看到普通的缺点:假设我有一个父类:class Animal //创建一个动物类 { String name; int age; public void cry() //动物会叫 { System.out.println("不知道怎么叫!"); //可是我们不...
  • 回想前面我们的猫狗案例,提取出了一个动物类。并且我们在前面也创建过了动物对象,其实这是不对的。 为什么呢?因为,我说动物,你知道我说的是什么动物吗?只有看到了具体的动物,你才知道,这是什么动物。 所以说...
  • 一个事物在不同的时刻表现出来不同的状态。 举例:猫可以是猫类型,同时猫也可以是动物的一种。 Cat cat = new Cat(); Animal a =new Cat(); 多态的前提: 要有继承的关系 要有方法的重写。 要有父类引用指向子类...
  • java抽象方法理解

    2020-10-12 22:45:46
    抽象方法: 举例: 1.计算二维图形的面积的一个方法,具体一个图形可以去计算,但是不具体呢?这个方法就是一个抽象方法。...不能直接创建抽象对象(创建一个动物?不具体) * 2.必须新建一个
  • 在上一节继承中讲到,如果一个猫继承于一个动物类,在测试创建猫的对象是这样写的 Cat c = new Cat();在这个等式中含义就是猫的一个实例对象,创建了一个猫对象,但是猫同时也是动物的一种,也是属于动物...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 159
精华内容 63
关键字:

创建一个动物抽象类java

java 订阅