java类设计原则的简单运用实例一

此程序无界面功能，只是设计几个类，实现了酒店的房间入住状态查询、酒店入住功能、酒店退房功能、退出系统功能。

在下面给出两份代码，都实现了上述的四个功能，并且都无界面，知识实现的过程不同，一个是面向过程的解决思想，另一个是面向对象的解决思想。

第一种解法（面向对象的解决思路）：
代码共分为五个部分，写成五个类，设计步骤大致如下：

房间类
String 房间号
boolean 状态empty
客户 入住者
void in(客户 c)
void out()
客户
姓名
酒店管理类(显示界面/显示逻辑)
酒店 酒店
printMenu()
inHandler(处理者)
outHandler()
searchHandler()
酒店类
房间[][]
房间[][] search()// 查询所有房间的信息
in(String customerName)
out(String roomNo)
测试类

Customer类（第一个类）
public class Customer {


    //下面这个变量是用来存储入住宾馆的客户姓名！
    private String name;

    /**函数作用
     * 构造函数
     * 这个构造函数写不写都无所谓，不写是因为编译器会默认提供一个无参构造函数，
     * 写了下面这种类型，作用和编译器提供的作用是一样的。
     */
    public Customer()
    {

    }


    /**函数功能
     * 定义的name私有变量的get/set方法
     */
    public void setName(String name)
    {
        this.name = name;
    }

    public String getName()
    {
        return name;
    }
}


第二个类Room类
public class Room {

    //房间号，下面构造函数完成了房价号的组合，即楼层floor加房间num.
    private String roomNo;

    //判断房间是否有人住的标识符
    private boolean empty; 

    //在Room类中，用类Customer创建一个对象customer，
    private Customer customer;

    /**
     * get/set方法
     * 通过此处可以直到，get/set方法并不是全部都需要，根据逻辑和需求来进行编写
     * @return
     */
    public String getRoomNo()
    {
        return roomNo;
    }

    public boolean isEmpty()
    {
        return empty;
    }

    public Customer getCustomer()
    {
        return customer;
    }

    /**
     * 构造函数
     * 
     * 初始化作用1:
     * 这个构造函数主要是为了在用Room创建一个宾馆的时候，宾馆的房间号格式的设置
     * 即房间号是由楼层号(floor)加这层楼层号所在的房间号码(num)
     * 
     * 初始化作用2:
     * 把一些定义的变量的初始值进行更改，
     * 在这里更改的变量是roomNo和empty变量
     * 具体这两个变量的更改在下面已有注释。
     * @param floor楼层数
     * @param num房间号码
     */
    public Room(int floor , int num)
    {

        /* * 下面这条语句是为了给roomNo赋值，因为roomNo初始值为null，所以赋予roomNo为空，这样输出的时候格式和输出内容会得到改善
         * 不使用下面这条语句打印，打印前面会有NULL+房间号+是否有人住（或人名）
         */
        roomNo = "";
        /**下面的代码用来控制房间号的形式，即楼层号加房间号
        */
        if (floor < 10)
        {
            roomNo += "0";
        }
        roomNo += floor;

        if (num < 10)
        {
            roomNo += "0";
        }
        roomNo += num;

        /**
         * boolean类型的默认值为false，在本程序中，当房间没有人住宿时
         * empty应该为true，当有人住宿时，为false，
         * 因为初始化二维数组，所有的房间在刚开始的时候都没有人住宿，所以
         * 在这里把empty赋值为true
         */
        this.empty = true;
    }


    /**函数功能
     * 用来实现当客户来入住宾馆时，要改变 房间的信息
     * 即在 Hotel类中具体实现的入住房间函数功能中，有语句传递customer到下面这个函数中
     * 去改变相应的房间的住宿人名，和这个房间的入住状态
     * 
     * 我觉得可以将这个函数称为宾馆入住函数的辅助函数，即宾馆入住辅助函数
     */
    public void in(Customer customer)
    {
        /**之所以这样写是因为对象调用这个函数，而this指针指向了这个对象
         * 所以用this指针给customer和empty赋值
         * 改变宾馆房间的入住状态和入住姓名信息
         */
        this.customer = customer;
        this.empty = false;
    }


    /**函数功能
     * 具体含义参考上面的客户住房辅助函数
     * 客户退房辅助函数
     */
    public void out()
    {
        //下面两条语句的原理参考上面的入住函数体中的语句含义。
        this.customer = null;
        this.empty = true;
    }
}


第三个类Hotel类

public class Hotel {

