文章42
标签13
分类3

JavaSE练习10

day10

关卡1

训练案例1

  • 训练考核知识点
    接口

  • 训练描述
    请阐述接口中成员的特点

  • 操作步骤描述

1.接口中成员方法的特点是什么 ?

2.接口中变量特点是什么?

3.接口可以直接创建对象吗? 为什么?

4.实现接口的类可以创建对象吗 ?

训练案例2

  • 训练考核知识点
    接口

  • 训练描述
    请阐述接口的特点.

  • 操作步骤描述

1.Java中接口可以继承吗 ?

2.Java支持多继承吗 ?

3.Java支持继承父类的同时,再实现多个接口吗 ?

4.Java 允许父类的与实现接口的有相同的功能吗 ?

训练案例3

  • 训练考核知识点
    接口、抽象类

  • 训练描述
    请阐述接口与抽象的区别

  • 操作步骤描述

1.接口与抽象类的相同点是什么 ?

2.接口与抽象类的区别是什么 ?

3.二者如何选用 ?

训练案例4

  • 训练考核知识点
    多态

  • 训练描述
    请阐述一下你对多态理解

  • 操作步骤描述

1.多态前提条件是什么?

2.多态有哪些注意事项?

3.多态的好处和弊端是分别是什么?

4.什么是多态的向上转型 ?

5.什么是多态的向下转型, 为什么要向下转型 , 向下转型需要注意什么?

训练案例5

  • 训练考核知识点
    接口定义、类实现接口

  • 训练描述
    请使用代码描述:
    使用6000元的雷神电脑,编程和玩游戏
    使用3000元的华为手机打电话和玩游戏

  • 操作步骤描述

1.定义玩游戏(PlayGame)接口
a)声明抽象 playGame()
2.定义手机类(Phone)类,实现玩游戏(PlayGame)接口
a)属性: 品牌(brand),价格(price)
b)功能:
i.特有功能: 打电话(call())
1.输出格式: 在使用3000 元 华为手机打电话
ii.实现接口功能: 玩游戏()
1.输出格式: 在使用3000 元 华为手机发短信
c)提供 空参,有参构造;setters和getters方法
3.定义电脑(Computer)类实现玩游戏接口(PlayGame())
a)属性: 品牌(brand)和价格(price)
b)功能:
i.实现playGame()方法
1.输出格式: 使用6000元的雷神电脑玩游戏
ii.特有功能: 编码(coding)
1.输出格式: 使用6000元的雷神电脑开发JavaEE应用
c)提供空参,有参构造;setters和getters方法
4.定义测试类Test
a)定义main方法
b)在main方法中
i.创建手机对象 p,品牌赋值为华为,价格赋值为3000
ii.调用手机对象 p的玩游戏功能
iii.调用手机对象 p的打电话功能
iv.创建电脑对象 c,品牌赋值为雷神,价格赋值为6000
v.调用电脑对象c的玩游戏功能
vi.调用电脑对象c的编程功能

package com.greedring.practice01;

public interface PlayGame {
    void playGame();
}
package com.greedring.practice01;

public class Phone implements PlayGame {
    private String brand;
    private double price;

    private String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    private double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public Phone() {
    }

    void call() {
        System.out.println("在使用" + getPrice() + "元" + getBrand() + "手机打电话");
    }

    @Override
    public void playGame() {
        System.out.println("在使用" + getPrice() + "元" + getBrand() + "手机发短信");
    }
}
package com.greedring.practice01;

public class Computer implements PlayGame {
    private String brand;
    private double price;

    private String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    private double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    Computer(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    public Computer() {
    }

    void coding() {
        System.out.println("使用" + getPrice() + "元的" + getBrand() + "电脑开发JavaEE应用");
    }

    @Override
    public void playGame() {
        System.out.println("使用" + getPrice() + "元的" + getBrand() + "电脑玩游戏");
    }
}
package com.greedring.practice01;

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone("华为", 3000);
        Computer computer = new Computer("雷神", 6000);
        phone.playGame();
        phone.call();
        computer.playGame();
        computer.coding();
    }
}

