Java 类和对象练习3

Kilo.

于 2024-01-25 20:01:32 发布

阅读量516

点赞数 11

文章标签： java 开发语言 intellij-idea 软件工程

本文链接：https://blog.csdn.net/qq_60694399/article/details/135852362

版权

模拟主人喂养宠物的场景。

主人类：Master

宠物类：Pet

宠物子类：Dog Cat Bird

主人喂养方法feed()，宠物吃的方法有eat()，主人提供一种喂养方法，要求达到喂养各种类型宠物的目的。

测试类，创建主人对象，创建各种宠物对象，调用主人喂养方法feed（），喂养不同的宠物，观察结果。

/定义主人类
public class Master{
   //构造喂养方法
    public void feed(Pet pet){
        System.out.println("主人在喂宠物");
        pet.eat();
    }

}
//定义宠物抽象类
public abstract class Pet {
    //构造宠物吃饭方法
    public abstract void eat();
}
//dog继承pet类
public class Dog extends Pet {
    //重写喂养狗狗方法
    @Override
    public void eat(){
        System.out.println("狗狗正在吃主人喂的狗粮");
    }

}
//猫猫继承pet类
public class Cat extends Pet {
    //重写猫猫喂养方法
    @Override
    public void eat(){
        System.out.println("猫猫在吃主人喂的猫粮");
    }
}
//bird继承pet类
public class Bird extends Pet {
    //重写喂养小鸟方法
    @Override
    public void eat() {
        System.out.println("小鸟在吃主人喂的鸟食");
    }
}
//定义测试类
public class Test {
    public static void main(String[] args){
        //创建master对象
        Master master=new Master();
        //创建dog对象
        Pet dog = new Dog();
        //创建dog对象
        Pet cat = new Cat();
        //创建cat对象
        Pet bird = new Bird();
        //主人喂养狗狗
        master.feed(dog);
        //主人喂养猫猫
        master.feed(cat);
        //主人喂养小鸟
        master.feed(bird);


    }
}

编写Point类

属性：坐标x，y

提供set、get方法，构造方法，print（）输出信息

编写Line类继承point类

提供方法，求线段长度的方法Math.sqrt(Math.pow(x1-x1,2)+ Math.pow(y1-y2,2))

测试类：

创建两个Point对象，和Line对象line

调用line的getLen方法，获得线段长度，并打印输出

//定义Point类
public class Point {
    private double x;
    private double y;
//无参构造方法
  public Point(){

  }
//有参构造方法
    public Point(double x,double y){
      this.x=x;
      this.y=y;

    }
    //y的赋值方法
    public void setY(double y) {
        this.y = y;
    }
    //x的赋值方法

    public void setX(double x) {
        this.x = x;
    }
    //获取x的方法
    public double getX() {
        return x;
    }
    //获取y的方法
    public double getY() {
        return y;
    }
    //重写方法
    @Override
    public String toString(){
      return "Point{" + "x=" + x + ", y=" + y + '}';
    }
        
    }
//Line类继承Point类
public class Line extends Point {
    private double x1;
    private double x2;
    private double y1;
    private double y2;
    //构造Line有参方法
    public Line(double x1,double y1,double x2,double y2){
        super(x1,y1);
        this.x1=x1;
        this.y1=y1;
        this.x2=x2;
        this.y2=y2;

    }
    //构造Line无参方法
    public Line(){

    }
    //构造获取线段长度的方法getLine
    public double getLen(){
        return Math.sqrt(Math.pow(x1-x2,2)+ Math.pow(y1-y2,2));
    }
    //重写父类方法toString
    @Override
    public String toString(){
       return "Line{" + "x1=" + x1 + ", y1=" + y1 + ", x2=" + x2 + ", y2=" + y2 + '}';
    }


}
public class Test {
    public static void main(String[] args) {
        //创建Point对象p1
        Point p1 = new Point(1, 4);
        //创建Point对象p2
        Point p2 = new Point(3, 8);
        //创建Line对象l
        Line l = new Line(p1.getX(), p1.getY(), p2.getX(), p2.getY());
        //输出线段的长度
        System.out.println("线段的长度为 "+l.getLen());
        //测试输出l的信息
        System.out.println(l);
        //测试输出p1的信息
        System.out.println(p1);

    }
}

定义抽象类Shape：定义抽象方法，求面积 getArea（）

编写两个子类：Rectangle类和Circle类

Rectangle类：定义属性，长length、宽width

重写方法getArea（）

Circle类：定义属性，半径radius

重写方法getArea（）

编写测试类：Shape shape= new Rectangle（6,8）；

Shape shape= new Circle（10）；实现向上转型

