使用Java实现面向对象编程

源码展示：

 1 package cdjj.s2t075.com;
 2 import java.util.Scanner;
 3 public class Door {
 4     /*
 5      * Door为门类
 6      * 它包括：开门和关门的操作
 7      * 然而，因为要通过记录Person输入的信息，交由
 8      * Computer计算机类进行处理，之后，再交由Door门类
 9      * 进行处理所以Person要继承于Computer类，Computer类又要
10      * 继承于Door类
11      */
12     private  String status=CLOSE;//定义门为关闭状态
13     public static final String CLOSE="门已打开";//定义门打开的时候
14     public static final String OPEN="门已关闭";//定义开门关闭的时候
15     private String noise;//响铃
16     public String getNoise() {
17         return noise;
18     }
19     public void setNoise(String noise) {
20         this.noise = noise;
21     }
22     public Door(){
23         /*
24          * 定义一个无参的构造函数
25          */
26     }
27     public Door(String noise){
28         /*
29          * 定义一个带参数的构造函数
30          */
31         this.noise=noise;
32     }
33     public String getStatus() {
34         return status;
35     }
36     public void setStatus(String status) {
37         this.status = status;
38     }
39     public void Do(){
40         System.out.println("这个门是一个全自动的哦...");
41     }
42 }

 1 package cdjj.s2t075.com;
 2 
 3 public class AddEmp extends Admin {
 4     /*
 5      * DeleteEmp为增加内部人员信息
 6      * 可实现增加内部人员操作
 7      * 它继承于Admin高级用户类
 8      */
 9     public void addemp() throws InterruptedException{
10         System.out.println("正在增加信息中...");
11         java.lang.Thread.sleep(5000);
12         System.out.println("此方法实现增加员工信息");
13     }
14 }

AddEmp

 1 package cdjj.s2t075.com;
 2 
 3 public class Admin {
 4     /*
 5      *Admin为高级用户，他可以实现开门的动作（无限制的）
 6      *而且，他还可以实现对内部人员的增、删、改的操作
 7      *所以，其拥有很高的权限
 8      */
 9     private String update;//修改信息操作
10     private String delete;//删除信息操作
11     private String add;//增加信息操作
12     private String adminOpen;//高级用户实现开门的操作
13     public String getUpdate() {
14         return update;
15     }
16     public void setUpdate(String update) {
17         this.update = update;
18     }
19     public String getDelete() {
20         return delete;
21     }
22     public void setDelete(String delete) {
23         this.delete = delete;
24     }
25     public String getAdd() {
26         return add;
27     }
28     public void setAdd(String add) {
29         this.add = add;
30     }
31     public String getAdminOpen() {
32         return adminOpen;
33     }
34     public void setAdminOpen(String adminOpen) {
35         this.adminOpen = adminOpen;
36     }
37     public Admin(){
38         /*
39          * 定义一个无参的构造函数
40          */
41     }
42     public Admin(String update,String delete,String add,String AdminOpen){
43         /*
44          * 定义一个带参数的构造函数
45          */
46         this.update=update;
47         this.delete=delete;
48         this.add=add;
49         this.adminOpen=AdminOpen;
50     }
51     public void Do(){
52         System.out.println("这个为高级用户，可进行特殊的操作");
53     }
54 }

Admin

 1 package cdjj.s2t075.com;
 2 
 3 public class AdminOpenDoor extends Admin {
 4     /*
 5      * AdminOpenDoor为高级用户
 6      * 可实现开门操作（无限制）
 7      * 它继承于Admin高级用户类
 8      */
 9     public void adminOpen() throws InterruptedException{
10         /*
11          * 高级用户实现开门的方法
12          */
13         System.out.println("管理员，正在开门...");
14         java.lang.Thread.sleep(5000);
15         System.out.println("此时，门已经打开...");
16     }
17 }

AdminOpenDoor

 1 package cdjj.s2t075.com;
 2 
 3 public class CloseDoor extends Door {
 4     /*
 5      * CloseDoor类为关门的操作
 6      * 它继承与Door门类
 7      */
 8     public void close() throws InterruptedException{
 9         /*
10          * 实现关门的方法
11          */
12         if(super.CLOSE.equals("门已打开")){
13             System.out.println("门的状态为...");
14             java.lang.Thread.sleep(5000);
15             System.out.println("此时门为关闭状态...");
16             super.setStatus("门已关闭");
17         }
18     }
19 
20 }