训练案例6

  • 训练考核知识点
    继承、接口、类实现接口、多态(向上转型)、向下转型

  • 训练描述
    请使用代码描述:
    奥迪车(Audi)都具有跑的功能,但是智能奥迪车(SmartAudi)除了具有跑的功能外,还具有自动泊车(automaticParking)和无人驾驶(automaticDrive)的功能!
    要求:在测试类中创建Audi车对象和智能奥迪车对象,分别调用各自方法; 然后测试向上转型(转换为父类类型和实现的接口类型)和向下转型.

  • 操作步骤描述

1.定义奥迪车类(Audi)
a)成员方法: 跑(run())
i.输出格式: 奥迪车在跑
2.定义智能接口(Smart)
a)抽象方法: 自动泊车(automaticParking)和无人驾驶(automaticDrive)
3.定义智能奥迪车类(SmartAudi) 继承Audi实现Smart接口
a)成员方法
i.实现automaticParking方法
1.输出:智能奥迪车在自动泊车
ii.实现automaticDrive方法
1.输出:智能奥迪车在无人驾驶
4.定义测试类Test
a)提供main方法
b)在main方法中
i.创建Audi车对象 a,调用跑方法
ii.创建SmartAudi车对象 sa,调用跑,自动泊车,自动驾驶方法
iii.定义Audi类型的变量 aa 把sa赋值aa; 测试aa只能调用run方法,不能调用其他方法
iv.判断如果aa是SmartAudi的实例对象, 把aa强制转换为saa;使用saa调用自动泊车和自动驾驶方法
定义Smart类型的变量 s,把sa赋值给s,测试只能调用自动泊车和自动驾驶方法,不能调用run方法.

package com.greedring.practice02;

public class Test {
    public static void main(String[] args) {
        Audi a = new Audi();
        a.run();
        System.out.println("=======================");
        SmartAudi sa = new SmartAudi();
        sa.run();
        sa.automaticParking();
        sa.automaticDrive();
        System.out.println("=======================");
        Audi aa = sa;
        aa.run();
        if (aa instanceof SmartAudi) {
            SmartAudi saa = (SmartAudi) aa;
            saa.automaticParking();
            saa.automaticDrive();
        }
        System.out.println("=======================");
        Smart s = sa;
        s.automaticParking();
        s.automaticDrive();
        //s.run();
    }
}
package com.greedring.practice02;

class Audi {
    void run() {
        System.out.println("奥迪车在跑");
    }
}
package com.greedring.practice02;

public interface Smart {
    void automaticParking();

    void automaticDrive();
}
package com.greedring.practice02;

public class SmartAudi extends Audi implements Smart {

    @Override
    public void automaticParking() {
        System.out.println("智能奥迪车在自动泊车");
    }

    @Override
    public void automaticDrive() {
        System.out.println("智能奥迪车在无人驾驶");
    }
}

关卡2

训练案例1

  • 训练考核知识点
    继承、接口定义、类实现接口

  • 训练描述
    请使用代码描述:
    100元诺基亚手机(Phone)可以打电话(call)和发短信(sendMessage)
    3000元的华为智能手机可以打电话,发短信和玩游戏(playGame)
    2000元的iPad 平板,可以听歌(listenMusic)和玩游戏.
    要求: 把手机的共性提取到父类中,特性的功能放到接口.

  • 操作步骤描述

1.定义玩游戏(PlayGame)接口
a)声明抽象方法 playGame()
2.定义手机类(Phone)类
a)属性: 品牌(brand),价格(price)
b)功能:
i.打电话(call(String name))
1.输出格式: 在使用100 元 诺基亚 手机 给 景甜 打电话
ii.发短信(sendMessage(String name))
1.输出格式: 在使用100 元 诺基亚 手机 给 景甜 发短信
c)提供 空参,有参构造;setters和getters方法
3.定义智能手机(SmartPhone)类继承手机类(Phone),实现玩游戏接口(PlayGame())
a)实现playGame()方法
i.在使用3000元的 华为 手机玩游戏
b)提供空参,有参构造
4.定义平板(Pad)类,实现PlayGame接口
a)属性:品牌(brand),价格(price)
b)成员方法
i.实现playGame()方法
1.输出格式: 在使用2000元的iPad平板玩游戏
ii.特有方法: 听音乐(listenMusic)
1.输出格式: 在使用2000元的iPad平板听音乐
c)提供空参,有参构造,setters和getters方法
5.定义测试类Test
a)创建手机对象 njy,品牌赋值为诺基亚,价格赋值为100
b)调用手机对象 njy的打印电话和发短信功能,传入 景甜
c)创建智能手机对象 sp,品牌赋值为华为,价格赋值为3000
d)调用智能数据对象sp的打电话,发短信功能都传入林思意, 调用玩游戏功能
e)创建平板对象 p,品牌赋值为iPad,价格赋值为2000
f)调用平板p对象的听歌和玩游戏功能.

