AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

通过宠物商店理解java面向对象

2023-01-04 157
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 本篇博客，适合刚刚学完java基础语法的但是，对于面向对象，理解不够深刻的读者，本文通过经典的宠物商店，来让读者深刻的理解，面向对象，IS-A，HAS-A法则。本文不仅仅是简单的用java来模拟一个宠物商店，而是通过分析宠物商店的业务，来让大家理解，最简单的业务逻辑，即商店，商品，用户，这三者的逻辑，这个代码同样可以适用于，图书管理系统，书店管理系统，宿舍管理系统等等的入门理解。好了本文开始了。首先我们先把题目给出来。

前言：本篇博客，适合刚刚学完java基础语法的但是，对于面向对象，理解不够深刻的读者，本文通过经典的宠物商店，来让读者深刻的理解，面向对象，IS-A，HAS-A法则。本文不仅仅是简单的用java来模拟一个宠物商店，而是通过分析宠物商店的业务，来让大家理解，最简单的业务逻辑，即商店，商品，用户，这三者的逻辑，这个代码同样可以适用于，图书管理系统，书店管理系统，宿舍管理系统等等的入门理解。

好了本文开始了。首先我们先把题目给出来。

题目

在这里插入图片描述

业务逻辑分析

首先是分析，宠物店，动物，小猫小狗，客户之间的关系，其中最为明显的就是，小猫小狗与动物之间的关系，很显然小猫小狗继承动物的属性，他们之间属于IS-A，什么是IS-A法则，就是这种继承关系，所以，我们可以构建Animal类，思考所有动物的公共属性，比如我这里写的这个Animal类中的姓名，价格，性别，颜色，年龄这些成员，因为是举例子，所以很多地方并不会写的很全，然后再分析行为，我这里设计的他们的共有行为便是，Shout()，大叫属性。

当Animal这个基类成功之后，那么后续就是，设计猫类，狗类了，对于这两个类的话，为了方便理解，我们设置他们的新的成员是，对于猫来说为CatPara，对于狗来说的话是DogPara，然后他们会重写父类的Shout()方法，这里就体现了面向对象里面的多态，具体代码如下。

动物类的编写

代码如下：

/*
* 讲解面向对象的三个基本特性
* IS-A法则
* HAS-A法则
* */

// 动物类
class Animal{
    private String name;  // 姓名
    private Double price; // 价格
    private Boolean sex; // 性别
    private String color; // 颜色 
    private Integer age; // 年龄

    public Animal() {
    }

    public void Shout(){ // 大叫
        System.out.println("大声的叫");
    }

    public String getName() {
        return name;
    }

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

    public Double getPrice() {
        return price;
    }

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

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public String getColor() {
        return color;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() { // 重写toString()方法 方便遍历类
        return "Animal{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", sex=" + sex +
                ", color='" + color + '\'' +
                ", age=" + age +
                '}';
    }
}

// 狗类
class Dog extends Animal{ // Dog is a animal // 继承父类属性 这里体现了继承
    private Integer DogPara; // 狗参数

    public Integer getDogPara() {
        return DogPara;
    }

    public void setDogPara(Integer dogPara) {
        DogPara = dogPara;
    }

    public void WagTail(){ // 对于小狗添加了一个新的摇尾巴的方法
        System.out.println("摇尾巴");
    }
    public Dog() {
    }
    @Override
    public void Shout(){   // 重写父类的方法 这里体现了多态
        System.out.println("汪汪汪");
    }

    @Override
    public String toString() {
        return "Dog{" +
                "DogPara=" + DogPara + " " + super.toString() +
                '}';
    }
}

// 猫类
class Cat extends Animal{
    private Integer CatPara; // 猫参数

    public Integer getCatPara() {
        return CatPara;
    }

    public void setCatPara(Integer catPara) {
        CatPara = catPara;
    }

    public void LickHair(){   // 对于小猫 添加一个舔毛的方法
        System.out.println("舔毛");
    }
    public Cat() {
    }
    @Override
    public void Shout(){ // 重写父类属性
        System.out.println("喵喵喵");
    }

    @Override
    public String toString() {  // 重写toString()方法 方便遍历类
        return "Cat{" +            // super()调用父类的toString()方法 可以简写很多。
                "CatPara=" + CatPara + " " + super.toString() +
                '}';
    }
}

宠物店类的编写

对于宠物店类，和宠物的关系，这里属于的是HAS-A法则，HAS-A法则什么意思了，比如，汽车与轮胎之间的关系，轮胎属于汽车，在这个例题中的情况就是，宠物属于宠物店，这就是HAS-A法则。

/*
* Has-A法则
*
* */
// 宠物店类
class PetShop{
    // 这里体现了HAS-A法则 宠物店包含小猫，小狗这些宠物
    private ArrayList<Dog> dogs;  // 宠物店的小狗的集合
    private ArrayList<Cat> cats;  // 宠物店中小猫的集合