CloseDoor

 1 package cdjj.s2t075.com;
 2 import java.util.Scanner;
 3 public class Computer extends Door {
 4     /*
 5      * Computer为计算机类
 6      * 它可以实现获得数据、处理数据、返回数据、保存数据
 7      * 并且，记录历史数据信息的操作
 8      * 然而，因为要通过记录Person输入的信息，交由
 9      * Computer计算机类进行处理，之后，再交由Door门类
10      * 进行处理所以Person要继承于Computer类，Computer类又要
11      * 继承于Door类
12      */
13     public void Do(){
14         Scanner scan=new Scanner(System.in);
15         System.out.println("请选择你的操作【温馨提示：1保存信息 2删除信息 3处理信息 4获得信息】");
16         int temp1=scan.nextInt();
17         while(temp1>4 ||temp1<1){
18             if(temp1==1){
19                 SaveInfo save=new SaveInfo();
20                 save.saveInfo();
21             }
22             else if(temp1==2){
23                 DeleteEmp del=new DeleteEmp();
24                 try {
25                     del.delete();
26                 } catch (InterruptedException e) {
27                     // TODO Auto-generated catch block
28                     e.printStackTrace();
29                 }
30             }
31             else if(temp1==3){
32                 GainInfo grain=new GainInfo();
33                 grain.Gain();
34             }
35             else if(temp1==4){
36                 UpdateEmp up=new UpdateEmp();
37                 up.updateEmp();
38             }
39         }
40         System.out.println("是否退出此操作？【温馨提示：输入数字大于4或小于1即退出，否则，不成立】");
41         temp1=scan.nextInt();
42     }
43     
44     private String save;//计算机的保存信息操作
45     private String del;//计算机的删除信息操作
46     private String treat;//计算机的处理信息操作
47     private String giveInfo;//计算机的获得信息操作
48     public String getSave() {
49         return save;
50     }
51     public void setSave(String save) {
52         this.save = save;
53     }
54     public String getDel() {
55         return del;
56     }
57     public void setDel(String del) {
58         this.del = del;
59     }
60     public String getTreat() {
61         return treat;
62     }
63     public void setTreat(String treat) {
64         this.treat = treat;
65     }
66     public String getGiveInfo() {
67         return giveInfo;
68     }
69     public void setGiveInfo(String giveInfo) {
70         this.giveInfo = giveInfo;
71     }
72     public Computer(){
73         /*
74          * 定义一个无参数的构造函数
75          */
76     }
77     public Computer(String save,String del,String treat,String giveInfo){
78         /*
79          * 定义一个带参的构造函数
80          */
81         this.save=save;
82         this.del=del;
83         this.treat=treat;
84         this.giveInfo=giveInfo;
85     }
86 
87 }

Computer

 1 package cdjj.s2t075.com;
 2 
 3 public class DeleteEmp  extends Admin{
 4     /*
 5      * DeleteEmp为删除内部人员信息
 6      * 可实现删除内部人员操作
 7      * 它继承于Admin高级用户类
 8      */
 9     public void delete() throws InterruptedException{
10         System.out.println("正在删除信息中...");
11         java.lang.Thread.sleep(5000);
12         System.out.println("此方法实现删除员工信息操作");
13     }
14 }

DeleteEmp

 1 package cdjj.s2t075.com;
 2 
 3 public class DoorFinger extends Person {
 4     /*
 5      * DoorFinger类为指纹验证
 6      * 它要继承于Person人类
 7      */
 8     public void Finger() throws InterruptedException{
 9         /*
10          * 指纹验证信息
11          */
12         if(super.temp.length()==1){//指纹验证信息判断
13             System.out.println("指纹验证中，请稍后...");
14             java.lang.Thread.sleep(5000);
15             System.out.println("指纹验证通过...");
16         }
17     }
18 }

DoorFinger

 1 package cdjj.s2t075.com;
 2 
 3 public class DoorPwd extends Person {
 4     /*
 5      * DoorPwd类为录入密码
 6      * 它要继承于Person人类
 7      */
 8     public void Pwd() throws InterruptedException{
 9         /*
10          * 密码验证信息
11          */
12         if(super.temp=="123456"){//高级用户密码判断
13             System.out.println("密码中，请稍后...");
14             java.lang.Thread.sleep(5000);
15             System.out.println("密码验证已通过...");
16             
17 //        }
18 //        else if(super.temp==){//一般用户判断
19         }
20     }
21 }

DoorPwd

 1 package cdjj.s2t075.com;
 2 
 3 public class DoorRing extends Person {
 4         /*
 5          * DoorRing类为按门铃
 6          * 它要继承于Person人类
 7          */
 8     
 9     public void input() throws InterruptedException{
10         /*
11          *输入信息 
12          */
13         if(super.temp==""){//呼叫信息判断
14             System.out.println("门铃响了:叮咚，叮咚...");
15             java.lang.Thread.sleep(5000);
16             System.out.println("呼叫信息已发出...");
17         }
18     }
19 
20 }

DoorRing

  1 package cdjj.s2t075.com;
  2 import java.awt.Component;
  3 import java.util.*;
  4 import javax.swing.JOptionPane;
  5 public class DorrTest {
  6 
  7     /**
  8      * 门禁系统测试类
  9      * @param args
 10      * @throws InterruptedException 
 11      */
 12     public static void main(String[] args) throws InterruptedException {
 13         // TODO Auto-generated method stub
 14         Scanner input=new Scanner(System.in);
 15         System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * *");
 16         System.out.println("\t\t\t门禁系统");
 17         System.out.println("* * * * * * * * * * * * * * * * * * * * * * * * * * * *");
 18         System.out.println("是否想进入该系统？【温馨提示 y 想进入 n 不想进入】");
 19         String answer=input.next();
 20         while(answer.equals("y")){
 21             System.out.println("请输入你想了解某个信息【爱心提示：Person人类 Door门类 Admin高级用户类 Computer计算机类】");
 22             String answer1=input.next();
 23             if(answer1.equals("Person")){
 24                 Person person=new Person();
 25                 person.pressRing();
 26                 person.Do();
 27                 
 28                 System.out.println("是否想细致的了解：Person人类、Door门类、Admin高级用户类、Computer计算机类？【温馨提示 y 想进入 n 不想进入】");
 29                 String answer2=input.next();
 30                 while(answer2.equals("y")){
 31                     System.out.println("请选择你要了解的项：DoorRing响铃类、DoorPwd密码类、DoorFinger指纹类？");
 32                     String a1=input.next();
 33                     if(a1.equals("DoorRing")){
 34                         DoorRing doorring=new DoorRing();
 35                         doorring.Do();
 36                         doorring.pressRing();
 37                         doorring.input();
 38                     }
 39                     else if(a1.equals("DoorPwd")){
 40                         DoorPwd doorPwd=new DoorPwd();
 41                         doorPwd.Do();
 42                         doorPwd.pressRing();
 43                         doorPwd.Pwd();
 44                         
 45                     }
 46                     else if(a1.equals("DoorFinger")){
 47                         DoorFinger finger=new DoorFinger();
 48                         finger.Do();
 49                         finger.Finger();
 50                         finger.pressRing();
 51                     }
 52                 }
 53                 System.out.println("是否想退出此操作？【温馨提示 y 不想退出 n 想退出】");
 54                 answer2=input.next();//温馨提示用户
 55 
 56             }
 57             else if(answer1.equals("Door")){
 58                 Door door=new Door();
 59                 door.Do();
 60                 System.out.println("是否想细致的了解：Person人类、Door门类、Admin高级用户类、Computer计算机类？【温馨提示 y 想进入 n 不想进入】");
 61                 String answer3=input.next();
 62                 while(answer3.equals("y")){
 63                     System.out.println("请选择你要了解的项：CloseDoor关门类、OpenDoor开门类？【温馨提示：y是  n否】");
 64                     String a3=input.next();
 65                     while(a3.equals("y")){
 66                         if(a3.equals("CloseDoor")){
 67                             CloseDoor closedoor=new CloseDoor();
 68                             closedoor.Do();
 69                             closedoor.close();
 70                         }
 71                         else if(a3.equals("OpenDoor")){
 72                             OpenDoor opendoor=new OpenDoor();
 73                             opendoor.Do();
 74                             opendoor.open();
 75                         }
 76                     }
 77                     System.out.println("是否想退出此操作？【温馨提示：y是 n否】");
 78                     a3=input.next();
 79                 }
 80                 System.out.println("是否想退出此操作？【温馨提示 y 不想退出 n 想退出】");
 81                 answer3=input.next();//温馨提示用户
 82                 
 83                 
 84             }
 85             else if(answer1.equals("Computer")){
 86                 Computer computer=new Computer();
 87                 computer.Do();
 88                 System.out.println("是否想细致的了解：Person人类、Door门类、Admin高级用户类、Computer计算机类？【温馨提示 y 想进入 n 不想进入】");
 89                 String answer4=input.next();
 90                 while(answer4.equals("y")){
 91                     System.out.println("请选择你要了解的项：Person人类、Door门类、Admin高级用户类、Computer计算机类？");
 92                     String a4=input.next();
 93                     if(a4.equals("ReturnInfo")){
 94                         ReturnInfo returninfo=new ReturnInfo();
 95                         returninfo.Do();
 96                         returninfo.returnInfo();
 97                     }
 98                     else if(a4.equals("SaveInfo")){
 99                         SaveInfo save=new SaveInfo();
100                         save.Do();
101                         save.saveInfo();
102                     }
103                     else if(a4.equals("GainInfo")){
104                         GainInfo grain=new GainInfo();
105                         grain.Do();
106                         grain.Gain();
107                     }
108                 }
109                 System.out.println("是否想退出此操作？【温馨提示 y 不想退出 n 想退出】");
110                 answer4=input.next();//温馨提示用户
111                 
112             }
113             else if(answer1.equals("Admin")){
114                 Admin admin=new Admin();
115                 admin.Do();
116                 System.out.println("是否想细致的了解：Person人类、Door门类、Admin高级用户类、Computer计算机类？【温馨提示 y 想进入 n 不想进入】");
117                 String answer5=input.next();
118                 while(answer5.equals("y")){
119                     System.out.println("请选择你要了解的项：AdminOpenDoor高级管理员类、AddEmp增加内部员工类、DeleteEmp删除内部员工类、UpdateEmp更新内部员工类？");
120                     String a5=input.next();
121                     if(a5.equals("AdminOpenDoor")){
122                         AdminOpenDoor add=new AdminOpenDoor();
123                         add.Do();
124                         add.adminOpen();
125                     }
126                     else if(a5.equals("AddEmp")){
127                         AddEmp emp=new AddEmp();
128                         emp.Do();
129                         emp.addemp();
130                     }
131                     else if(a5.equals("DeleteEmp")){
132                         DeleteEmp delete=new DeleteEmp();
133                         delete.Do();
134                         delete.delete();
135                     }
136                     else if(a5.equals("UpdateEmp")){
137                         UpdateEmp update=new UpdateEmp();
138                         update.Do();
139                         update.updateEmp();
140                     }
141                 }
142                 System.out.println("是否想退出此操作？【温馨提示 y 不想退出 n 想退出】");
143                 answer5=input.next();//温馨提示用户
144                
145             }
146         }
147         System.out.println("是否想退出此系统？【温馨提示 y 不想退出 n 想退出】");
148         answer=input.next();//温馨提示用户
149         System.out.println("门禁系统结束！");
150     }
151 
152 }

DorrTest

 1 package cdjj.s2t075.com;
 2 import java.util.*;
 3 public class GainInfo extends Computer {
 4     /*
 5      * GainInfo为获得信息类
 6      * 它继承于Computer类
 7      */
 8     Scanner i=new Scanner(System.in);
 9     public void Gain(){
10         System.out.println("你是否想获得计算机的某些信息？【温馨提示：y是 n否】");
11         String n=i.next();
12         while(i.equals("y")){
13             Computer c=new Computer();
14             c.getGiveInfo();
15             c.getDel();
16         }
17         System.out.println("你是否想继续获得某些信息【温馨提示：y是  n否】");
18         String n1=i.next();
19     }
20 }

GainInfo

 1 package cdjj.s2t075.com;
 2 
 3 public class OpenDoor extends Door{
 4     /*
 5      * OpenDoor类为开门的操作
 6      * 它继承与Door门类
 7      */
 8     public void open() throws InterruptedException{
 9         /*
10          * 实现开门的方法
11          */
12         if(super.CLOSE.equals("门已关闭")){
13             super.setStatus("门已打开");
14             System.out.println("门的状态为...");
15             java.lang.Thread.sleep(5000);
16             System.out.println("此时门为打开状态...");
17         }
18     
19     }
20 }

OpenDoor

 1 package cdjj.s2t075.com;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Person extends Computer{
 6     /*
 7      * Person为人类、包括普通人：如果要进入，按门铃
 8      * 内部人员：录入密码、进行密码验证，按指纹、进行DNA验证
 9      * 因此，Person保存这次操作
10      * 然而，因为要通过记录Person输入的信息，交由
11      * Computer计算机类进行处理，之后，再交由Door门类
12      * 进行处理所以Person要继承于Computer类，Computer类又要
13      * 继承于Door类
14      */
15     Scanner scanner=new Scanner(System.in);
16     String temp=scanner.next();
17     private String name;//姓名
18     private String sex;//性别
19     private int age;//年龄
20     public String getName() {
21         return name;
22     }
23     public void setName(String name) {
24         this.name = name;
25     }
26     public String getSex() {
27         return sex;
28     }
29     public void setSex(String sex) {
30         this.sex = sex;
31     }
32     public int getAge() {
33         return age;
34     }
35     public void setAge(int age) {
36         this.age = age;
37     }
38     public void pressRing(){
39         System.out.println("我是来我叔叔家的，请开一下们好吗？");
40     }
41     public Person(){
42         /*
43          * 定义一个无参的构造函数
44          */
45     }
46     public Person(String name,String sex,int age){
47         /*
48          * 定义一个带参数的构造函数
49          */
50         this.name=name;
51         this.sex=sex;
52         this.age=age;
53     }
54 
55 }