package com.greedring.practice03;

public class Test {
    public static void main(String[] args) {
        Phone njy = new Phone("诺基亚", 100);
        njy.call("景甜");
        njy.sendMessage("景甜");
        SmartPhone sp = new SmartPhone("华为", 3000);
        sp.call("林思意");
        sp.sendMessage("林思意");
        sp.playGame();
        Pad p = new Pad("iPad", 2000);
        p.listenMusic();
        p.playGame();
    }
}
package com.greedring.practice03;

public class Phone {
    private String brand;
    private double price;

    String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    Phone() {
    }

    void call(String name) {
        System.out.println("在使用" + getPrice() + "元" + getBrand() + "手机给" + name + "打电话");
    }

    void sendMessage(String name) {
        System.out.println("在使用" + getPrice() + "元" + getBrand() + "手机给" + name + "发短信");
    }
}
package com.greedring.practice03;

public interface PlayGame {
    void playGame();
}
package com.greedring.practice03;

public class SmartPhone extends Phone implements PlayGame {
    SmartPhone(String brand, double price) {
        super(brand, price);
    }

    public SmartPhone() {
    }

    @Override
    public void playGame() {
        System.out.println("在使用" + getPrice() + "元的" + getBrand() + "手机玩游戏");
    }
}
package com.greedring.practice03;

public class Pad implements PlayGame {
    private String brand;
    private double price;

    private String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    private double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public Pad() {
    }

    Pad(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    void listenMusic() {
        System.out.println("在使用" + getPrice() + "元的" + getBrand() + "平板听音乐");
    }

    @Override
    public void playGame() {
        System.out.println("在使用" + getPrice() + "元的" + getBrand() + "平板玩游戏");
    }
}

训练案例2

  • 训练考核知识点
    抽象类、接口、继承、多态、类名作为参数类型、接口作为参数类型

  • 训练描述
    请使用代码描述:
    所有的学生都有年龄和姓名,都会吃饭(学生餐)和学习,但是有部分学生会打篮球
    所有的老师都有年龄和姓名,都会吃饭(工作餐)和讲课,但有部分老师会打篮球
    去打篮球,会打篮球的老师和学生可以. (提示通过在测试类中的静态方法实现)
    去食堂吃饭,所有人都可以去(提示通过在测试类中的静态方法实现)

  • 操作步骤描述

1.定义抽象人类(Person)
a)属性: 姓名(name),年龄(age)
b)抽象方法: eat()
c)提供:无参,有参构造方法和setters和getters方法
2.定义运动接口(Sport)
a)抽象方法: playBasketball
3.定义老师类(Teacher)继承Person类
a) 成员方法:: 实现抽象方法eat()
i.输出格式: 年龄为30岁周晓斌老师,正在吃工作餐
b)提供: 无参,有参构造方法
4.定义运动老师类(SportTeacher)继承老师类(Teacher)实现运动接口
a)成员方法: 实现playBasketball的抽象方法
i.输出格式: 年龄为30岁 周晓斌 老师在打篮球
b)提供: 无参,有参构造方法
5.定义学生类(Student),继承人类(Person)
a)成员方法:现抽象方法eat()
i.输出格式: 年龄18岁的 叶知秋 在吃学生餐
b)提供: 无参,有参构造方法
6.定义运动学生类(SportStudent类),继承Student类,实现Sport接口
a)成员方法: 实现playBasketball的抽象方法
i.输出格式: 年龄为18岁 叶知秋 学生在打篮球
b)提供: 无参,有参构造方法
7.定义测试类Test
a)提供静态方法去运动goToSport(Sport s) ,在方法中调用s的打篮球功能
i.思考这里为什么要传入Sport接口类型
b)提供静态方法去餐馆goToRestaurant(Person p),在方法中调用p对象的吃方法
i.思考这里为什么要传入顶层父类类型
c)提供main方法
d)在main方法中
i.创建运动老师对象sp,年龄赋值为30,姓名赋值为周晓斌
ii.创建运动学生对象ss,年龄赋值为18,姓名赋值为叶知秋
iii.调用去运动goToSport方法传入对象sp
iv.调用去运动goToSport方法,传入对象ss
v.调用去食堂goToRestaurant方法,传入sp
vi.调用去食堂goToRestaurant方法,传入ss