    //这个二位数组什么时候初始化
    //三种解决方案
    //1 声明的时候  2 构造方法new  3构造方法 参数传进来  4 set方法赋值
    //方法2是正确的
    //选用方法主要考虑显逻辑问题！是否符合显示逻辑等其它问题！
    private Room[][] rooms;

    /**函数功能
     * 构造函数
     * 
     */
    public Hotel()
    {
        //创建一个初始二维数组
        rooms = new Room[10][12];
        //开始为二维数组赋值
        for (int i = 0; i < rooms.length; i++)
        {
            for (int j = 0; j < rooms[i].length; j++)
            {
                rooms[i][j] = new Room(i+1,j+1);
            }
        }
    }


    /**函数功能
     * 查询所有房间的信息
     */
    public Room[][] search()
    {

        //下面这样返回会有问题,完成后再来看 
        return rooms;
    }

    /**函数功能
     * 具体实现入住函数功能
     */
    public void in(String customerName, String roomNo)
    {
        //首先找到房间号对应的房间
        //房间号0706——>>rooms[6][5]

        //将字符串类型的数值，转换成int类型
        //方法为parseInt()
        int roomValue = Integer.parseInt(roomNo);
        //取楼层数
        int floor = roomValue / 100 - 1;
        //取房间数
        int num = roomValue % 100 - 1;

        Room r = rooms[floor][num];
        //判断该房间是否可以入住
        if (r.isEmpty())
        {
            //如果可以，调用对应房间的in方法
            Customer customer = new Customer();
            customer.setName(customerName);
            r.in(customer);
            System.out.println("入住成功");
            //此return用来避开if语句外面的输出“入住失败!”
            return;
        }
        //联系上面的return语句
        System.out.println("入住失败");

    }

    /**
     * 具体实现退房函数功能
     */
    public void out(String roomNo)
    {
        //将字符串类型的数值，转换成int类型
        //方法为parseInt()
        int roomValue = Integer.parseInt(roomNo);
        //取楼层数
        int floor = roomValue / 100 - 1;
        //取房间数
        int num = roomValue % 100 - 1;

        Room r = rooms[floor][num];

        r.out();
        System.out.println("退房成功");
    }
}


第四个类，HotelManage

import java.util.Scanner;


public class HotelManager {

    private Hotel hotel;

    //在下面的程序中要用到，所以在这里统一定义一个
    private Scanner sc;

    public HotelManager(Hotel hotel)
    {
        this.hotel = hotel;
        this.sc = new Scanner(System.in);
    }

    public void printMenu()
    {
        while(true)
        {
            //下面的6条System.out.println();语句实现的打印宾馆管理界面的功能
            System.out.println("菜单");
            System.out.println("1、查询");
            System.out.println("2、入住");
            System.out.println("3、退房");
            System.out.println("4、退出系统");
            System.out.println("--请选择--");
            //在这个类中已经初始的定义了一个Scanner类型的变量sc，
            //下面这条语句用来在控制台上输入数据，选择执行宾馆的哪项功能。
            int choice = sc.nextInt();
            //利用switch语句实现选择，类似这种情况的选择语句，优先选择下面这种结构
            switch (choice) {
                case 1:
                    search();
                    break;
                case 2:
                    in();
                    break;
                case 3:
                    out();
                    break;
                //case 4 之所以用return;就是告诉编译器在这里，接下来什么都不干，直接返回结束程序的运行。
                case 4:
                    System.out.println("再见");
                    return;
                default:
                    break;
            }

        }
    }

    /**函数功能
     * 具体实现查询宾馆的入住情况
     */
    public void search()
    {

        Room[][] r = hotel.search();
        for (int i = 0; i < r.length; i++)
        {
            for (int j = 0; j < r[i].length; j++) 
            {
                //取出房间的号，利用 对象.方法名 的形式，其中 getRoomNo() 在Room 类中有定义，
                //即利用Room类的get方法取出房间号
                //注意在这里并没有换行，所以才能输出房间号之后，还能在一行继续输出房间的住宿者姓名
                System.out.print(r[i][j].getRoomNo()+",");
                if(r[i][j].isEmpty())
                {
                    System.out.print("空");
                    System.out.print(" ");
                    continue;
                }
                //输出房间的住宿者的姓名。
                System.out.print(r[i][j].getCustomer().getName());
            }
            System.out.println();
        }
    }

    /**函数功能
     * 入住(具体实现在Hotel)
     */
    public void in()
    {
        System.out.println("请输入入住人的姓名");
        String name =sc.next();
        System.out.println("请输入要入住的房间");
        String roomNo = sc.next();
        hotel.in(name, roomNo);
    }

