实验三： 面向对象(二)

• 实验目的

在集成开发环境下，实现类的继承及多态，实现抽象类、接口的定义，根据实际问题，运用抽象方法、接口及抽象类进行程序开发。

• 实验目标

(1)能够运用Java语言来实现类的继承及多态性、熟练使用包来扩展程序功能并能建立自己的包；

(2)能够灵活运用Java语言的抽象方法、接口、抽象类来编写应用程序解决实际问题。

• 实验内容

1 实验环境

java version "11.0.12" 2021-07-20 LTS

Java(TM) SE Runtime Environment 18.9 (build 11.0.12+8-LTS-237)

Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.12+8-LTS-237, mixed mode)

2 具体实验内容

1. 设计一个抽象类图形类，在该类中包含有至少三个抽象方法，分别用于求周长、求面积，以及对图形进行描述（如，“这是**形状，周长是**，面积是**”），分别定义圆形类、长方形类、等边三角形类来继承图形类，实现上述三个方法，并创建实例验证。
2. 定义一个抽象接口，该接口用于求和与统计数量。定义两个奇数类与偶数类实现上述接口，分别可以求100以内的奇数的和，统计100以内的奇数个数，以及求100以内的偶数的和，统计100以内的偶数个数。
3. 定义一个抽象类动物类，同时定义抽象接口：进食接口、睡觉接口、思考接口、说话接口、行走接口、游泳接口、飞翔的接口。分别定义猫类、人类、鸟类、鱼类继承动物类，同时，根据实际情况，选择性实现上述接口，并创建实例验证。
4. 编写一个类，实现银行账户，并完成程序的测试：

1. 设置的属性有“账号”、 “储户姓名”、“地址”以及“存款余额”；
2. 设置的方法有“存款”、“取款”、“查询”、“计算利息”、“累加利息”；
3. 给类增加一个静态属性“最小余额”和一个用来修改这个最小余额属性的方法；
4. 给类增加一个静态属性“活期利息”和封装这个数据的对应方法；

• 实验过程分析
  1. 实验步骤

图形抽象类，首先创建一个公共的类，其中定义所有的图形的抽象方法，再创建长方形、正方形和圆形等图形继承这个类。代码如下：

package demo;

public class Main {

    public static void main(String[] args) {

        circle circle = new circle(3.5);

        circle.describe();

        shape shape = new shape(2.2, 3.5);

        shape.describe();

        triangle triangle = new triangle(5.5);

        triangle.describe();

    }

}

class circle extends type {

    private Double r;

    public circle(Double r) {

        this.r = r;

    }

    @Override

    Double c() {

        return 2 * 3.14 * this.r;

    }

    @Override

    Double s() {

        return 3.14 * this.r * this.r;

    }

    @Override

    void describe() {

        System.out.println("这个图形是圆形,周长是" + c() + "，面积是" + s());

    }

}

class shape extends type {

    private double x;

    private double y;

    public shape(double x, double y) {

        this.x = x;

        this.y = y;

    }

    @Override

    Double c() {

        return 2 * (this.x + this.y);

    }



    @Override

    Double s() {

        return x * y;

    }

    @Override

    void describe() {

        System.out.println("这个图形是长方形,周长是" + c() + "，面积是" + s());

    }

}

class triangle extends type {

    private Double length;

    public triangle(Double length) {

        this.length = length;

    }

    @Override

    Double c() {

        return 3 * this.length;

    }

    @Override

    Double s() {

        return this.length / 2 * (double) Math.sqrt(3) / 2 * this.length;

    }

    @Override

    void describe() {

        System.out.println("这个图形是等边三角形,周长是" + c() + "，面积是" + s());

    }

}

/**

 * c代表周长，s代表面积

 */

abstract class type {

    abstract Double c();

    abstract Double s();

    abstract void describe();

}

统计和计数，定义这个类，其中包含两个方法，分别是偶数和奇数集合，再写两个类，一个数偶数类，一个奇数类，分别实现其中的一个方法，抽象类不必全部继承方法。