package com.greedring.practice04;

public abstract class Person {
    private String name;
    private int age;

    String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    Person() {
    }

    abstract void eat();
}
package com.greedring.practice04;

public interface Sport {
    void playBasketball();
}
package com.greedring.practice04;

class Teacher extends Person {
    Teacher(String name, int age) {
        super(name, age);
    }

    Teacher() {
    }

    @Override
    void eat() {
        System.out.println("年龄为" + getAge() + "岁" + getName() + "老师,正在吃工作餐");
    }
}
package com.greedring.practice04;

public class SportTeacher extends Teacher implements Sport {
    SportTeacher(String name, int age) {
        super(name, age);
    }

    public SportTeacher() {
    }

    @Override
    public void playBasketball() {
        System.out.println("年龄为" + getAge() + "岁" + getName() + "老师在打篮球");
    }
}
package com.greedring.practice04;

class Student extends Person {
    Student(String name, int age) {
        super(name, age);
    }

    Student() {
    }

    @Override
    void eat() {
        System.out.println("年龄" + getAge() + "岁的" + getName() + "在吃学生餐");
    }
}
package com.greedring.practice04;

public class SportStudent extends Student implements Sport {
    SportStudent(String name, int age) {
        super(name, age);
    }

    public SportStudent() {
    }

    @Override
    public void playBasketball() {
        System.out.println("年龄为" + getAge() + "岁" + getName() + "学生在打篮球");
    }
}
package com.greedring.practice04;

public class Test {
    public static void main(String[] args) {
        SportTeacher sportTeacher = new SportTeacher("周晓斌", 30);
        SportStudent sportStudent = new SportStudent("叶知秋", 18);
        goToSport(sportTeacher);
        goToRestaurant(sportTeacher);
        goToSport(sportStudent);
        goToRestaurant(sportStudent);
    }

    private static void goToSport(Sport sport) {
        sport.playBasketball();
    }

    private static void goToRestaurant(Person person) {
        person.eat();
    }
}

训练案例3

  • 训练考核知识点
    抽象类、继承、接口、接口实现、多态、父类名作为参数类型、接口名作为参数类型、向下转型

  • 训练描述
    请用代码描述:
    在动物园每一个动物都有颜色和年龄,都会吃
    所有老虎都吃肉,但是有的老虎会表演(钻火圈)
    所有的大猩猩都吃香蕉,但有大猩猩会表演(骑自行车)
    所有的鹦鹉都吃小米和说话,但是有的鹦鹉会表演(过跷跷板)
    在动物园中管理员有年龄和姓名,他会喂动物和组织会表演的动物进行演出,如果演出时鹦鹉,还会让鹦鹉说你好

  • 操作步骤描述

