精华内容
下载资源
问答
  • 声明一个抽象类pet
    2020-04-05 23:40:23
    1. 声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat();
    2. 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()方法;
    3. 声明一个Cat类继承自Pet,封装属性weight,声明带有三个参数的构造函数,复写talk()和eat()方法;
    4. 编写测试类,通过有参构造函数实例化Dog类对象,调用talk()方法和eat()方法;通过有参构造函数实例化Cat类对象 ,调用talk()方法和eat()方法;
    import java.util.Scanner;
    
    abstract class Pet {
    	public String sex;
        public String name;
        public Pet(String s,String n){
            this.sex = s;
            this.name = n;
        }
        public void talk(){
    
        }
        public void eat(){
    
        }
    }
    
    class Dog extends Pet {
    	private String color;
        public Dog(String s, String n,String c) {
            super(s, n);
            this.color=c;
        }
    	public void talk(){
            System.out.println("名称:"+name+",性别:"+sex+",颜色:"+color+",汪汪叫");
        }
        public void eat(){
            System.out.println(""+name+"吃骨头!");
        }
        public void color(){
    
        }
    
    }
    
    class Cat extends Pet {
    public double weight;
        public Cat(String s, String n,double w) {
            super(s, n);
            this.weight=w;
        }
        public void talk(){
            System.out.println("名称:"+name+",性别:"+sex+",体重:"+weight+"kg,喵喵叫");
        }
        public void eat(){
            System.out.println(""+name+"吃鱼!");
        }
    }
    
    public class Test {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String dogName = sc.next();
    		String dogSex = sc.next();
    		String dogColor = sc.next();
    		String catName = sc.next();
    		String catSex = sc.next();
    		double catWeight = sc.nextDouble();
    		Dog d=new Dog(dogSex,dogName,dogColor);
            d.talk();
            d.eat();
    		Cat c=new Cat(catSex,catName,catWeight);
            c.talk();
            c.eat();
    	}
    }
    
    更多相关内容
  • 声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat(); 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()...

    第1关:通关任务一

    编程要求

    根据提示,在右侧编辑器Begin-End处补充代码:

    • 声明一个抽象类Pet,封装属性namesex,声明一个带有两个参数的构造函数,声明抽象方法void talk()void eat()

    • 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()eat()方法;

    • 声明一个Cat类继承自Pet,封装属性weight,声明带有三个参数的构造函数,复写talk()eat()方法;

    • 编写测试类,通过有参构造函数实例化Dog类对象,调用talk()方法和eat()方法;通过有参构造函数实例化Cat类对象 ,调用talk()方法和eat()方法;

    • 具体输出要求请看测试说明。

    测试说明

    通关代码

    package case1;
    
    import java.util.Scanner;
    
    public class Task1 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String dogName = sc.next();
            String dogSex = sc.next();
            String dogColor = sc.next();
            String catName = sc.next();
            String catSex = sc.next();
            double catWeight = sc.nextDouble();
            // 通过有参构造函数实例化Dog类对象dog
            // dog调用talk()方法
            // dog调用eat()方法
            /********* begin *********/
            Dog dog = new Dog(dogName, dogSex, dogColor);
            dog.talk();
            dog.eat();
            /********* end *********/
            // 通过有参构造函数实例化Cat类对象cat
            // cat调用talk()方法
            // cat调用eat()方法
            /********* begin *********/
            Cat cat = new Cat(catName, catSex, catWeight);
            cat.talk();
            cat.eat();
            /********* end *********/
        }
    }
    
    // 抽象类Pet 封装属性name和sex
    // 构造函数初始化name和sex
    // 声明抽象方法talk()
    // 声明抽象方法eat()
    abstract class Pet {
        /********* begin *********/
        private String name;
        private String sex;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        Pet(String name, String sex) {
            this.name = name;
            this.sex = sex;
        }
    
        abstract void talk();
    
        abstract void eat();
    
    
    /********* end *********/
    }
    
    // Dog类继承自Pet类 封装属性color
    // 构造函数初始化name、sex和color
    // 实现自己的talk()方法和eat()方法
    // talk()输出'名称:name,性别:sex,颜色:color,汪汪叫'
    // eat()输出'name吃骨头'
    class Dog extends Pet {
        /********* begin *********/
        private String color;
    
        public String getColor() {
            return color;
        }
    
        public void setColor(String color) {
            this.color = color;
        }
    
        Dog(String name, String sex, String color) {
            super(name, sex);
            this.color = color;
        }
    
        public void talk() {
            System.out.println("名称:" + getName() + ",性别:" + getSex() + ",颜色:" + getColor() + ",汪汪叫");
        }
    
        public void eat() {
            System.out.println(getName() + "吃骨头!");
        }
    
    
    /********* end *********/
    }
    
    // Cat类继承自Pet类 封装属性weight
    // 构造函数初始化name、sex和weight
    // 实现自己的talk()方法和eat()方法
    // talk()输出'名称:name,性别:sex,体重:weight kg,喵喵叫'
    // eat()输出'name吃鱼'
    class Cat extends Pet {
        /********* begin *********/
        double weight;
    
        public double getWeight() {
            return weight;
        }
    
        public void setWeight(double weight) {
            this.weight = weight;
        }
    
        Cat(String name, String sex, double weight) {
            super(name, sex);
            this.weight = weight;
        }
    
        public void talk() {
            System.out.println("名称:" + getName() + ",性别:" + getSex() + ",体重:" + getWeight() + "kg,喵喵叫");
        }
    
        public void eat() {
            System.out.println(getName() + "吃鱼!");
        }
        /********* end *********/
    }

    第2关:通关任务二

    编程要求

    按照要求编写一个Java应用程序:

    • 定义一个抽象类Person,包含抽象方法eat(),封装属性namesexage,声明包含三个参数的构造方法;

    • 定义一个Chinese类,继承自Person类,重写父类的eat()方法,并定义一个自己特有的方法shadowBoxing()

    • 定义一个English类,继承自Person类,重写父类的eat()方法,并定义一个自己特有的方法horseRiding()

    • 编写测试类,定义一个showEat()方法,使用父类作为方法的形参,实现多态,分别调用showEat()方法,通过强制类型转换调用各自类特有的方法;

    • 具体输出要求请看测试说明。

    测试说明

    通关代码

    package case2;
    
    import java.util.Scanner;
    
    public class Task2 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String cName = sc.next();
            String cSex = sc.next();
            int cAge = sc.nextInt();
            String eName = sc.next();
            String eSex = sc.next();
            int eAge = sc.nextInt();
            // 创建测试类对象test
            // 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
            // 通过showEat()方法调用Chinese的eat()方法
            // 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
            // 通过showEat()方法调用English的eat()方法
            /********* begin *********/
            Person person1 = new Chinese(cName, cSex, cAge);
            showEat(person1);
            Person person2 = new English(eName, eSex, eAge);
            showEat(person2);
            /********* end *********/
            // 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
            // 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
            /********* begin *********/
            Chinese chinese = (Chinese) person1;
            chinese.shadowBoxing();
            English english = (English) person2;
            english.horseRiding();
            /********* end *********/
        }
    
        // 定义showEat方法,使用父类作为方法的形参,实现多态,传入的是哪个具体对象就调用哪个对象的eat()方法
    
        /********* begin *********/
        public static void showEat(Person person) {
            person.eat();
        }
        /********* end *********/
    }
    
    // 抽象类Person 封装属性name、sex和age
    // 构造函数初始化name、sex和age
    // 声明抽象方法eat()
    abstract class Person {
        /********* begin *********/
        abstract void eat();
    
        private String name;
        private String sex;
        private int age;
    
        Person(String name, String sex, int age) {
            this.name = name;
            this.sex = sex;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getSex() {
            return sex;
        }
    
        public void setSex(String sex) {
            this.sex = sex;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    /********* end *********/
    }
    
    // Chinese类继承自Person类
    // 构造函数初始化name、sex和age
    // 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是中国人,我喜欢吃饭!'
    // 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳!'
    class Chinese extends Person {
        /********* begin *********/
        Chinese(String name, String sex, int age) {
            super(name, sex, age);
            //name = super.getName();
            //sex = super.getSex();
            //age = super.getAge();
        }
    
        public void eat() {
            System.out.println("姓名:" + getName() + ",性别:" + getSex() + ",年龄:" + getAge() + ",我是中国人,我喜欢吃饭!");
        }
    
        void shadowBoxing() {
            System.out.println(getName() + "在练习太极拳!");
        }
    
        /********* end *********/
    }
    
    // English类继承自Person类
    // 构造函数初始化name、sex和age
    // 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是英国人,我喜欢吃三明治!'
    // 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马!'
    class English extends Person {
        /********* begin *********/
        English(String name, String sex, int age) {
            super(name, sex, age);
            //name = super.getName();
            //sex = super.getSex();
            //age = super.getAge();
        }
    
        public void eat() {
            System.out.println("姓名:" + getName() + ",性别:" + getSex() + ",年龄:" + getAge() + ",我是英国人,我喜欢吃三明治!");
        }
    
        void horseRiding() {
            System.out.println(getName() + "在练习骑马!");
        }
        /********* end *********/
    }

    第3关:通关任务三

    编程要求

    教练和运动员案例:

    • 乒乓球运动员和篮球运动员;

    • 乒乓球教练和篮球教练;

    • 跟乒乓球相关的人员都需要学习英语;

    • 分析,这个案例中有哪些抽象类,哪些接口,哪些具体类。

    分析过程如下:

    预览大图

    - 具体输出要求请看测试说明。

    测试说明

    测试输入:

    张继科

    30

    易建联

    31

    刘国梁

    42

    杜锋

    37

    预期输出:

    张继科---30

    人都是要睡觉的

    乒乓球运动员吃大白菜,喝小米粥

    乒乓球运动员学习如何发球和接球

    乒乓球运动员说英语

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

    易建联---31

    人都是要睡觉的

    篮球运动员吃牛肉,喝牛奶

    篮球运动员学习如何运球和投篮

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

    刘国梁---42

    人都是要睡觉的

    乒乓球教练吃小白菜,喝大米粥

    乒乓球教练教如何发球和接球

    乒乓球教练说英语

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

    杜锋---37

    人都是要睡觉的

    篮球教练吃羊肉,喝羊奶

    篮球教练教如何运球和投篮

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

    通关代码

    package case3;
    
    import java.util.Scanner;
    
    public class Task3 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            String pppName = sc.next();
            int pppAge = sc.nextInt();
            String bpName = sc.next();
            int bpAge = sc.nextInt();
            String ppcName = sc.next();
            int ppcAge = sc.nextInt();
            String bcName = sc.next();
            int bcAge = sc.nextInt();
            // 测试运动员(乒乓球运动员和篮球运动员)
            // 乒乓球运动员
            // 通过带参构造函数实例化PingPangPlayer对象ppp
            // 输出'name---age'
            // 分别调用sleep()、eat()、study()、speak()方法
            /********* begin *********/
            PingPangPlayer ppp = new PingPangPlayer(pppName, pppAge);
            System.out.println(pppName + "---" + pppAge);
            ppp.sleep();
            ppp.eat();
            ppp.study();
            ppp.speak();
            /********* end *********/
            System.out.println("----------------");
            // 篮球运动员
            // 通过带参构造函数实例化BasketballPlayer对象bp
            // 输出'name---age'
            // 分别调用sleep()、eat()、study()方法
            /********* begin *********/
            BasketballPlayer bp = new BasketballPlayer(bpName, bpAge);
            System.out.println(bpName + "---" + bpAge);
            bp.sleep();
            bp.eat();
            bp.study();
            /********* end *********/
            System.out.println("----------------");
            // 测试教练(乒乓球教练和篮球教练)
            // 乒乓球教练
            // 通过带参构造函数实例化PingPangCoach对象ppc
            // 输出'name---age'
            // 分别调用sleep()、eat()、teach()、speak()方法
            /********* begin *********/
            PingPangCoach ppc = new PingPangCoach(ppcName, ppcAge);
            System.out.println(ppcName + "---" + ppcAge);
            ppc.sleep();
            ppc.eat();
            ppc.teach();
            ppc.speak();
            /********* end *********/
            System.out.println("----------------");
            // 篮球教练
            // 通过带参构造函数实例化BasketballCoach对象bc
            // 输出'name---age'
            // 分别调用sleep()、eat()、teach()方法
            /********* begin *********/
            BasketballCoach bc = new BasketballCoach(bcName, bcAge);
            System.out.println(bcName + "---" + bcAge);
            bc.sleep();
            bc.eat();
            bc.teach();
            /********* end *********/
            System.out.println("----------------");
        }
    }
    
    // 说英语接口 声明抽象方法speak()
    interface SpeakEnglish {
        /********* begin *********/
        void speak();
        /********* end *********/
    }
    
    // 定义人的抽象类Person 封装name和age
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 定义具体方法sleep() 输出'人都是要睡觉的'
    // 抽象方法eat()(吃的不一样)
    abstract class Person {
        /********* begin *********/
        private String name;
        private int age;
    
        Person() {
    
        }
    
        Person(String name, int age) {
            this.name = name;
            this.age = age;
    
        }
    
        public void sleep() {
            System.out.println("人都是要睡觉的");
        }
    
        abstract void eat();
    
        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;
        }
        /********* end *********/
    }
    
    // 定义运动员Player(抽象类)继承自Person类
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 运动员学习内容不一样,抽取为抽象 定义抽象方法study()
    abstract class Player extends Person {
        /********* begin *********/
        Player() {
    
        }
    
        Player(String name, int age) {
            super(name, age);
            name = super.getName();
            age = super.getAge();
        }
    
        abstract void study();
        /********* end *********/
    }
    
    // 定义教练Coach(抽象类)继承自Person类
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 教练教的不一样 定义抽象方法teach()
    abstract class Coach extends Person {
        /********* begin *********/
        Coach() {
    
        }
    
        Coach(String name, int age) {
            super(name, age);
            name = super.getName();
            age = super.getAge();
        }
    
        abstract void teach();
        /********* end *********/
    }
    
    // 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类(兵乓球运动员需要说英语)
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'乒乓球运动员吃大白菜,喝小米粥'
    // 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
    // 实现自己的speak()方法 输出'乒乓球运动员说英语'
    class PingPangPlayer extends Player implements SpeakEnglish {
        /********* begin *********/
        PingPangPlayer() {
    
        }
    
        PingPangPlayer(String name, int age) {
            super(name, age);
            name = super.getName();
            age = super.getAge();
        }
    
        public void eat() {
            System.out.println("乒乓球运动员吃大白菜,喝小米粥");
        }
    
        public void study() {
            System.out.println("乒乓球运动员学习如何发球和接球");
        }
    
        public void speak() {
            System.out.println("乒乓球运动员说英语");
        }
    /********* end *********/
    }
    
    // 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口,因为他不需要说英语
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'篮球运动员吃牛肉,喝牛奶'
    // 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
    class BasketballPlayer extends Player {
        /********* begin *********/
        BasketballPlayer() {
    
        }
    
        BasketballPlayer(String name, int age) {
            super(name, age);
            name = super.getName();
            age = super.getAge();
        }
    
        public void eat() {
            System.out.println("篮球运动员吃牛肉,喝牛奶");
        }
    
        public void study() {
            System.out.println("篮球运动员学习如何运球和投篮");
        }
        /********* end *********/
    }
    
    // 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类(兵乓球教练需要说英语)
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'乒乓球教练吃小白菜,喝大米粥'
    // 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
    // 实现自己的speak()方法 输出'乒乓球教练说英语'
    class PingPangCoach extends Coach implements SpeakEnglish {
        /********* begin *********/
        PingPangCoach() {
    
        }
    
        PingPangCoach(String name, int age) {
    
        }
    
        public void eat() {
            System.out.println("乒乓球教练吃小白菜,喝大米粥");
        }
    
        public void teach() {
            System.out.println("乒乓球教练教如何发球和接球");
        }
    
        public void speak() {
            System.out.println("乒乓球教练说英语");
        }
        /********* end *********/
    }
    
    // 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口,因为他不需要说英语
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'篮球教练吃羊肉,喝羊奶'
    // 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
    class BasketballCoach extends Coach {
        /********* begin *********/
        BasketballCoach() {
    
        }
    
        BasketballCoach(String name, int age) {
    
        }
    
        public void eat() {
            System.out.println("篮球教练吃羊肉,喝羊奶");
        }
    
        public void teach() {
            System.out.println("篮球教练教如何运球和投篮");
        }
        /********* end *********/
    }
    

     

    展开全文
  • 声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat(); 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写tal...

    Educoder–Java面向对象(第三章综合练习)-封装继承和多态的综合练习【笔记+参考代码】

    第一关

    编程要求
    根据提示,在右侧编辑器Begin-End处补充代码:

    声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat();

    声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()方法;

    声明一个Cat类继承自Pet,封装属性weight,声明带有三个参数的构造函数,复写talk()和eat()方法;

    编写测试类,通过有参构造函数实例化Dog类对象,调用talk()方法和eat()方法;通过有参构造函数实例化Cat类对象
    ,调用talk()方法和eat()方法;

    具体输出要求请看测试说明。


    测试说明 测试输入:

    泰迪

    male

    brown

    波斯猫

    male

    2.5

    预期输出:

    名称:泰迪,性别:male,颜色:brown,汪汪叫

    泰迪吃骨头!

    名称:波斯猫,性别:male,体重:2.5kg,喵喵叫

    波斯猫吃鱼!

    参考代码

    package case1;
    
    import java.util.Scanner;
    
    public class Task1 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String dogName = sc.next();
    		String dogSex = sc.next();
    		String dogColor = sc.next();
    		String catName = sc.next();
    		String catSex = sc.next();
    		double catWeight = sc.nextDouble();
    		// 通过有参构造函数实例化Dog类对象dog
    		// dog调用talk()方法
    		// dog调用eat()方法
    		/********* begin *********/
    		Pet dog=new Dog(dogName,dogSex,dogColor);
    		dog.talk();
    		dog.eat();
    		/********* end *********/
    		// 通过有参构造函数实例化Cat类对象cat
    		// cat调用talk()方法
    		// cat调用eat()方法
    		/********* begin *********/
    		Pet cat=new Cat(catName,catSex,catWeight);
    		cat.talk();
    		cat.eat();
    		/********* end *********/
    	}
    }
    
    // 抽象类Pet 封装属性name和sex
    // 构造函数初始化name和sex
    // 声明抽象方法talk()
    // 声明抽象方法eat()
    abstract class Pet {
    	/********* begin *********/
    	String name;
    	String sex;
    	abstract void talk();
    	abstract void eat();
    	/********* end *********/
    }
    
    // Dog类继承自Pet类 封装属性color
    // 构造函数初始化name、sex和color
    // 实现自己的talk()方法和eat()方法
    // talk()输出'名称:name,性别:sex,颜色:color,汪汪叫'
    // eat()输出'name吃骨头'
    class Dog extends Pet {
    	/********* begin *********/
    	String color;
    	Dog(String name,String sex,String color){
    		this.name=name;
    		this.sex=sex;
    		this.color=color;
    	}
    	void talk(){
    		System.out.println("名称:"+name+",性别:"+sex+",颜色:"+color+",汪汪叫");
    	}
    	void eat(){
    		System.out.println(name+"吃骨头!");
    	}
    	/********* end *********/
    }
    
    // Cat类继承自Pet类 封装属性weight
    // 构造函数初始化name、sex和weight
    // 实现自己的talk()方法和eat()方法
    // talk()输出'名称:name,性别:sex,体重:weight kg,喵喵叫'
    // eat()输出'name吃鱼'
    class Cat extends Pet {
    	/********* begin *********/
    	double weight;
    	Cat(String name,String sex,double weight){
    		this.name=name;
    		this.sex=sex;
    		this.weight=weight;
    	}
    	void talk(){
    		System.out.println("名称:"+name+",性别:"+sex+",体重:"+weight+"kg,喵喵叫");
    	}
    	void eat(){
    		System.out.println(name+"吃鱼!");
    	}
    	/********* end *********/
    }
    

    此处涉及Java继承中类型转换的两种方式
    1. 将子类对象转换成父类类型,例如:
      Pet pet=new Dog();
      此类型转换为自动转换
      因为子类的功能比父类更加强大,因此可以自动转换完成
    2. 将父类对象转换为子类类型,例如:
      Pet pet=new Pet();
      Dog dog=(Dog)pet;
      此类型转换为强制转换
      因为父类的功能要弱于子类,因此需要强制转换


    第二关

    编程要求

    按照要求编写一个Java应用程序:

    定义一个抽象类Person,包含抽象方法eat(),封装属性name、sex、age,声明包含三个参数的构造方法;

    定义一个Chinese类,继承自Person类,重写父类的eat()方法,并定义一个自己特有的方法shadowBoxing();

    定义一个English类,继承自Person类,重写父类的eat()方法,并定义一个自己特有的方法horseRiding();

    编写测试类,定义一个showEat()方法,使用父类作为方法的形参,实现多态,分别调用showEat()方法,通过强制类型转换调用各自类特有的方法;

    具体输出要求请看测试说明。


    测试说明 测试输入:

    张三

    20

    史蒂文

    22


    预期输出:

    姓名:张三,性别:男,年龄:20,我是中国人,我喜欢吃饭!

    姓名:史蒂文,性别:男,年龄:22,我是英国人,我喜欢吃三明治!

    张三在练习太极拳!

    史蒂文在练习骑马!


    参考代码

    package case2;
    
    import java.util.Scanner;
    
    public class Task2 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String cName = sc.next();
    		String cSex = sc.next();
    		int cAge = sc.nextInt();
    		String eName = sc.next();
    		String eSex = sc.next();
    		int eAge = sc.nextInt();
    		// 创建测试类对象test
    		Person test;
    		// 创建Person类对象person1,引用指向中国人,通过有参构造函数实例化中国人类对象
    		Person person1=new Chinese(cName,cSex,cAge);
    		// 通过showEat()方法调用Chinese的eat()方法
    		showEat(person1);
    		// 创建Person类对象person2,引用指向英国人,通过有参构造函数实例化英国人类对象
    		Person person2=new English(eName,eSex,eAge);
    		// 通过showEat()方法调用English的eat()方法
    		showEat(person2);
    		/********* begin *********/
    
    		/********* end *********/
    		// 强制类型转换(向下转型) 调用Chinese类特有的方法shadowBoxing()
    		Chinese d=(Chinese)person1;
    		d.shadowBoxing();
    		// 强制类型转换(向下转型) 调用English类特有的方法horseRiding()
    		English e=(English)person2;
    		e.horseRiding();
    		/********* begin *********/
    
    		/********* end *********/
    	}
    
    	// 定义showEat方法,使用父类作为方法的形参,实现多态,传入的是哪个具体对象就调用哪个对象的eat()方法
    	/********* begin *********/
    	
    	public static void showEat(Person p){
            p.eat();
        }
    	/********* end *********/
    }
    
    // 抽象类Person 封装属性name、sex和age
    // 构造函数初始化name、sex和age
    // 声明抽象方法eat()
    abstract class Person {
    	/********* begin *********/
    	public String name;
    	public String sex;
    	public int age;
    	abstract void eat();
    	/********* end *********/
    }
    
    // Chinese类继承自Person类
    // 构造函数初始化name、sex和age
    // 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是中国人,我喜欢吃饭!'
    // 定义子类特有方法shadowBoxing(),当父类引用指向子类对象时无法调用该方法 输出'name在练习太极拳!'
    class Chinese extends Person {
    	/********* begin *********/
    	public String name;
    	public String sex;
    	public int age;
    	Chinese(String name,String sex,int age){
    		this.name=name;
    		this.sex=sex;
    		this.age=age;
    	}
    	void eat(){
    		System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age+",我是中国人,我喜欢吃饭!");
    	}
    	void shadowBoxing(){
    		System.out.println(name+"在练习太极拳!");
    	}
    	/********* end *********/
    }
    
    // English类继承自Person类
    // 构造函数初始化name、sex和age
    // 重写父类方法eat() 输出'姓名:name,性别:sex,年龄:age,我是英国人,我喜欢吃三明治!'
    // 定义子类特有方法horseRiding(),当父类引用指向子类对象时无法调用该方法 输出'name在练习骑马!'
    class English extends Person {
    	/********* begin *********/
    	public String name;
    	public String sex;
    	public int age;
    	English(String name,String sex,int age){
    		this.name=name;
    		this.sex=sex;
    		this.age=age;
    	}
    	void eat(){
    		System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age+",我是英国人,我喜欢吃三明治!");
    	}
    	void horseRiding(){
    		System.out.println(name+"在练习骑马!");
    
    	}
    	/********* end *********/
    }
    



    第三关

    编程要求 教练和运动员案例:

    乒乓球运动员和篮球运动员;

    乒乓球教练和篮球教练;

    跟乒乓球相关的人员都需要学习英语;

    分析,这个案例中有哪些抽象类,哪些接口,哪些具体类。

    分析过程如下:


    具体输出要求请看测试说明。 测试说明 测试输入:

    张继科

    30

    易建联

    31

    刘国梁

    42

    杜锋

    37


    预期输出:

    张继科—30

    人都是要睡觉的

    乒乓球运动员吃大白菜,喝小米粥

    乒乓球运动员学习如何发球和接球

    乒乓球运动员说英语


    易建联—31

    人都是要睡觉的

    篮球运动员吃牛肉,喝牛奶

    篮球运动员学习如何运球和投篮


    刘国梁—42

    人都是要睡觉的

    乒乓球教练吃小白菜,喝大米粥

    乒乓球教练教如何发球和接球

    乒乓球教练说英语


    杜锋—37

    人都是要睡觉的

    篮球教练吃羊肉,喝羊奶

    篮球教练教如何运球和投篮





    参考代码

    package case3;
    
    import java.util.Scanner;
    
    public class Task3 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String pppName = sc.next();
    		int pppAge = sc.nextInt();
    		String bpName = sc.next();
    		int bpAge = sc.nextInt();
    		String ppcName = sc.next();
    		int ppcAge = sc.nextInt();
    		String bcName = sc.next();
    		int bcAge = sc.nextInt();
    		// 测试运动员(乒乓球运动员和篮球运动员)
    		// 乒乓球运动员
    		// 通过带参构造函数实例化PingPangPlayer对象ppp
    		// 输出'name---age'
    		// 分别调用sleep()、eat()、study()、speak()方法
    		/********* begin *********/
    		PingPangPlayer ppp=new PingPangPlayer(pppName,pppAge);
    		System.out.println(pppName+"---"+pppAge);
    		ppp.sleep();
    		ppp.eat();
    		ppp.study();
    		ppp.speak();
    		/********* end *********/
    		System.out.println("----------------");
    		// 篮球运动员
    		// 通过带参构造函数实例化BasketballPlayer对象bp
    		// 输出'name---age'
    		// 分别调用sleep()、eat()、study()方法
    		/********* begin *********/
    		BasketballPlayer bp=new BasketballPlayer(bpName,bpAge);
    		System.out.println(bpName+"---"+bpAge);
    		bp.sleep();
    		bp.eat();
    		bp.study();
    		/********* end *********/
    		System.out.println("----------------");
    		// 测试教练(乒乓球教练和篮球教练)
    		// 乒乓球教练
    		// 通过带参构造函数实例化PingPangCoach对象ppc
    		// 输出'name---age'
    		// 分别调用sleep()、eat()、teach()、speak()方法
    		/********* begin *********/
    		PingPangCoach ppc=new PingPangCoach(ppcName,ppcAge);
    		System.out.println(ppcName+"---"+ppcAge);
    		ppc.sleep();
    		ppc.eat();
    		ppc.teach();
    		ppc.speak();
    		/********* end *********/
    		System.out.println("----------------");
    		// 篮球教练
    		// 通过带参构造函数实例化BasketballCoach对象bc
    		// 输出'name---age'
    		// 分别调用sleep()、eat()、teach()方法
    		/********* begin *********/
    		BasketballCoach bc=new BasketballCoach(bcName,bcAge);
    		System.out.println(bcName+"---"+bcAge);
    		bc.sleep();
    		bc.eat();
    		bc.teach();
    		/********* end *********/
    		System.out.println("----------------");
    	}
    }
    
    // 说英语接口 声明抽象方法speak()
    interface SpeakEnglish {
    	/********* begin *********/
    	abstract void speak();
    	/********* end *********/
    }
    
    // 定义人的抽象类Person 封装name和age
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 定义具体方法sleep() 输出'人都是要睡觉的'
    // 抽象方法eat()(吃的不一样)
    abstract class Person {
    	/********* begin *********/
    	String name;
    	int age;
    	Person(String name,int age){
    		this.name=name;
    		this.age=age;
    	}
    	void sleep(){
    		System.out.println("人都是要睡觉的");
    	}
    	abstract void eat();
    	/********* end *********/
    }
    
    // 定义运动员Player(抽象类)继承自Person类
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 运动员学习内容不一样,抽取为抽象 定义抽象方法study()
    abstract class Player extends Person {
    	/********* begin *********/
    	Player(String name,int age){
    		super(name,age);
    	}
    	abstract void study();
    	/********* end *********/
    }
    
    // 定义教练Coach(抽象类)继承自Person类
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 教练教的不一样 定义抽象方法teach()
    abstract class Coach extends Person {
    	/********* begin *********/
    	Coach(String name,int age){
    		super(name,age);
    	}
    	abstract void teach();
    	/********* end *********/
    }
    
    // 定义乒乓球运动员具体类PingPangPlayer 继承自Player类并实现SpeakEnglish类(兵乓球运动员需要说英语)
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'乒乓球运动员吃大白菜,喝小米粥'
    // 实现自己的study()方法 输出'乒乓球运动员学习如何发球和接球'
    // 实现自己的speak()方法 输出'乒乓球运动员说英语'
    class PingPangPlayer extends Player implements SpeakEnglish {
    	/********* begin *********/
    	PingPangPlayer(String name,int age){
    		super(name,age);
    	}
    	void eat(){
    		System.out.println("乒乓球运动员吃大白菜,喝小米粥");
    	}
    	void study(){
    		System.out.println("乒乓球运动员学习如何发球和接球");
    	}
    	public void speak(){
    		System.out.println("乒乓球运动员说英语");
    	}
    	/********* end *********/
    }
    
    // 定义篮球运动员具体类BasketballPlayer 继承自Player类 不需要继承接口,因为他不需要说英语
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'篮球运动员吃牛肉,喝牛奶'
    // 实现自己的study()方法 输出'篮球运动员学习如何运球和投篮'
    class BasketballPlayer extends Player {
    	/********* begin *********/
    	BasketballPlayer(String name,int age){
    		super(name,age);
    	}
    	void eat(){
    		System.out.println("篮球运动员吃牛肉,喝牛奶");
    	}
    	void study(){
    		System.out.println("篮球运动员学习如何运球和投篮");
    	}
    	/********* end *********/
    }
    
    // 定义乒乓球教练具体类 PingPangCoach 继承自Coach类并实现SpeakEnglish类(兵乓球教练需要说英语)
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'乒乓球教练吃小白菜,喝大米粥'
    // 实现自己的teach()方法 输出'乒乓球教练教如何发球和接球'
    // 实现自己的speak()方法 输出'乒乓球教练说英语'
    class PingPangCoach extends Coach implements SpeakEnglish {
    	/********* begin *********/
    	PingPangCoach(String name,int age){
    		super(name,age);
    	}
    	void eat(){
    		System.out.println("乒乓球教练吃小白菜,喝大米粥");
    	}
    	void teach(){
    		System.out.println("乒乓球教练教如何发球和接球");
    	}
    	public void speak(){
    		System.out.println("乒乓球教练说英语");
    	}
    	/********* end *********/
    }
    
    // 定义篮球教练具体类BasketballCoach 继承自Coach类 不需要继承接口,因为他不需要说英语
    // 无参构造函数
    // 有参构造函数初始化name和age
    // 实现自己的eat()方法 输出'篮球教练吃羊肉,喝羊奶'
    // 实现自己的teach()方法 输出'篮球教练教如何运球和投篮'
    class BasketballCoach extends Coach {
    	/********* begin *********/
    	BasketballCoach(String name,int age){
    		super(name,age);
    	}
    	void eat(){
    		System.out.println("篮球教练吃羊肉,喝羊奶");
    	}
    	void teach(){
    		System.out.println("篮球教练教如何运球和投篮");
    	}
    	/********* end *********/
    }
    
    

    两个容易犯的错误

    1、在写子类的构造函数时下方写法报错:Implicit super constructor Person() is undefined. Must explicitly invoke another constructor

    abstract class Player extends Person {
    	/********* begin *********/
    	Player(String name,int age){
    		this.name=name;
    		this.age=age;
    	}
    	abstract void study();
    	/********* end *********/
    }
    

    原因是父类已经定义了一个有参构造函数,子类在继承时应该通过super关键字调用父类的有参构造函数

    【继承中构造函数情况总结】

    Ⅰ.父类有无参构造函数时(显示或隐式),子类的有参和无参构造函数都是默认调用父类的无参构造函数;
    Ⅱ.当父类只有有参构造函数时,子类可以有有参和无参构造函数,子类有参构造函数必须显式调用父类的有参构造函数,子类无参构造函数也必须显式调用父类的有参构造函数,但需给父类有参构造函数赋实参。



    2、此处若函数Sting speak()像下方代码不加public属性则会报错

    class PingPangCoach extends Coach implements SpeakEnglish {
    	/********* begin *********/
    	PingPangCoach(String name,int age){
    		super(name,age);
    	}
    	void eat(){
    		System.out.println("乒乓球教练吃小白菜,喝大米粥");
    	}
    	void teach(){
    		System.out.println("乒乓球教练教如何发球和接球");
    	}
    	String speak(){
    		return "乒乓球教练说英语";
    	}
    	/********* end *********/
    }
    
    

    报错内容:
    Multiple markers at this line
    - Cannot reduce the visibility of the inherited method from
    SpeakEnglish
    在这里插入图片描述
    是因为speak是复写父类的方法,父类是 public ,子类为定义,默认变为了protected,违反了两同两小一大的一大原则。添加public后就不再报错了。

    java中方法的重写的两同两小一大原则

    方法名相同,参数类型相同
    子类返回类型小于等于父类方法返回类型,
    子类抛出异常小于等于父类方法抛出异常,
    子类访问权限大于等于父类方法访问权限。

    展开全文
  • 声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat(); 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()方法; ...

    题目要求:

    1. 声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat();
    2. 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()方法;
    3. 声明一个Cat类继承自Pet,封装属性weight,声明带有三个参数的构造函数,复写talk()和eat()方法;
    4. 编写测试类,通过有参构造函数实例化Dog类对象,调用talk()方法和eat()方法;通过有参构造函数实例化Cat类对象 ,调用talk()方法和eat()方法;
    package case1;
    
    import java.util.Scanner;
    
    public class Task1 {
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		String dogName = sc.next();
    		String dogSex = sc.next();
    		String dogColor = sc.next();
    		String catName = sc.next();
    		String catSex = sc.next();
    		double catWeight = sc.nextDouble();
    		Dog d=new Dog(dogSex,dogName,dogColor);
            d.talk();
            d.eat();
    		Cat c=new Cat(catSex,catName,catWeight);
            c.talk();
            c.eat();
    	}
    }
    
    abstract class Pet {
    	public String sex;
        public String name;
        public Pet(String s,String n){
            this.sex = s;
            this.name = n;
        }
        public void talk(){
    
        }
        public void eat(){
    
        }
    }
    class Dog extends Pet {
    	private String color;
        public Dog(String s, String n,String c) {
            super(s, n);
            this.color=c;
        }
    	public void talk(){
            System.out.println("名称:"+name+",性别:"+sex+",颜色:"+color+",汪汪叫");
        }
        public void eat(){
            System.out.println(""+name+"吃骨头!");
        }
        public void color(){
        }
    }
    
    class Cat extends Pet {
    public double weight;
        public Cat(String s, String n,double w) {
            super(s, n);
            this.weight=w;
        }
        public void talk(){
            System.out.println("名称:"+name+",性别:"+sex+",体重:"+weight+"kg,喵喵叫");
        }
        public void eat(){
            System.out.println(""+name+"吃鱼!");
        }
    }
    
    展开全文
  • java综合练习

    千次阅读 2019-11-25 21:00:56
    // 说英语接口 声明抽象方法speak() interface SpeakEnglish { /********* begin *********/ abstract void speak ( ) ; /********* end *********/ } // 定义人的抽象类Person 封装name和...
  • 声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat(); 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()...
  • 2019独角兽企业重金招聘Python工程师标准>>> 第4章 类与面向对象编程 ...在前面的章节中,我们学习了Kotlin的语言基础知识、类型系统...下面我们声明一个抽象类Shape,并带有width ,heigth,radius属性和...
  • 声明一个抽象类Pet,封装属性name和sex,声明一个带有两个参数的构造函数,声明抽象方法void talk()和void eat(); 声明一个Dog类继承自Pet,封装属性color,声明带有三个参数的构造函数,复写talk()和eat()...
  • Java 抽象类

    2020-06-16 15:55:59
    本文我们来看看抽象类,你将了解到抽象类的概念和特点,抽象类在程序设计时的应用场景,什么是抽象方法,抽象方法有什么特点,如何声明一个抽象方法等内容。 1.概念和特点 在面向对象的概念中,所有的对象都是通过类...
  • C++ 抽象类

    千次阅读 2020-10-01 15:04:00
    C++接口时通过抽象类实现的,设计抽象类的目的,是为了给其他类提供一个可以继承的适当的基类。抽象类本类不能被用于实例化对象,只能作为接口使用。如果试图实例化一个抽象类的对象,会导致编译错误。 因此,如果一个...
  • 多态,是允许你将父对象设置成为和一个或更多的它的子对象相等的技术,赋值之后,父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。父类引用指向子类对象。 接下来通过具体的讲解并以三个综合练习来...
  • 面向对象----封装

    2019-04-21 23:44:25
    private仅仅是封装的种体现形式,不能说是封装就是私有。 5.this关键字的概述和使用 this关键字特点:代表当前对象的引用 this关键字的应用场景:用来区分同名的成员变量和局部变量。用this调用的就是成员...
  • C#学习入门(三)—— 抽象类

    千次阅读 2020-11-08 21:50:49
    抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念,是对系列看上去不同,但是本质上相同的具体概念的抽象。  在C#中,抽象类可以包含:抽象方法、抽象属性、具体方法和具体属性。 1.1 定义 访问修饰...
  • 多态自测练习(二)

    2019-04-19 19:23:00
    定义员工(抽象) 内容,都是所有子类的共性抽取 属性: 姓名,工号 方法: 工作(抽象) 开发部员工 特有属性: language (掌握的语言) 维护部员工 特有属性: skill (掌握的技能) 实体: 实现父类的工作方法 J2EE...
  • Java--面向对象之封装

    2017-07-13 14:41:03
    需求:使用java描述百合网会员 问题:性别有问题?? 根本原因:由于其他人可以直接操作sex属性。可以对sex属性进行了直接的赋值。 封装:  权限修饰符:权限修饰符就是控制变量可见范围的 ...
  • java抽象类

    2021-12-09 14:38:42
    java抽象类,抽象方法,final,抽象方法
  • 1.多态一个特定类型的变量,可以引用多个不同类型的对象,并且能自动调用引用对象的方法,也就是根据引用对象的不同,响应不同的操作方法重写是多态的基础,在继承中,子类拥有和父类相同的方法(方法名称、参数、...
  • 抽象类、抽象方法 抽象类:我们使用面向对象的思想,其实就是把类当中的成员进一步的向上提取封装。 public abstract class Animal { public abstract void Bark(); } public class Cat extends Animal { ...
  • Java抽象类

    2020-06-08 19:13:33
    在面向对象编程中,所有的事物都可以看做为对象,所有的对象都是通过类来描绘的,但并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类抽象类与普通类...
  • Task05:综合练习

    2020-07-01 23:06:18
    (3) 请按照分位数将价格分为“高、较高、中、较低、低”5 类别,再将 类别结果插入到标题列之后,最后对类别列进行降序排序。 (4) 付款人数栏有缺失值吗?若有则请利用上问的分类结果对这些缺失 值进行合理...
  • 抽象类

    2020-07-07 10:58:22
    抽象类中可以没有、有一个或多个抽象方法,甚至全部方法都可以是抽象方法 抽象方法之一方法声明,没有方法实现。有抽象方法的类必须声明抽象类。子类必须重写所有的抽象方法才能实例化,否则子类还是一个抽象类。 ...
  • 第十三章 抽象类和接口 1.作业回顾 1,编写一个Person类,包括属性(name、age),有参构造器、方法say(返回自我介绍的字符串)。 2.编写一个Student类,继承Person类,增加sno、score属性,以及有参构造器,在子类...
  • 抽象类 & 接口

    2020-06-08 15:02:16
    抽象类 & 接口抽象类为什么使用抽象类抽象类abstract关键字抽象方法抽象类特点抽象类和普通类的区别final...需要把这定义为抽象类 exp: 1 Animal animal=new Animal(); 2 Pet pet=new Pet() 这里的动物类就比较抽
  • java抽象类和接口

    2021-01-26 15:49:24
    java抽象类和接口抽象类概念抽象类与普通类抽象类与抽象方法的使用总结二,接口接口的概念接口的特征示例总结 抽象类 概念     抽象类和具体类是相对的概念。“抽象”是种存在思想...
  • 说真的,在 Java 使用最多的集合中,List 绝对占有一席之地的,它和 Map 一样适用于很多场景,非常方便我们的日常开发,毕竟存储一个列表的需求随处可见。尽管如此,还是有很多同学没有弄明白 List 中 ArrayList ...
  • 节:抽象类 1. 我们为什么要使用抽象类 有些类创建对象不具体。需要把这定义为抽象类 1.Animal animal=new Animal(); 2.Pet pet=new Pet(); 使用abstract修饰类变成抽象类:不能实例化,只能被继承抽象类的...
  • 1.什么是继承继承,就是面向对象中之间的种关系继承的实现方式:实现继承 接口继承 2.继承的本质(1)继承是可以传递的,子类是对父类的扩展,必须继承父类的方法,同时可以添加新方法(2)子类可以调用父类...
  • 如果一个类中存在抽象方法,那么这个类必须要声明抽象类 如果父类中有一个方法,每一个子类都有不同的实现,此时可以将这个方法声明为抽象方法,抽象方法是没有方法体的,只是一种规范。 Pet类中的toHospital...
  • 去掉方法体,加一个abstract关键字就是一个抽象类,如果一个类具有抽象方法,则再类的申明上必须要加abstract关键字,变成一个抽象类,我们要注意的时,抽象方法没有方法体(也就是没有大括号),所以不能直接调用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,201
精华内容 1,280
热门标签
关键字:

声明一个抽象类pet