代码如下：

package demo;



public class Main {

    public static void main(String[] args) {

        even even = new even();

        odd odd = new odd();

        System.out.println("100以内的偶数和是"+even.sum()+",偶数个数是"+even.count());

        System.out.println("100以内的奇数和是"+odd.sum()+",奇数个数是"+odd.count());

    }

}

class even extends sumAndcount {

    @Override

    int sum() {

        int sum = 0;

        for (int i = 2; i <= 100; i += 2) {

            sum += i;

        }

        return sum;

    }

    @Override

    int count() {

        int sum = 0;

        for (int i = 2; i <= 100; i += 2) {

            sum++;

        }

        return sum;

    }

}

class odd extends sumAndcount {



    @Override

    int sum() {

        int sum = 0;

        for (int i = 1; i <= 100; i += 2) {

            sum += i;

        }

        return sum;

    }

    @Override

    int count() {

        int sum = 0;

        for (int i = 1; i <= 100; i += 2) {

            sum++;

        }

        return sum;

    }

}

abstract class sumAndcount {

    abstract int sum();



abstract int count();

      }

动物抽象方法，先创建一个公共的动物类，在里面写上抽象方法，再写几个需求的类，将这些类继承这个公共类，选择继承其中的类方法。

代码如下：

package demo;



public class Main {

    public static void main(String[] args) {

        cat cat = new cat("一号");

        people people = new people("二号");

        bird bird = new bird("三号");

        fish fish = new fish("四号");

        cat.eat();

        people.sleep();

        bird.fly();

        fish.swimming();

    }

}

class cat extends animal {

    private String name;



    public cat(String name) {

        this.name = name;

    }

    @Override

    void eat() {

        System.out.println("猫" + this.name + "正在吃饭");

    }

    @Override

    void sleep() {

        System.out.println("猫" + this.name + "正在睡觉");

    }

    @Override

    void want() {

        System.out.println("猫" + this.name + "正在思考");

    }

    @Override

    void speak() {

        System.out.println("猫" + this.name + "正在说话");

    }

    @Override

    void walk() {

        System.out.println("猫" + this.name + "正在行走");

    }

    @Override

    void swimming() {

        System.out.println("猫" + this.name + "正在游泳");

    }

    @Override

    void fly() {

    }

}

class people extends animal {

    private String name;

    public people(String name) {

        this.name = name;

    }



    @Override

    void eat() {

        System.out.println("人" + this.name + "正在吃饭");

    }

    @Override

    void sleep() {

        System.out.println("人" + this.name + "正在睡觉");

    }

    @Override

    void want() {

        System.out.println("人" + this.name + "正在思考");

    }

    @Override

    void speak() {

        System.out.println("人" + this.name + "正在说话");

    }

    @Override

    void walk() {

        System.out.println("人" + this.name + "正在行走");

    }

    @Override

    void swimming() {

        System.out.println("人" + this.name + "正在游泳");

    }

    @Override

    void fly() {

    }

}

class bird extends animal {

    private String name;

    public bird(String name) {

        this.name = name;

    }

    @Override

    void eat() {

        System.out.println("鸟" + this.name + "正在吃饭");

    }

    @Override

    void sleep() {

        System.out.println("鸟" + this.name + "正在睡觉");

    }

    @Override

    void want() {

        System.out.println("鸟" + this.name + "正在思考");

    }

    @Override

    void speak() {

        System.out.println("鸟" + this.name + "正在说话");

    }

    @Override

    void walk() {

        System.out.println("鸟" + this.name + "正在行走");

    }

    @Override

    void swimming() {

    }

    @Override

    void fly() {

        System.out.println("鸟" + this.name + "正在飞翔");

    }

}

class fish extends animal {

    private String name;

    public fish(String name) {

        this.name = name;

    }

    @Override

    void eat() {

        System.out.println("鱼" + this.name + "正在吃饭");

    }

    @Override

    void sleep() {

        System.out.println("鱼" + this.name + "正在睡觉");

    }

    @Override