    public PetShop() {  // 构造方法中加上代码 随机的生成初始数据
        Random random = new Random();
        dogs = new ArrayList<>();
        cats = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
               Dog dog = new Dog();
               Cat cat = new Cat();
               dog.setName("dog" + i);
               cat.setName("cat" + i);
               dog.setPrice(random.nextDouble() * 400 + 100); // [0,1) * 400 = [0, 400) + 100 = [100, 500)
               cat.setPrice(random.nextDouble() * 400 + 100); // [0,1) * 400 = [0, 400) + 100 = [100, 500)
               dog.setSex(random.nextBoolean());
               cat.setSex(random.nextBoolean());

               dog.setDogPara(random.nextInt(1000));
               cat.setCatPara(random.nextInt(1000));

               dog.setColor(random.nextInt(1000) + ":" + random.nextInt(1000) + ":" + random.nextInt(1000));
               cat.setColor(random.nextInt(1000) + ":" + random.nextInt(1000) + ":" + random.nextInt(1000));

               dog.setAge(random.nextInt(10));
               cat.setAge(random.nextInt(10));

               dogs.add(dog);
               cats.add(cat);
        }
    }



    public void Traversal(){  // 遍历现有数据
        for (int i = 0; i < dogs.size(); i++) {
            System.out.println(dogs.get(i));
        }
        System.out.println("----------------------------------");
        Iterator<Cat> iterator2 = cats.iterator();
        while(iterator2.hasNext())
        {
            System.out.println(iterator2.next());
        }
    }

    public int getNumDog(){
        return dogs.size();
    }
    public int getNumCat(){
        return cats.size();
    }

    public ArrayList<Dog> getDogs() {
        return dogs;
    }

    public void setDogs(ArrayList<Dog> dogs) {
        this.dogs = dogs;
    }

    public ArrayList<Cat> getCats() {
        return cats;
    }

    public void setCats(ArrayList<Cat> cats) {
        this.cats = cats;
    }
}

客户类的编写

这时候我们就需要分析最后一种关系，客户与宠物店之间的关系，它们之间的关系，是两个单独的个体，至于怎么联合起来，通过客户类中的Buy(PetShop petShop)行为就可以理解了。


class Custom{
    private Boolean sex;
    private Integer age;

    private String name;

    private ArrayList<Dog> dogs;
    private ArrayList<Cat> cats;

    public Custom() {
    }

    public Custom(String name) {
        this.name = name;
    }

    public boolean Buy(PetShop petShop){ // 这是客户在宠物店中购买商品的情况 
    // 因为这是一个讲解面向对象的，所以这里作者就先不补全了，示意即可
        Scanner in = new Scanner(System.in);
        System.out.println("Y/N"); // 小狗就是Y 小猫就是N
        String flag = in.nextLine().toLowerCase();
        if (flag.equals("y")){

        }
        else {

        }
        return false;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

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

    public ArrayList<Dog> getDogs() {
        return dogs;
    }

    public void setDogs(ArrayList<Dog> dogs) {
        this.dogs = dogs;
    }

    public ArrayList<Cat> getCats() {
        return cats;
    }

    public void setCats(ArrayList<Cat> cats) {
        this.cats = cats;
    }
}

代码汇总

通过该文章的这个例题的简介，基本上就讲解完了，面向对象的基础和IS-A,HAS-A法则。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Random;
import java.util.Scanner;

/*
* 讲解面向对象的三个基本特性
* IS-A法则
* HAS-A法则
* */
class Animal{
    private String name;  // 姓名
    private Double price; // 价格
    private Boolean sex; // 性别
    private String color; // 颜色 
    private Integer age; // 年龄

    public Animal() {
    }

    public void Shout(){ // 大叫
        System.out.println("大声的叫");
    }

    public String getName() {
        return name;
    }

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

    public Double getPrice() {
        return price;
    }

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

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public String getColor() {
        return color;
    }

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

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", price=" + price +
                ", sex=" + sex +
                ", color='" + color + '\'' +
                ", age=" + age +
                '}';
    }
}

class Dog extends Animal{ // Dog is a animal
    private Integer DogPara;

    public Integer getDogPara() {
        return DogPara;
    }

    public void setDogPara(Integer dogPara) {
        DogPara = dogPara;
    }