1.定义动物类(Animal)
a)属性:颜色(color),年龄(age)
b)抽象方法: 吃(eat)
c)提供: 空参,带参构造;setters和getters方法
2.定义表演者接口(Actor)
a)抽象方法: play()
3.定义老虎类(Tiger),继承动物类(Animal)
a)实现抽象方法: 吃(eat)
i.输出格式: 2岁的黄色老虎吃肉
b)提供: 空参,带参构造;
4.定义会表演的老虎类(ActedTiger),继承老虎类(Tiger),实现表演者接口
a)实现抽象方法表演(play)
i.输出格式: 2岁的黄色老虎在表演钻火圈
b)提供: 空参,带参构造;
5.定义大猩猩类(Gorilla),继承动物类(Animal)
a)实现抽象方法: 吃(eat)
i.输出格式: 3岁的黑色大猩猩吃香蕉
b)提供: 空参,带参构造;
6.定义会表演的大猩猩(ActedGorilla),继承大猩猩类(Gorilla),实现表演者接口
a)实现抽象方法表演(play)
i.输出格式: 3岁的黑色大猩猩在表演骑自行车
b)提供: 空参,带参构造;
7.定义鹦鹉类(Parrot),继承动物类(Animal)
a)实现抽象方法: 吃(eat)
i.输出格式: 1岁的绿色鹦鹉在吃小米
b)特有方法: 说话(say)
i.输出格式: 1岁的绿色鹦鹉在说你好
c)提供: 空参,带参构造;
8.定义会会表演的鹦鹉类(ActedParrot),继承鹦鹉类(Parrot),实现表演者接口
a)实现抽象方法表演(play)
i.输出格式: 1岁的绿色鹦鹉在表演过跷跷板
b)提供: 空参,带参构造;
9.定义动物园管理员类(ZooManager)
a)属性:姓名(name),年龄(age)
b)行为:
i.喂养动物(feed(Animal a)),调用吃的方法;
1.请思考此处为什么使用Animal作为参数类型而不是其子类
2.在方法内部,调用a对象的eat方法
ii.组织演出(letItShow(Actor a))
1.请思考此处为什么使用Actor接口类型作为参数类型而不是其实现类
2.在方法内部
a)调用a的play方法
b)如果是鹦鹉,把a向下转型为Parrot类型,调用说话方法
c) 提供空参,有参构造方法与setters和getters方法
10.定义测试类Test
a)提供main方法
b)在main方法
i.创建会表演的老虎类(ActedTiger)对象t,把颜色赋值为黄色,年龄赋值为2
ii.创建会表演的大猩猩(ActedGorilla)对象g,把颜色赋值黑色,年龄赋值为3
iii.创建会表演的鹦鹉类(ActedParrot)对象 p,把颜色赋值为绿色,年龄赋值1
iv.创建物园管理员类(ZooManager)对象zm,把名称赋值邓超,年龄赋值30
1.调用三次zm对象的喂养动物(feed(Animal a))方法,分别传入t,g,p对象
调用三次zm对象的组织表演(letItShow(Actor a))方法,分别传入t,g,p对象

package com.greedring.practice05;

public abstract class Animal {
    private String color;
    private int age;

    String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    Animal(String color, int age) {
        this.color = color;
        this.age = age;
    }

    Animal() {
    }

    abstract void eat();
}
package com.greedring.practice05;

public interface Actor {
    void play();
}
package com.greedring.practice05;

class Tiger extends Animal {
    Tiger(String color, int age) {
        super(color, age);
    }

    Tiger() {
    }

    @Override
    void eat() {
        System.out.println(getAge() + "岁的" + getColor() + "老虎吃肉");
    }
}
package com.greedring.practice05;

public class ActedTiger extends Tiger implements Actor {
    ActedTiger(String color, int age) {
        super(color, age);
    }

    public ActedTiger() {
    }

    @Override
    public void play() {
        System.out.println(getAge() + "岁的" + getColor() + "老虎在表演钻火圈");
    }
}
package com.greedring.practice05;

class Gorilla extends Animal {
    Gorilla(String color, int age) {
        super(color, age);
    }

    Gorilla() {
    }

    @Override
    void eat() {
        System.out.println(getAge() + "岁的" + getColor() + "大猩猩吃香蕉");
    }
}
package com.greedring.practice05;

public class ActedGorilla extends Gorilla implements Actor {
    ActedGorilla(String color, int age) {
        super(color, age);
    }

    public ActedGorilla() {
    }

    @Override
    public void play() {
        System.out.println(getAge() + "岁的" + getColor() + "大猩猩在表演骑自行车");
    }
}
package com.greedring.practice05;

class Parrot extends Animal {
    Parrot(String color, int age) {
        super(color, age);
    }

    Parrot() {
    }

    @Override
    void eat() {
        System.out.println(getAge() + "岁的" + getColor() + "鹦鹉在吃小米");
    }

    void say() {
        System.out.println(getAge() + "岁的" + getColor() + "鹦鹉在说你好");
    }
}
package com.greedring.practice05;

