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

痛定思痛。 2024-04-01 18:38 56阅读 0赞

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

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

## 题目 ##

![在这里插入图片描述][1cecaf41f3564490a5ff64b34de365f0.png]

## 业务逻辑分析 ##

首先是分析，`宠物店，动物，小猫小狗，客户`之间的关系，其中最为明显的就是，小猫小狗与动物之间的关系，很显然小猫小狗继承动物的属性，他们之间属于`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");
    
        }
    }

[1cecaf41f3564490a5ff64b34de365f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/20c53eaaf0f946bcaef17ebe72dec9a6.png