    public void WagTail(){
        System.out.println("摇尾巴");
    }
    public Dog() {
    }
    @Override
    public void Shout(){
        System.out.println("汪汪汪");
    }

    @Override
    public String toString() {
        return "Dog{" +
                "DogPara=" + DogPara + " " + super.toString() +
                '}';
    }
}

class Cat extends Animal{
    private Integer CatPara;

    public Integer getCatPara() {
        return CatPara;
    }

    public void setCatPara(Integer catPara) {
        CatPara = catPara;
    }

    public void LickHair(){
        System.out.println("舔毛");
    }
    public Cat() {
    }
    @Override
    public void Shout(){
        System.out.println("喵喵喵");
    }

    @Override
    public String toString() {
        return "Cat{" +
                "CatPara=" + CatPara + " " + super.toString() +
                '}';
    }
}

/*
* Has-A法则
*
* */

class PetShop{
    private ArrayList<Dog> dogs;
    private ArrayList<Cat> cats;

    public PetShop() {
        Random random = new Random();
        dogs = new ArrayList<>();
        cats = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
               Dog dog = new Dog();
               Cat cat = new Cat();
               dog.setName("dog" + i);
               cat.setName("cat" + i);
               dog.setPrice(random.nextDouble() * 400 + 100); // [0,1) * 400 = [0, 400) + 100 = [100, 500)
               cat.setPrice(random.nextDouble() * 400 + 100); // [0,1) * 400 = [0, 400) + 100 = [100, 500)
               dog.setSex(random.nextBoolean());
               cat.setSex(random.nextBoolean());

               dog.setDogPara(random.nextInt(1000));
               cat.setCatPara(random.nextInt(1000));

               dog.setColor(random.nextInt(1000) + ":" + random.nextInt(1000) + ":" + random.nextInt(1000));
               cat.setColor(random.nextInt(1000) + ":" + random.nextInt(1000) + ":" + random.nextInt(1000));

               dog.setAge(random.nextInt(10));
               cat.setAge(random.nextInt(10));

               dogs.add(dog);
               cats.add(cat);
        }
    }



    public void Traversal(){
        for (int i = 0; i < dogs.size(); i++) {
            System.out.println(dogs.get(i));
        }
        System.out.println("----------------------------------");
        Iterator<Cat> iterator2 = cats.iterator();
        while(iterator2.hasNext())
        {
            System.out.println(iterator2.next());
        }
    }

    public int getNumDog(){
        return dogs.size();
    }
    public int getNumCat(){
        return cats.size();
    }

    public ArrayList<Dog> getDogs() {
        return dogs;
    }

    public void setDogs(ArrayList<Dog> dogs) {
        this.dogs = dogs;
    }

    public ArrayList<Cat> getCats() {
        return cats;
    }

    public void setCats(ArrayList<Cat> cats) {
        this.cats = cats;
    }
}

class Custom{
    private Boolean sex;
    private Integer age;

    private String name;

    private ArrayList<Dog> dogs;
    private ArrayList<Cat> cats;

    public Custom() {
    }

    public Custom(String name) {
        this.name = name;
    }

    public boolean Buy(PetShop petShop){
        Scanner in = new Scanner(System.in);
        System.out.println("Y/N"); // 小狗就是Y 小猫就是N
        String flag = in.nextLine().toLowerCase();
        if (flag.equals("y")){

        }
        else {

        }
        return false;
    }

    public Boolean getSex() {
        return sex;
    }

    public void setSex(Boolean sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

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

    public ArrayList<Dog> getDogs() {
        return dogs;
    }

    public void setDogs(ArrayList<Dog> dogs) {
        this.dogs = dogs;
    }

    public ArrayList<Cat> getCats() {
        return cats;
    }

    public void setCats(ArrayList<Cat> cats) {
        this.cats = cats;
    }
}

public class Main {