Person

 1 package cdjj.s2t075.com;
 2 import java.util.Scanner;
 3 public class ReturnInfo extends Computer {
 4     /*
 5      * ReturnInfo为返回信息类
 6      * 它继承于Computer类
 7      */
 8     Scanner input=new Scanner(System.in);
 9     String[] ComputerInfo =new String[200];//对计算机所以信息进行操作
10     public void returnInfo(){
11         /*
12          * 返回内部人员信息方法
13          */
14         System.out.println("确认要获得此数组列表里面的信息吗？【温馨提示：y是 n否】");
15         String n=input.next();
16         while(n.equals("y")){
17             System.out.println("现在的数组元素包含："+ComputerInfo);
18             
19         }
20         System.out.println("你是否要继续访问？【温馨提示 y是 n否】");
21         String n1=input.next();
22         
23     }
24 }

ReturnInfo

 1 package cdjj.s2t075.com;
 2 import java.util.Scanner;
 3 public class SaveInfo extends Computer {
 4     /*
 5      * SaveInfo为保存信息类
 6      * 它继承于Computer类
 7      */
 8     Scanner scann=new Scanner(System.in);
 9     public void saveInfo(){
10         /*
11          * 保存内部人员信息方法
12          */
13         System.out.println("请输入你所要保存的信息");
14         String temp2=scann.next();
15         String[] ComputerInfo =new String[200];//对计算机所以信息进行操作
16         for (int i = 0; i < ComputerInfo.length; i++) {
17             ComputerInfo [i]=temp2;
18             
19         }
20         System.out.println("现在的数组元素包含："+ComputerInfo);
21         
22     }
23 }

SaveInfo

 1 package cdjj.s2t075.com;
 2 import java.util.Scanner;
 3 public class UpdateEmp extends Admin {
 4     /*
 5      * UpdateEmp为更新内部人员信息
 6      * 可实现更新内部人员操作
 7      * 它继承于Admin高级用户类
 8      */
 9     Scanner scanners=new Scanner(System.in);
10     String[] ComputerInfo =new String[200];//对计算机所以信息进行操作
11     public void updateEmp(){
12         /*
13          * 更新内部人员信息方法
14          */
15         System.out.println("请输入你要修改的信息");
16         String temp3=scanners.next();
17         for (int i = 0; i < ComputerInfo.length; i++) {
18             ComputerInfo[i]=temp3;
19         }
20         System.out.println("现在的数组元素包含："+ComputerInfo);
21     }
22 }

UpdateEmp

需求及详细介绍如下：

posted on 2017-03-19 21:10 互联网开发者阅读(815) 评论(0) 编辑收藏举报

刷新页面返回顶部

坚持:既然选择了程序员就得坚持,生活没有那么的如意,致有志成为程序员的你们. 理想:技术改变生活. 愿景:没有经济压力时,做最想做的事.

--为系统而生,为框架而死,为bug奋斗一辈子.吃符号的亏,上大小写的当,最后死在需求上.

使用Java实现面向对象编程

公告

坚持:既然选择了程序员就得坚持,生活没有那么的如意,致有志成为程序员的你们. 理想:技术改变生活. 愿景:没有经济压力时,做最想做的事.--为系统而生,为框架而死,为bug奋斗一辈子.吃符号的亏,上大小写的当,最后死在需求上.

使用Java实现面向对象编程

公告

坚持:既然选择了程序员就得坚持,生活没有那么的如意,致有志成为程序员的你们. 理想:技术改变生活. 愿景:没有经济压力时,做最想做的事.

--为系统而生,为框架而死,为bug奋斗一辈子.吃符号的亏,上大小写的当,最后死在需求上.