    /**函数功能
     * 退房(具体实现在Hotel)
     */
    public void out()
    {
        System.out.println("请输入要退房的房间");
        String roomNo = sc.next();
        hotel.out(roomNo);
    }
}

第五个类：Test类
public class Test {

        public static void main(String[] args) {

        //Hotel homelike = new Hotel();
        //Hotel类创建一个对象sevenDays，对象名为sevenDays,即创建了一个宾馆
        Hotel sevenDays = new Hotel();
        //HotelManager类创建了一个对象mananer，对象名为manager，即创建了一个宾馆管理者
        HotelManager manager = new HotelManager(sevenDays);
        //打印宾馆管理界面的菜单
        manager.printMenu();
    }

}

第二种解法是一种面向过程的解法，推荐第一种。

import java.util.Date;
import java.util.Scanner;

public class Hotel
{
    public static String[][] rooms = new String[10][12];

    public static Scanner sc = new Scanner(System.in);

    public static void main(String[] args)
    {

        new Date("2016-12-21");

        // 初始化所有的房间
        init();
        // 系统默认是 运行状态
        boolean running = true;
        while(running)
        {
            // 打印菜单
            printMenu();
            // 用户输入选项
            int choice = sc.nextInt();
            // 对不同选项做处理
            switch (choice)
            {
                case 1:
                    // 打印房间状态
                    printRoomStatus();
                    break;
                case 2 :
                    in();
                    break;
                case 3 :
                    out();
                    break;
                case 4 :
                    System.out.println("再见");
                    running = false;
                    break;
                default:
                    System.out.println("无此功能");
                    break;
            }
        }
    }

    public static void out()
    {
        while(true)
        {
            System.out.println("请输入要退房的房间号");
            int roomNo = sc.nextInt();
            // 101  110  1001  1011
            int i = roomNo / 100 - 1;
            int j = roomNo % 100 - 1;
            // ! 代表  非  !true == false  !false == true
            if(!"空房".equals(rooms[i][j]))
            {
                // 不是空房
                rooms[i][j] = "空房";
                System.out.println("退房成功");
                break;
            }
            System.out.println("该房间是空房!请重新选择房间");
        } 
    }

    public static void in()
    {
        while(true)
        {
            System.out.println("请输入要入住的房间号");
            int roomNo = sc.nextInt();
            // 101  110  1001  1011
            int i = roomNo / 100 - 1;
            int j = roomNo % 100 - 1;
            // ! 代表  非  !true == false  !false == true
            if("空房".equals(rooms[i][j]))
            {
                // 不是空房
                System.out.println("请输入入住人的姓名");
                String name = sc.next();
                rooms[i][j] = name;
                System.out.println("入住成功");
                break;
            }
            System.out.println("该房间已经有人入住!请重新选择房间");
        }

    }



    /**
     * 打印房间状态
     * <一句话功能简述>
     * <功能详细描述>
     * @see [类、类#方法、类#成员]
     */
    public static void printRoomStatus()
    {
        //控制的楼层
        for (int i = 0; i < rooms.length; i++)
        {
            //打印的是房间号
            for (int j = 0; j < rooms[i].length; j++)
            {
                // String + 任意类型的数据 = String
                String roomNo = "";
                if(i < 9)
                {
                    roomNo = roomNo + "0" + (i+1);
                }else{
                    roomNo = roomNo + (i+1);
                }

                if(j < 9)
                {
                    roomNo = roomNo + "0" + (j+1);
                }else{
                    roomNo = roomNo + (j+1);
                }
                System.out.print(roomNo+"\t");
            }
            System.out.println();
            // 打印房间状态
            for (int j = 0; j < rooms[i].length; j++)
            {
                System.out.print(rooms[i][j]+"\t");
            }
            System.out.println();
        }
    }


    /**
     * 打印菜单
     * <一句话功能简述>
     * <功能详细描述>
     * @see [类、类#方法、类#成员]
     */
    public static void printMenu()
    {
        System.out.println("-------------菜单-------------");
        System.out.println("1--查询所有房间的状态");
        System.out.println("2--入住");
        System.out.println("3--退房");
        System.out.println("4--退出系统");
        System.out.println("------------------------------");
        System.out.println("请选择要进行的操作:");
    }

    /**
     * 初始化所有客房为  空房
     * <一句话功能简述>
     * <功能详细描述>
     * @see [类、类#方法、类#成员]
     */
    public static void init()
    {
        //循环rooms，将每个元素的值  赋值 为  空房
        for (int i = 0; i < rooms.length; i++)
        {
            for (int j = 0; j < rooms[i].length; j++)
            {
                rooms[i][j] = "空房";
            }
        }
    }
}

再这里给出第二种解法的代码编译运行结果: