同步练习(Java SE(五))

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量159 收藏
点赞数
分类专栏： 同步练习 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52993606/article/details/121113817
版权

案例一: 存储字符串并遍历

需求: 创建一个存储字符串的集合，存储3个字符串元素，使用程序实现在控制台遍历该集合

思路: 1.创建集合对象

        2.往集合中添加字符串对象

        3.遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(int index)方法实现

        4.遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现

        5.遍历集合的通用格式

package test;

import java.util.ArrayList;

public class Test38 {
    public static void main(String[] args) {
        // 1.创建集合对象
        ArrayList<String> arrayList = new ArrayList<String>();
        // 2.往集合中添加字符串对象
        arrayList.add("张三");
        arrayList.add("李四");
        arrayList.add("王五");
        // 3.遍历集合，首先要能够获取到集合中的每一个元素，这个通过get(int index)方法实现
        // 4.遍历集合，其次要能够获取到集合的长度，这个通过size()方法实现
        // 5.遍历集合的通用格式
        for (int i = 0; i<arrayList.size(); i++){
            System.out.println("第"+(i+1)+"个元素为:"+arrayList.get(i));
        }
    }
}

案例二: 存储学生对象并遍历

需求: 创建一个学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历该集合

思路: 1.定义学生类

        2.创建集合对象

        3.创建学生对象

        4.添加学生对象到集合中

        5.遍历集合，采用通用遍历格式实现

学生类

package test.test39;

// 1.定义学生类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

测试类

package test.test39;

import java.util.ArrayList;

public class StudentTest {
    public static void main(String[] args) {
        // 2.创建集合对象
        ArrayList<Student> arrayList = new ArrayList<Student>();
        // 3.创建学生对象
        Student stu1 = new Student("张三",18);
        Student stu2 = new Student("李四",20);
        Student stu3 = new Student("王五",16);
        // 4.添加学生对象到集合中
        arrayList.add(stu1);
        arrayList.add(stu2);
        arrayList.add(stu3);
        // 5.遍历集合，采用通用遍历格式实现
        for (int i = 0; i<arrayList.size(); i++){
            System.out.println("第"+(i+1)+"个学生的姓名为:"+arrayList.get(i).getName()+",年龄为"+arrayList.get(i).getAge());
        }
    }
}

案例三: 存储学生对象并遍历

需求: 创建一个学生对象的集合，存储三个学生对象，使用程序实现在控制台遍历该集合

        学生的姓名和年龄来自于键盘录入

思路: 1.定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型

        2.创建集合对象

        3.键盘录入学生对象所需要的的数据

        4.创建学生对象，把键盘录入的数组赋值给学生对象的成员变量

        5.往集合中添加学生对象

        6.遍历集合，采用通用遍历格式实现

学生类

package test.test40;

// 1.定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为String类型
public class Student {
    private String name;
    private String age;

    public Student() {
    }

    public Student(String name, String age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public String getAge() {
        return age;
    }

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

测试类

package test.test40;

import java.util.ArrayList;
import java.util.Scanner;

public class StudentTest {
    public static void main(String[] args) {
        // 2.创建集合对象
        ArrayList<Student> arrayList = new ArrayList<>();

        addStudent(arrayList);
        addStudent(arrayList);
        addStudent(arrayList);

        // 6.遍历集合，采用通用遍历格式实现
        for (int i = 0; i<arrayList.size(); i++){
            System.out.println("第"+(i+1)+"个学生的姓名为:"+arrayList.get(i).getName()+",年龄为"+arrayList.get(i).getAge());
        }
    }

    public static void addStudent(ArrayList<Student> arrayList){
        // 3.键盘录入学生对象所需要的的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入学生姓名:");
        String name = sc.nextLine();
        System.out.println("请输入学生年龄:");
        String age = sc.nextLine();
        // 4.创建学生对象，把键盘录入的数组赋值给学生对象的成员变量
        Student stu = new Student(name, age);
        // 5.往集合中添加学生对象
        arrayList.add(stu);
    }
}

案例四: 老师和学生

需求: 定义老师类和学生类，然后写代码测试;最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式写代码，并进行测试

思路: 1.定义老师类(姓名，年龄，教书())

        2.定义学生类(姓名，年龄，学习())

        3.定义测试类，写代码测试

        4.共性抽取父类，定义为人类(姓名，年龄)

        5.定义老师类，继承人类，并给出自己特有的方法: 教书()

        6.定义学生类，继承人类，并给出自己特有的方法: 学习()

        7.定义测试类，写代码测试

最初老师类

package test.test41;

// 1.定义老师类(姓名，年龄，教书())
public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public void teach(){
        System.out.println("用爱成就每一个成员");
    }
}

最初学生类

package test.test41;

// 2.定义学生类(姓名，年龄，学习())
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public void study(){
        System.out.println("好好学习，天天向上");
    }
}

最初测试类

package test.test41;

// 3.定义测试类，写代码测试
public class Demo {
    public static void main(String[] args) {
        //创建老师类对象进行测试
        Teacher t1 = new Teacher();
        t1.setName("张三");
        t1.setAge(30);
        System.out.println(t1.getName()+","+t1.getAge());
        t1.teach();

        Teacher t2 = new Teacher("李四",33);
        System.out.println(t2.getName()+","+t2.getAge());
        t2.teach();
    }
}

共性抽取出的父类

package test.test42;

// 4.共性抽取父类，定义为人类(姓名，年龄)
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

最终老师类

package test.test42;

// 5.定义老师类，继承人类，并给出自己特有的方法: 教书()
public class Teacher extends Person {
    public Teacher() {
    }

    public Teacher(String name, int age) {
        super(name, age);
    }

    public void teach(){
        System.out.println("用爱成就每一位学员");
    }
}

最终学生类

package test.test42;

// 6.定义学生类，继承人类，并给出自己特有的方法: 学习()
public class Student extends Person{
    public Student() {
    }

    public Student(String name, int age) {
        super(name, age);
    }

    public void study(){
        System.out.println("好好学习，天天向上");
    }
}

最终测试类

package test.test42;

// 7.定义测试类，写代码测试
public class PersonDemo {
    public static void main(String[] args) {
        //创建老师类对象并进行测试
        Teacher t1 = new Teacher();
        t1.setName("张三");
        t1.setAge(30);
        System.out.println(t1.getName()+","+t1.getAge());
        t1.teach();

        Teacher t2 = new Teacher("李四",33);
        System.out.println(t2.getName()+","+t2.getAge());
        t2.teach();

        //创建学生类对象进行测试
        Student s1 = new Student();
        s1.setName("王五");
        s1.setAge(18);
        System.out.println(s1.getName()+","+s1.getAge());
        s1.study();

        Student s2 = new Student("赵六",17);
        System.out.println(s2.getName()+","+s2.getAge());
        s2.study();
    }
}

案例五: 猫和狗

需求: 请采用继承的思想实现毛和狗的案例，并在测试类中进行测试

分析:

1.猫: 

        成员变量: 姓名，年龄

        构造方法: 有参，无参

        成员方法: get/set方法，抓老鼠()

2.狗:

        成员变量: 姓名，年龄

        构造方法: 有参，无参

        成员方法: get/set方法，看门()

3.共性: 

        成员变量: 姓名，年龄

        构造方法: 有参，无参

        成员方法: get/set方法

思路: 1.定义动物类(Animal)

                成员变量: 姓名，年龄

                构造方法: 有参，无参

                成员方法: get/set方法

        2.定义猫类(Cat),继承动物类

                构造方法: 有参，无参

                成员方法: 抓老鼠()

        3.定义狗类(Dog),继承动物类

                构造方法: 有参，无参

                成员方法: 看门()

        4.定义测试类(AnimalDemo),写代码测试

动物类

package test.test43;

/**
 * 1.定义动物类(Animal)
 *      成员变量: 姓名，年龄
 *      构造方法: 有参，无参
 *      成员方法: get/set方法
 */
public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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;
    }
}

猫类

package test.test43;

/**
 * 2.定义猫类(Cat),继承动物类
 *      构造方法: 有参，无参
 *      成员方法: 抓老鼠()
 */
public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

狗类

package test.test43;

/**
 * 3.定义狗类(Dog),继承动物类
 *      构造方法: 有参，无参
 *      成员方法: 看门()
 */
public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    public void lookDoor(){
        System.out.println("狗看门");
    }
}

动物测试类

package test.test43;