public class ActedParrot extends Parrot implements Actor {
    ActedParrot(String color, int age) {
        super(color, age);
    }

    public ActedParrot() {
    }

    @Override
    public void play() {
        System.out.println(getAge() + "岁的" + getColor() + "鹦鹉在表演过跷跷板");
    }
}
package com.greedring.practice05;

public class ZooManager {
    private String name;
    private int age;

    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;
    }

    ZooManager(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public ZooManager() {
    }

    void feed(Animal animal) {
        animal.eat();
    }

    void letItShow(Actor actor) {
        if (actor instanceof Parrot) {
            Parrot parrot = (Parrot) actor;
            parrot.say();
        } else {
            actor.play();
        }
    }
}
package com.greedring.practice05;

public class Test {
    public static void main(String[] args) {
        ActedTiger actedTiger = new ActedTiger("黄色", 2);
        ActedGorilla actedGorilla = new ActedGorilla("黑色", 3);
        ActedParrot actedParrot = new ActedParrot("绿色", 1);
        ZooManager zooManager = new ZooManager("邓超", 30);
        zooManager.feed(actedTiger);
        zooManager.feed(actedGorilla);
        zooManager.feed(actedParrot);
        zooManager.letItShow(actedTiger);
        zooManager.letItShow(actedGorilla);
        zooManager.letItShow(actedParrot);
    }
}

关卡3

训练案例1

  • 训练考核知识点
    继承、接口、类实现接口、多态、向下转型

  • 训练描述
    请使用代码描述:
    所有飞机(Plane)都具有飞(fly)的功能,但是战斗机(Battleplane)除了具有飞的功能外,还具有发射炮弹(fire)的功能!
    要求:在测试类中创建战斗机对象,分别调用fly和fire方法; 然后测试向上转型(转换为父类类型和实现的接口类型)和向下转型.

package com.greedring.practice06;

public interface fly {
    void canFly();
}
package com.greedring.practice06;

public class Plane implements fly {

    @Override
    public void canFly() {
        System.out.println("飞机可以飞");
    }
}
package com.greedring.practice06;

class Battleplane extends Plane implements fly {
    void fire() {
        System.out.println("战斗机可以发射炮弹");
    }
}
package com.greedring.practice06;

public class Test {
    public static void main(String[] args) {
        Battleplane battleplane = new Battleplane();
        battleplane.canFly();
        battleplane.fire();
        System.out.println("===============");
        Plane plane = new Battleplane();
        plane.canFly();
        System.out.println("===============");
        Battleplane b = (Battleplane) plane;
        b.fire();
        b.canFly();
    }
}

训练案例2

  • 训练考核知识点
    抽象类、接口、继承、多态、类名作为参数类型、接口作为参数类型、向下转型

  • 训练描述
    请使用代码描述:
    所有的猫都有颜色和年龄,都会吃(吃鱼)和抓老鼠,但是有部猫会卖萌(actingCute)
    所有的狗都有颜色和年龄,都会吃(肯骨头)和看家,但有部分狗会卖萌(actingCute)
    去卖萌,会卖萌的猫和狗可以. (提示通过在测试类中的静态方法实现)
    如果传入的猫就调用猫的抓老鼠方法
    如果传入的狗就调用狗的看家方法
    去吃饭,所有动物都可以去(提示通过在测试类中的静态方法实现)
    如果传入的猫就调用猫的抓老鼠方法
    如果传入的狗就调用狗的看家方法

package com.greedring.practice07;

public abstract class Animal {
    private String color;
    private int age;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    Animal(String color, int age) {
        this.color = color;
        this.age = age;
    }

    Animal() {
    }

    abstract void eat();
}
package com.greedring.practice07;

public interface Cute {
    void actingCute();
}
package com.greedring.practice07;

class Cat extends Animal {
    Cat(String color, int age) {
        super(color, age);
    }

    Cat() {
    }

    @Override
    void eat() {
        System.out.println(getAge() + "岁" + getColor() + "的猫会吃鱼");
    }

    void catchMouse() {
        System.out.println(getAge() + "岁" + getColor() + "的猫会抓老鼠");
    }
}
package com.greedring.practice07;

class Dog extends Animal {
    Dog(String color, int age) {
        super(color, age);
    }