    void want() {

        System.out.println("鱼" + this.name + "正在思考");

    }

    @Override

    void speak() {

        System.out.println("鱼" + this.name + "正在说话");

    }

    @Override

    void walk() {

    }

    @Override

    void swimming() {

        System.out.println("鱼" + this.name + "正在游泳");

    }

    @Override

    void fly() {

    }

}

/**

 * 进食接口、睡觉接口、思考接口、

 * 说话接口、行走接口、游泳接口、飞翔的接口

 */

abstract class animal {

    abstract void eat();

    abstract void sleep();

    abstract void want();

    abstract void speak();

    abstract void walk();

    abstract void swimming();

    abstract void fly();

}

银行存钱，创建一个银行方法，在这个方法中写上需求的几个方法。

代码如下：

package demo;

import java.util.Scanner;

import java.util.Vector;



public class Main {

    public static void main(String[] args) {

        bank bank1 = new bank("110", "龙", "四川", 1000000000000.5, 2);

        bank1.showMoney();

        bank1.saveMoney(463812.32);

        bank1.getMoney(4132.4);

        bank1.showPoint();

        bank1.showAddpoint();

        bank.smallMoney();

    }

}



/**

 * bank测试,设置的属性有“账号”、 “储户姓名”、“地址”以及“存款余额”；

 */

class bank {

    public bank(String sno, String sname, String address, Double money, int year) {

        this.sno = sno;

        this.sname = sname;

        this.address = address;

        this.money = money;

        this.year = year;

    }

    private static Integer small;

    private static Double huoMoney;

    private String sno;

    private String sname;

    private String address;

    private Double money;

    private int year;

    private static double point;

    public void saveMoney(Double money) {

        Scanner scanner = new Scanner(System.in);

        this.money = this.money + money;

        System.out.println("你要存几年: ");

        this.year = scanner.nextInt();

        System.out.println("你存入" + money + "元，账户余额" + this.money + "元");

    }



    public void getMoney(Double money) {

        if (money <= 0 || this.money < money) {

            System.out.println("你的账户余额不足");

        } else {

            this.money -= money;

            System.out.println("你取出" + money + "元，账户余额" + this.money + "元");

        }

    }



    public void showMoney() {

        System.out.println("账户余额" + this.money);

    }



    public void showPoint() {

        this.point = 0.1;

        System.out.println("你的利息为" + this.money * (this.point) * this.year);

    }



    public void showAddpoint() {

        this.point = 0.2;

        System.out.println("你的累加利息为" + this.money * (this.point + 1));

    }



    public static void smallMoney() {

        small = 10000;

        System.out.println("本银行最少存钱为:" + small);

    }



    public void setHuoMoney() {

        this.point = 0.1;

        huoMoney = this.money * point;

        System.out.println(huoMoney);

    }

}

1. 1. 错误分析

静态方法和实例方法的问题

Java中的静态方法是指被static 修饰的方法。

1、静态方法：可以直接通过类名.方法名访问。(有静态方法的类，必须声明为静态类)非静态方法：需要通过创建对象来访问方法。

2、静态方法：只可以访问静态成员(静态变量和静态方法)。非静态方法：既可以访问实例也可以访问静态。

3、静态方法和静态类是随着类的加载而加载的。并且只加载一次。

4、静态方法可以直接调用，类名调用和对象调用。（类名.方法名 / 对象名.方法名）但是非静态方法只能通过对象调用。（对象名.方法名）

• 实验总结

答：静态方法和非静态方法的总结

1.静态方法 静态方法又称类方法,是加staic关键字修饰的方法,在类定义的时候就被分配和装载入内存中。 静态方法属于类所有,类实例化前即可使用,同时不能使用super和this关键字。 静态方法只能调用静态方法以及访问静态...

2.非静态方法 非静态方法,又称为实例方法、成员方法,是不加staic关键字修饰的方法,在类定义时不菲配内存,只有在类被实例化为对象后,对象调用该方法时才被分配内存,因此非静态方法属于对象,不属于类。