// 4.定义测试类(AnimalDemo),写代码测试
public class AnimalDemo {
    public static void main(String[] args) {
        // 创建猫类对象并进行测试
        Cat c1 = new Cat();
        c1.setName("加菲");
        c1.setAge(5);
        System.out.println(c1.getName()+","+c1.getAge());
        c1.catchMouse();

        Cat c2 = new Cat("加菲猫",5);
        System.out.println(c2.getName()+","+c2.getAge());
        c2.catchMouse();

        //创建狗类对象并进行测试
        Dog d1 = new Dog();
        d1.setName("二和");
        d1.setAge(3);
        System.out.println(d1.getName()+","+d1.getAge());
        d1.lookDoor();

        Dog d2 = new Dog("哈士奇",2);
        System.out.println(d2.getName()+","+d2.getAge());
        d2.lookDoor();
    }
}

案例六: 猫和狗

需求: 请采用多态的思想实现毛和狗的案例，并在测试类中进行测试

思路: 1.定义动物类(Animal)

                成员变量: 姓名，年龄

                构造方法: 有参，无参

                成员方法: get/set方法,吃饭()

        2.定义猫类(Cat),继承动物类

                构造方法: 有参，无参

                成员方法: 重写吃饭()

        3.定义狗类(Dog),继承动物类

                构造方法: 有参，无参

                成员方法: 重写吃饭()

        4.定义测试类(AnimalDemo),写代码测试

动物类

package test.test44;

/**
 * 1.定义动物类(Animal)
 *      成员变量: 姓名，年龄
 *      构造方法: 有参，无参
 *      成员方法: get/set方法,吃饭()
 */
public class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public void eat(){
        System.out.println("动物吃东西");
    }
}

猫类

package test.test44;

/**
 * 2.定义猫类(Cat),继承动物类
 *      构造方法: 有参，无参
 *      成员方法: 重写吃饭()
 */
public class Cat extends Animal {
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

狗类

package test.test44;

/**
 * 3.定义狗类(Dog),继承动物类
 *      构造方法: 有参，无参
 *      成员方法: 重写吃饭()
 */
public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

动物测试类

package test.test44;

// 4.定义测试类(AnimalDemo),写代码测试
public class AnimalDemo {
    public static void main(String[] args) {
        // 创建猫类对象并进行创建
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        // 创建狗类对象并进行测试
        Animal b = new Dog();
        b.setName("二哈");
        b.setAge(3);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();

        b = new Dog("哈士奇",2);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
    }
}

案例七: 猫和狗

需求: 请采用抽象类的思想实现猫和狗的案例，并在测试类中进行测试

思路: 1.定义动物类(Animal)

                成员变量: 姓名，年龄

                构造方法: 有参，无参

                成员方法: get/set方法,吃饭();

        2.定义猫类(Cat),继承动物类

                构造方法: 有参，无参

                成员方法: 重写吃饭(){...}

        3.定义狗类(Dog),继承动物类

                构造方法: 有参，无参

                成员方法: 重写吃饭(){...}

        4.定义测试类(AnimalDemo),写代码测试

动物类

package test.test45;

/**
 * 1.定义动物类(Animal)
 *      成员变量: 姓名，年龄
 *      构造方法: 有参，无参
 *      成员方法: get/set方法,吃饭();
 */
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public abstract void eat();
}

猫类

package test.test45;

/**
 * 2.定义猫类(Cat),继承动物类
 *      构造方法: 有参，无参
 *      成员方法: 重写吃饭(){...}
 */
public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

狗类

package test.test45;

/**
 * 3.定义狗类(Dog),继承动物类
 *      构造方法: 有参，无参
 *      成员方法: 重写吃饭(){...}
 */
public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

动物测试类

package test.test45;

// 4.定义测试类(AnimalDemo),写代码测试
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，按照多态的方式
        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("---------");

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("---------");

        Animal b = new Dog();
        b.setName("二哈");
        b.setAge(3);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
        System.out.println("---------");

        b = new Dog("哈士奇",2);
        System.out.println(b.getName()+","+b.getAge());
        b.eat();
    }
}

案例七: 猫和狗

需求: 对猫和狗进行训练，他们就可以跳高了，这里加入了跳高功能。请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试

思路: 1.定义接口(Jumpping)

                成员方法: 跳高();

        2.定义抽象动物类(Animal)

                成员变量: 姓名，年龄;构造方法: 无参，有参;成员方法: get/set方法，吃饭();

        3.定义具体猫类(Cat),继承动物类，实现跳高接口

                构造方法: 无参，有参;成员方法: 重写吃饭(){...}，重写跳高方法(){...}

        4.定义具体狗类(Dog),继承动物类，实现跳高接口

                构造方法: 无参，有参;成员方法: 重写吃饭(){...}，重写跳高方法(){...}

        5.定义测试类(AnimalDemo)，写代码测试