    Dog() {
    }

    @Override
    void eat() {
        System.out.println(getAge() + "岁" + getColor() + "的狗会啃骨头");
    }

    void lookHome() {
        System.out.println(getAge() + "岁" + getColor() + "的狗会看家");
    }
}
package com.greedring.practice07;

public abstract class SomeCat extends Cat implements Cute {
    public SomeCat(String color, int age) {
        super(color, age);
    }

    public SomeCat() {
    }
}
package com.greedring.practice07;

public abstract class SomeDog extends Dog implements Cute {
    public SomeDog(String color, int age) {
        super(color, age);
    }

    public SomeDog() {
    }
}
package com.greedring.practice07;

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("白色", 2);
        cat.eat();
        cat.catchMouse();
        Dog dog = new Dog("黄色", 3);
        dog.eat();
        dog.lookHome();
        actingCute(cat);
        actingCute(dog);
    }

    private static void actingCute(Animal animal) {
        System.out.println(animal.getAge() + "岁" + animal.getColor() + "的动物会卖萌");
    }

}

训练案例3

  • 训练考核知识点
    抽象类、接口、继承、多态、类名作为参数类型、接口作为参数类型

  • 训练描述
    请用代码描述
    在某个公司每一个员工都有工号,姓名和工资,都要工作. 按照做工作的内容不同分为行政部(AdminStaff),开发部(Developer)和财务部(Treasurer)
    所有行政部人员都要工作(采购),但是有的行政部员工会表演(跳舞)
    所有的开发部人员都要工作(编程),但有开发部员工会表演(唱歌)
    所有的财务部人员都要工作(对账),但是有的财务部员工表演(玩魔术)
    35岁的薛之谦老板会安排员工工作和组织员工表演.

package com.greedring.practice08;

abstract public class Person implements Showing{
    private int id;
    private String name;
    private int salary;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    Person(int id, String name, int salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }

    Person() {
    }

    abstract void work();
}

package com.greedring.practice08;

public interface Showing {
    void show();
}
package com.greedring.practice08;

public class AdminStaff extends Person implements Showing {
    public AdminStaff(int id, String name, int salary) {
        super(id, name, salary);
    }

    AdminStaff() {
    }

    @Override
    public void show() {
        System.out.println("有的行政部员工会表演(跳舞)");
    }

    @Override
    void work() {
        System.out.println("所有行政部人员都要工作(采购)");
    }
}
package com.greedring.practice08;

public class Developer extends Person implements Showing {
    public Developer(int id, String name, int salary) {
        super(id, name, salary);
    }

    Developer() {
    }

    @Override
    public void show() {
        System.out.println("有开发部员工会表演(唱歌)");
    }

    @Override
    void work() {
        System.out.println("所有的开发部人员都要工作(编程)");
    }
}
package com.greedring.practice08;

public class Treasurer extends Person implements Showing {
    public Treasurer(int id, String name, int salary) {
        super(id, name, salary);
    }

    Treasurer() {
    }

    @Override
    public void show() {
        System.out.println("有的财务部员工表演(玩魔术)");
    }

    @Override
    void work() {
        System.out.println("所有的财务部人员都要工作(对账)");
    }
}
package com.greedring.practice08;

public class Boss {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    Boss(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public Boss() {
    }

    void work() {
        System.out.println(getAge() + "岁的" + getName() + "老板会安排员工工作和组织员工表演");
    }
}
package com.greedring.practice08;

public class Test {
    public static void main(String[] args) {
        AdminStaff adminStaff = new AdminStaff();
        adminStaff.work();
        adminStaff.show();
        Developer developer = new Developer();
        developer.work();
        developer.show();
        Treasurer treasurer = new Treasurer();
        treasurer.work();
        treasurer.show();
        Boss boss = new Boss(35, "薛之谦");
        Organization(adminStaff, boss);
        Organization(developer, boss);
        Organization(treasurer, boss);
    }

    private static void Organization(Person person, Boss boss) {
        boss.work();
        person.work();
        person.show();
    }
}
本文作者:GreedRing
本文链接:http://greedring.com/2019/08/28/JavaSEPractice10/
版权声明:本文采用 CC BY-NC-SA 3.0 CN 协议进行许可