    public static void main(String[] args) {
        PetShop petShop = new PetShop(); // 创建一个宠物店
//        petShop.Traversal();
        Custom custom = new Custom("LiHua");

    }
}
文章标签：
Java
关键词：
Java面向对象
宠物Java
极客李华
目录
相关文章
刘大猫.
|
8天前
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
刘大猫.
14 1
雨溪-yuxi
|
21天前
|
JavaScript 前端开发 Java
还不明白面向对象？ 本文带你彻底搞懂面向对象的三大特征（2024年11月Java版）
欢迎来到我的博客，我是瑞雨溪，一名热爱JavaScript和Vue的大一学生。如果你从我的文章中受益，欢迎关注我，我将持续更新更多优质内容。你的支持是我前进的动力！🎉🎉🎉
雨溪-yuxi
21 0
还不明白面向对象？ 本文带你彻底搞懂面向对象的三大特征（2024年11月Java版）
土木林森
|
1月前
|
Java 关系型数据库 数据库
面向对象设计原则在Java中的实现与案例分析
【10月更文挑战第25天】本文通过Java语言的具体实现和案例分析，详细介绍了面向对象设计的五大核心原则：单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则帮助开发者构建更加灵活、可维护和可扩展的系统，不仅适用于Java，也适用于其他面向对象编程语言。
土木林森
26 2
杀死一只知更鸟debug
|
3月前
|
Java 编译器
封装，继承，多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性：封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态，继承允许新类扩展现有类的功能，而多态则允许对象在不同情况下表现出不同的行为，这些特性共同提高了代码的复用性、扩展性和灵活性。
杀死一只知更鸟debug
46 2
封装，继承，多态【Java面向对象知识回顾①】
刘大猫.
|
3月前
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
刘大猫.
35 4
杀死一只知更鸟debug
|
3月前
|
Java
接口和抽象类【Java面向对象知识回顾②】
本文讨论了Java中抽象类和接口的概念与区别。抽象类是不能被实例化的类，可以包含抽象和非抽象方法，常用作其他类的基类。接口是一种纯抽象类型，只包含抽象方法和常量，不能被实例化，且实现接口的类必须实现接口中定义的所有方法。文章还比较了抽象类和接口在实现方式、方法类型、成员变量、构造方法和访问修饰符等方面的不同，并探讨了它们的使用场景。
杀死一只知更鸟debug
29 0
接口和抽象类【Java面向对象知识回顾②】
Codelinghu
|
2月前
|
存储 Java 程序员
Java基础-面向对象
Java基础-面向对象
Codelinghu
18 0
热爱技术的小郑
|
4月前
|
Java 数据处理 开发者
【Java基础面试十二】、说一说你对面向对象的理解
这篇文章阐述了面向对象是一种以类和对象为基础，通过封装、继承和多态等概念来模拟现实世界中的事物及其相互关系的程序设计方法，它强调以事物为中心进行思考和系统构造，与结构化程序设计相比，更符合人类的自然思维方式。
热爱技术的小郑
42 2
【Java基础面试十二】、说一说你对面向对象的理解
源码星辰
|
3月前
|
安全 Java Go
面向对象程序设计语言：Java
Java语言语法和C语言和C++语言很接近，很容易学习和使用，Java丢弃了C++中很少使用的、很难理解的、令人迷惑的特性，Java语言不使用指针，而是引用，并提供了自动分配和回收内存空间，使得程序员不必为内存管理而担忧
源码星辰
65 2
热爱技术的小郑
|
4月前
|
Java
【Java基础面试十三】、面向对象的三大特征是什么？
这篇文章介绍了面向对象程序设计的三大基本特征：封装、继承和多态，其中封装隐藏对象实现细节，继承实现软件复用，多态允许子类对象表现出不同的行为特征。
热爱技术的小郑
52 1
【Java基础面试十三】、面向对象的三大特征是什么？

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    阿里巴巴Java开发规约-插件使用[Idea和Eclipse]
  • 3
    关于Java面向对象的分析题
  • 4
    代码行数减少 30-90%！多邻国从Java迁移到Kotlin的奇妙体验
  • 5
    漫谈 Java 实例化类
  • 6
    《连载 | 物联网框架ServerSuperIO教程》1.4种通讯模式机制。附小文：招.NET开发，结果他转JAVA了，一切都是为了生活
  • 7
    java-subString方法易导致内存溢出
  • 8
    Java-学习笔记-8-接口
  • 9
    【Java学习笔记】TCP客户端/服务器端
  • 10
    Java程序内存分析：使用mat工具分析内存占用
  • 1
    深入理解Java并发编程：线程池的应用与优化
    38
  • 2
    理解Java中的多线程编程
    51
  • 3
    采用java+springboot+vue.js+uniapp开发的一整套云MES系统源码 MES制造管理系统源码
    104
  • 4
    【JAVA】分布式链路追踪技术概论
    102
  • 5
    Java进阶-Java Stream API详解与使用
    60
  • 6
    【Java】实现一个简单的线程池
    33
  • 7
    深入理解Java并发编程：线程安全与性能优化
    26
  • 8
    Java中的多线程编程：理解与实践
    49
  • 9
    Java中的线程同步与并发控制
    52
  • 10
    Java LinkedList
    49

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云对象存储OSS收费标准：存储、流量和请求等多个计费项详解