//定义抽象类Shape
public abstract class Shape {
    //定义抽象方法getArea()
    public abstract double getArea();
}
//定义Shape子类Rectangle
public class Rectangle extends Shape  {
    //定义宽度
    private double wide;
    //定义长度
    private double length;
    //构造有参方法
    public  Rectangle (double wide,double length)  {
        this.wide=wide;
        this.length =length;

    }
    //构造无参方法
    public Rectangle (){

    }
    //重写getArea方法
    @Override
    public double getArea() {
        return length * wide;
    }


}
//定义Shape子类Circle
public class Circle extends Shape {
    //定义半径
    private double radius;
    //构造有参方法
    public Circle(double radius){
        this.radius =radius;
    }
    //构造无参方法
    public Circle(){
        
    }
    //重写getArea方法
    @Override
    public double getArea(){
        //返回圆的面积
        return Math.PI * Math.pow(radius, 2);
    }

}
//定义测试类
public class Test {
    public static void main(String[] args){
        //创建对象shape1为长方形并实例化向上转型赋值
        Shape shape1= new Rectangle(6,8);
        System.out.println("Rectangle area: "+shape1.getArea() );
        //创建对象shape2为圆形，并实例化向上转型赋值
        Shape shape2= new Circle(10);
        System.out.println("Circle area: "+shape2.getArea() );

    }
}

编写带有接口和抽象类的标准Javabean类

参加奥运会的有乒乓球运动员和羽毛球运动员，乒乓球教练和羽毛球教练。

为方便交流，跟乒乓球相关的所有人员都需要学习外语。

请分析如何设计所有的类，哪些设计为接口，哪些为抽象类

乒乓球运动员：姓名、年龄、打乒乓球、学英语

羽毛球运动员：姓名、年龄、打羽毛球

乒乓球教练：姓名、年龄、教乒乓球、学英语

羽毛球教练：姓名、年龄、教羽毛球

//定义语言接口
public interface Language {
    //定义方法
    void learnLanguage();
}
//定义抽象类Person
public abstract class Person{
    //定义name属性
    private String name;
    //定义age属性
    private int age;
    //构造无参方法
    public Person(){

    }
    //构造有参方法
    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    //age赋值方法
    public void setAge(int age) {
        this.age = age;
    }
    //name赋值方法
    public void setName(String name) {
        this.name = name;
    }
    //获取name
    public String getName() {
        return name;
    }
    //获取age
    public int getAge() {
        return age;
    }

}
//定义抽象类Coach继承Person
public abstract class Coach extends Person{
    //构造无参方法
    public  Coach(){

    }
    //构造有参方法
    public Coach(String name,int age){
        //访问父类属性
        super(name,age);
    }
    //构造teach方法
    public abstract void teach();

        }
//定义抽象类Sporatsman继承Person
public abstract class Sportsman extends Person {
    //构造无参方法
    public Sportsman (){

    }
    //构造有参方法
    public Sportsman (String name,int age){
        //访问父类属性
        super(name,age);
    }
    //构造learn方法
    public abstract void learn();
}
//Basketballcoach类继承Coach类
public class Basketballcoach extends Coach{
    //构造无参方法
    public Basketballcoach (){

    }
    //构造有参方法
    public Basketballcoach(String name,int age){
        //调用父类属性
        super(name,age);
    }
    //重写teach方法
    @Override
    public void teach() {
        System.out.println("篮球教练教运动员篮球相关动作。");
    }
}
// Basketballplayer继承Sportsman类
public class Basketballplayer extends Sportsman {
    //构造无参方法
    public Basketballplayer(){

    }
    //构造有参方法
    public Basketballplayer(String name,int age){
        //调用父类属性
        super(name,age);
    }
    //重写learn方法
    @Override
    public void learn() {
        System.out.println("篮球运动员学习篮球相关动作");
    }
}
//Pingpangcoach继承Coach类接入Language接口
public class Pingpangcoach extends Coach implements Language {
    //构造无参方法
    public Pingpangcoach (){

    }
    //构造有参方法
    public Pingpangcoach(String name,int age){
        super(name,age);
    }
    //重写teach方法
    @Override
    public void teach() {
        System.out.println("乒乓球教练教运动员学习乒乓球相关动作。");
    }
    //重写learnLanguage方法
    @Override
    public void learnLanguage() {
        System.out.println("乒乓球教练要学英语。");
    }
}
//定义Pingpangplayer继承Sportsman类并接入language接口
public class Pingpangplayer extends Sportsman implements Language {
    //构造无参方法
    public Pingpangplayer (){

    }
    //构造有参方法
    public Pingpangplayer(String name,int age){
        //重写父类
        super(name, age);
    }
    //重写learn方法
    @Override
    public void learn() {
        System.out.println("乒乓球运动员学习乒乓球相关动作。");
    }
    //重写learnLanguage方法
    @Override
    public void learnLanguage() {
        System.out.println("乒乓球运动员要学习英语。");
    }
}
//定义测试类
public class Test {
    public static void main(String[] args){
        //创建对象，输出信息
        Pingpangcoach coach1=new Pingpangcoach("刘国梁",50);
        System.out.println(coach1.getName()+","+coach1.getAge());
        coach1.teach();
        coach1.learnLanguage();
        Basketballcoach coach2=new Basketballcoach("姚明",39);
        System.out.println(coach2.getName()+","+coach2.getAge());
        coach2.teach();
        Pingpangplayer player1=new Pingpangplayer("王楚钦",23);
        System.out.println(player1.getName()+","+player1.getAge());
        player1.learn();
        player1.learnLanguage();
        Basketballplayer player2=new Basketballplayer("林书豪",35);
        System.out.println(player2.getName()+","+player2.getAge());
        player2.learn();
    }
}