接口(Jumpping)

package test.test46;

/**
 * 1.定义接口(Jumpping)
 *      成员方法: 跳高();
 */
public interface Jumpping {
    public abstract void jump();
}

抽象动物类(Animal)

package test.test46;

/**
 * 2.定义抽象动物类(Animal)
 *      成员变量: 姓名，年龄;构造方法: 无参，有参;成员方法: get/set方法，吃饭();
 */
public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public abstract void eat();
}

具体猫类(Cat)

package test.test46;

/**
 * 3.定义具体猫类(Cat),继承动物类，实现跳高接口
 *      构造方法: 无参，有参;成员方法: 重写吃饭(){...}，重写跳高方法(){...}
 */
public class Cat extends Animal implements Jumpping{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}

具体狗类(Dog)

package test.test46;

/**
 * 4.定义具体狗类(Dog),继承动物类，实现跳高接口
 *      构造方法: 无参，有参;成员方法: 重写吃饭(){...}，重写跳高方法(){...}
 */
public class Dog extends Animal implements Jumpping{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void jump() {
        System.out.println("狗可以跳高了");
    }
}

测试类(AnimalDemo)

package test.test46;

// 5.定义测试类(AnimalDemo)，写代码测试
public class AnimalDemo {
    public static void main(String[] args) {
        // 创建对象，调用方法
        Jumpping j = new Cat();
        j.jump();
        System.out.println("--------");

        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();

        a = new Cat("加菲",4);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------");

        // 平时用法
        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();

        c = new Cat("加菲",4);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
        System.out.println("--------");

        Dog d = new Dog();
        d.setName("二哈");
        d.setAge(3);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        d.jump();

        d = new Dog("二哈",2);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        d.jump();
    }
}

案例八: 运动员和教练

需求: 我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。为了出国交流，跟乒乓球相关的人员都要学习英语。请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现

分析: 从具体到抽象

实现: 从抽象到具体

使用: 使用的是具体的类的对象

思路: 1.定义说英语接口   成员方法: 说英语();

        2.定义抽象人类   成员变量: 姓名，年龄; 构造方法: 无参，带参; 成员方法: get/set方法，吃饭();

        3.定义抽象教练类，继承人类   构造方法: 无参，带参; 成员方法: 教();

        4.定义抽象运动员类，继承人类   构造方法: 无参，带参; 成员方法: 学习();

        5.定义具体篮球教练类，继承教练类   构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写教(){...}

        6.定义具体乒乓球教练类，继承教练类，实现说英语接口

                构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写教(){...}，重写说英语(){...}

        7.定义具体的篮球运动员，继承运动员类   构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写学习(){...}

        8.定义具体乒乓球运动员类，继承运动员，实现说英语接口

                构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写学习(){...}，重写说英语(){...}

        9.定义测试了，写代码测试

说英语接口

package test.test47;

// 1.定义说英语接口 成员方法: 说英语();
public interface SpeakEnglish {
    public abstract void speak();
}

抽象人类

package test.test47;

// 2.定义抽象人类 成员变量: 姓名，年龄; 构造方法: 无参，带参; 成员方法: get/set方法，吃饭();
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    public abstract void eat();
}

抽象教练类

package test.test47;

// 3.定义抽象教练类，继承人类 构造方法: 无参，带参; 成员方法: 教();
public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

抽象运动员类

package test.test47;

// 4.定义抽象运动员类，继承人类 构造方法: 无参，带参; 成员方法: 学习();
public abstract class Player extends Person{
    public Player() {
    }

    public Player(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

具体篮球教练类

package test.test47;

// 5.定义具体篮球教练类，继承教练类 构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写教(){...}
public class BasketballCoach extends Coach{
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练教如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球教练吃羊肉，喝羊奶");
    }
}

具体乒乓球教练类

package test.test47;

/**
 * 6.定义具体乒乓球教练类，继承教练类，实现说英语接口
 *      构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写教(){...}，重写说英语(){...}
 */
public class PingPangCoach extends Coach implements SpeakEnglish{
    public PingPangCoach() {
    }

    public PingPangCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练教如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃小白菜，喝大米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球教练说英语");
    }
}

具体篮球运动员类

package test.test47;

// 7.定义具体的篮球运动员，继承运动员类 构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写学习(){...}
public class BasketballPlayer extends Player{
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员学习如何运球和投篮");
    }

    @Override
    public void eat() {
        System.out.println("篮球运动员吃牛肉，喝牛奶");
    }
}

具体乒乓球运动员类

package test.test47;

/**
 * 8.定义具体乒乓球运动员类，继承运动员，实现说英语接口
 *      构造方法: 无参，带参; 成员方法:重写吃饭(){...},重写学习(){...}，重写说英语(){...}
 */
public class PingPangPlayer extends Player implements SpeakEnglish{
    public PingPangPlayer() {
    }

    public PingPangPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学习如何发球和接球");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃大白菜，喝小米粥");
    }

    @Override
    public void speak() {
        System.out.println("乒乓球运动员说英语");
    }
}

测试类

package test.test47;

// 9.定义测试了，写代码测试
public class PersonDemo {
    public static void main(String[] args) {
        //创建对象
        PingPangPlayer ppp = new PingPangPlayer();
        ppp.setName("王浩");
        ppp.setAge(30);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();
        System.out.println("--------");

        ppp = new PingPangPlayer("马龙",25);
        System.out.println(ppp.getName()+","+ppp.getAge());
        ppp.eat();
        ppp.study();
        ppp.speak();
        System.out.println("--------");

        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("姚明");
        bp.setAge(35);
        System.out.println(bp.getName()+","+bp.getAge());
        bp.eat();
        bp.study();
        System.out.println("--------");

        bp = new BasketballPlayer("易建联",30);
        System.out.println(bp.getName()+","+bp.getAge());
        bp.eat();
        bp.study();
        System.out.println("--------");

        PingPangCoach ppc = new PingPangCoach();
        ppc.setName("刘国梁");
        ppc.setAge(45);
        System.out.println(ppc.getName()+","+ppc.getAge());
        ppc.eat();
        ppc.teach();
        ppc.speak();
        System.out.println("--------");

        ppc = new PingPangCoach("孔令辉",40);
        System.out.println(ppc.getName()+","+ppc.getAge());
        ppc.eat();
        ppc.teach();
        ppc.speak();
        System.out.println("--------");

        BasketballCoach bc = new BasketballCoach();
        bc.setName("杨鸣");
        bc.setAge(30);
        System.out.println(bc.getName()+","+bc.getAge());
        bc.eat();
        bc.teach();
        System.out.println("--------");

        bc = new BasketballCoach("杜峰",35);
        System.out.println(bc.getName()+","+bc.getAge());
        bc.eat();
        bc.teach();
        System.out.println("--------");
    }
}

XinSKY丶TOT
关注
专栏目录
第十一天 面向对象-接口&多态【悟空教程】
Java帮帮
09-25 720
    第11天 面向对象 第1章 接口 1.1 接口概念 1.1.1 接口概念 接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。 接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。 请记住：一切事物均有功能即一切事物均有接口。 继承是方便类的定义，可以定义一...
day8 面向对象3作业
qq_25534101的博客
09-03 1046
一、基础案例 1．训练案例1 1.1．训练描述：【final关键字特点】 一、需求说明：定义子父类，父类如果被final修饰，测试子类能否继承父类。 二、再定义普通的子父类，父类中有方法被final所修饰，测试子类能否重写该方法。 三、定义一个类，该类中有final修饰的变量，并对其进行初始化，在该类中定义一个普通方法，测试这个变量值能否修改。 1.2．操作步骤描述 1.创建Father类，该类被final修饰。 2.创建Son类，并继承Father类，查看编译结果。 3.将上述内容注释掉，接下来，定义普通
需求:定义老师和学生类,然后写代码测试；最后找到老师类和学生类当中的共性内容,抽出一个父类,用继承的方式改写代码,并进行测试
o676448的博客
02-08 1211
需求:定义老师和学生类,然后写代码测试;最后找到老师类和学生类当中的共性内容,抽出一个父类 ,用继承的方式改写代码,并进行测试 思路: 1.定义老师类(姓名,年龄,教书()) 2.定义学生类(姓名,年龄,学习()) 3.定义测试类,写代码测试
java动物类继承鱼儿和狗类_Java基础-day10-代码题-继承&抽象类
weixin_31863707的博客
02-25 823
Java基础-day10-代码题-继承&抽象类1.门类继承题：编写代码，实现如下功能：(1)定义一个门类，包含3个属性：宽度width 和 高度height ，颜色color包含2个方法：开门和关门开门方法：输出“门已经打开，请进！”关门方法：输出“门已经关闭，禁止进入！”(2)定义一个木头门WOOD，继承Door重写父类开门方法：输出门的高度 宽度 颜色 +“门已经打开，请进！”重...
继承练习1：学生和教师
元气满满晨
08-13 971
/* 版本V2.0：使用继承后 学生： 成员变量：姓名、年龄 构造方法：无参 成员方法：setXxx()/getXxx() 老师： 成员变量：姓名、年龄 构造方法：无参 成员方法：setXxx()/getXxx() //若用带参的构造方法初始化对象，继承的话，没...
JAVA SE源码练习 Java学习资料
06-25
这个"JAVA SE源码练习"的压缩包文件包含了丰富的Java学习资料，可能是为了帮助初学者或有经验的开发者深入理解Java语言的内部机制和最佳实践。 在Java SE中，最重要的部分是JVM（Java虚拟机），它是Java程序运行的...
java se代码练习 Java学习资料
06-25
这份"java se代码练习"的资源包显然包含了用于学习Java编程的基础代码示例和练习，适合初学者或希望深入理解Java语言特性的开发者。下面我们将深入探讨Java SE中的关键知识点，并结合提供的文件名"jsd2204-se-master...
Java SE 基础 练习 Java学习资料
06-24
这份"Java SE 基础 练习 Java学习资料"包含的资源将帮助你深入理解Java编程语言的基础概念和实战技能。以下是这些学习资料可能涵盖的一些关键知识点： 1. **Java环境配置**：首先，你需要安装JDK（Java Development...
java SE基础练习 Java学习资料
06-25
这个“java SE基础练习”资料包显然是为了帮助初学者或者希望巩固基础的开发者准备的。它可能包含了源代码示例、教程文档、练习题等丰富的学习资源。下面我们将深入探讨Java SE的一些关键知识点。 1. **基础语法**...
java se 基础练习 Java学习资料
06-29
这份"java se 基础练习"的学习资料旨在帮助初学者巩固和深化Java编程基础，从而更好地掌握这门广泛使用的编程语言。以下将详细介绍Java SE的基础知识点： 1. **Java环境配置**：在开始Java编程之前，首先需要在...
php构建函数的继承 人类学生类,4.37 使用继承学生和老师案例
weixin_39989222的博客
03-27 293
/*学生案例和老师案例讲解学生：成员变量；姓名，年龄构造方法：无参，带参成员方法：getXxx()/setXxx()老师：成员变量；姓名，年龄构造方法：无参，带参成员方法：getXxx()/setXxx()*///定义学生类classStudent{//姓名privateStringname;//年龄privateintage;publicStudent(){}publicS...
day7作业
qq_25534101的博客
08-31 992
一、基础案例 1．训练案例1 1.1．训练描述：【继承】 一、分析以下需求，并用代码实现： 1.定义Person类 属性：姓名name、年龄age； 方法：空参构造方法、满参构造方法、setXxx()、getXxx()、工作work。 2.根据人类，派生一个老师类Teacher 重写工作方法（老师的工作是要好好讲课）。 3.根据人类，派生一个学生类Student 重写工作方法（学生的工作是要好好学习）。 4.编写测试类分别对上述2类具体人物进行测试 5.要求运行结果: 学生的工作要好好学习 老师的工作要好
【Python作业】定义动物类Animal，...编写猫类Cat...
热门推荐
微信公众号: 后端码匠
11-13 1万+
代码 class Animal(object): """定义动物类""" name = "" time = 0 def __init__(self, name, time): self.setName(name) self.setTime(time) def setName(self, name): self.name = name def setTime(self, time): if n
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 417
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 526
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1226
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 792
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 321
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
Java SE 5.0多线程及同步机制详解
Java SE 5.0引入的特性包括对线程同步机制的改进，这有助于避免常见的并发问题，如竞态条件和死锁。学习者需要了解如何使用synchronized关键字、wait()和notify()方法、以及Lock接口来管理线程间的协调。作者强调，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

XinSKY丶TOT

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值