1. package com.itheima;
   
2. 
   
3. /*
   
4. 每个Lamp元素代表一个方向上的灯，总共有12个方向，所有总共有12个Lamp元素。
   
5. 有如下一些方向上的灯,每两个形成一组，一组灯同时变绿或变红，所以，
   
6. 程序代码只需要控制每组灯中的一个灯即可：
   
7. s2n,n2s   
   
8. s2w,n2e
   
9. e2w,w2e
   
10. e2s,w2n
    
11. s2e,n2w
    
12. e2n,w2s
    
13. 上面最后两行的灯是虚拟的，由于从南向东和从西向北、以及它们的对应方向不受红绿灯的控制，
    
14. 所以，可以假想它们总是绿灯。
    
15. */
    
16. public enum Lamp {
    
17.         //每个枚举元素各表示一个方向的控制灯
    
18.         S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
    
19.         //下面元素表示与上面的元素的相反方向的灯，它们的“相反方向灯”和“下一个灯”应忽略不计
    
20.         N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),
    
21.         //由南向东和由西向北等右拐弯的灯不受红绿灯的控制，所以，可以假想它们总是绿灯
    
22.         S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);
    
23.        
    
24.         private Lamp(String opposite,String next,boolean lighted){
    
25.                 this.opposite = opposite;
    
26.                 this.next = next;
    
27.                 this.lighted = lighted;
    
28.         }
    
29. 
    
30. 
    
31.         //当前灯是否为绿
    
32.         private boolean lighted;
    
33.         //与当前灯同时为绿的对应方向
    
34.         private String opposite;
    
35.         //当前灯变红时下一个变绿的灯
    
36.         private String next;
    
37.         public boolean isLighted(){
    
38.                 return lighted;
    
39.         }
    
40.        
    
41.         //某个灯变绿时，它对应方向的灯也要变绿
    
42.         public void light(){
    
43.                 this.lighted = true;
    
44.                 if(opposite != null){
    
45.                         Lamp.valueOf(opposite).light();
    
46.                 }
    
47.                 System.out.println(name() + " lamp is green，下面总共应该有6个方向能看到汽车穿过！");
    
48.                
    
49.         }
    
50.         //某个灯变红时，对应方向的灯也要变红，并且下一个方向的灯要变绿
    
51.         //@return 下一个要变绿的灯       
    
52.         public Lamp blackOut(){
    
53.                 this.lighted = false;
    
54.                 if(opposite != null){
    
55.                         Lamp.valueOf(opposite).blackOut();
    
56.                 }               
    
57.                
    
58.                 Lamp nextLamp= null;
    
59.                 if(next != null){
    
60.                         nextLamp = Lamp.valueOf(next);
    
61.                         System.out.println("绿灯从" + name() + "-------->切换为" + next);                       
    
62.                         nextLamp.light();
    
63.                 }
    
64.                 return nextLamp;
    
65.         }
    
66. }

复制代码

比如说这个代码里有很多private，而我却不知道该什么情况下用private修饰？修饰与不修饰的区别又在哪里？关键就是在什么情况下使用它还有就是它可以修饰些什么？我看了看好像是可以修饰方法和变量，那会不会又分什么成员与局部之说？

在不想让其他类直接使用该类的成员和方法时就使用private，使用private后，可以给成员变量添加get set方法，暴露出这个成员变量的修改权限，如果不想让其他类修改就可以不暴露，这样能保证程序的完整性，安全性！同样在方法前加private一样，不允许别人直接访问该方法，而是由自己决定是否暴露出这个方法。

private私有
对属性和方法修饰，封装，下定义，自己内部类调用，继承的类也只能通过调用它的函数对它进行传值

只能本类调用的时候用private。

q527198615 发表于 2014-3-3 16:14
在不想让其他类直接使用该类的成员和方法时就使用private，使用private后，可以给成员变量添加get set方法 ...

那其他类该如何访问该类的私有方法或变量呢？

我叫MT 发表于 2014-3-3 17:52
那其他类该如何访问该类的私有方法或变量呢？

你就暴露出来就是了，比如说私有的成员变量，你可以给他设置set，get方法，其他类就能访问了

private是成员与方法的修饰符，将成员与方法私有化，这时候使用表示你不想让别人使用你定义的类中的成员和方法，保证了有些数据和方法的安全，如果需要在别的类中使用，则可以使用set和get方法，将这两个方法都设置为public属性，这样就可以访问了，既保证安全，又增加设计的灵活性！

private :私有，权限修饰符：用于修饰类中的成员(成员变量，成员函数)。
私有只在本类中有效,可以调用它本类中的方法对它进行赋值；
附：可参考毕老师第五天视频面向对象（private 封装）

private关键字是变量和方法的访问权限控制符，用private修饰的变量和方法称为私有变量和私有方法。在类a中定义私有变量和私有方法后，在另一个类b创建对象不能通过创建a类对象访问a类的成员变量和方法。

常见的private修饰 '方法' 和 '成员'：
当你定义成员的时候，应该更倾向于将成员的访问权限设置为private的访问权限。
主要的思路在于，面向对象的设计，是希望任何类都有封装性的。
里面的构件，不应对外可见。
外部对对象中成员进行修改的时候，应该通过专门的get/set方法去修改。这样，我们在get/set方法中，可以增加校验机制，增强类本身数据成员的安全性。

当你定义方法的时候，如果发现这个方法是你类中的某一个行为过程，外部没有必要知道，则定义为private权限。
如果发现方法是要暴露给外部去操作对象的，则设置为public。

下面有个例子：

1. 
   
2. /**
   
3. * 定义一个汽车类
   
4. * @author CBY
   
5. *
   
6. */
   
7. public class Car {
   
8.         public Car(int wheel) {
   
9.                 this.setWheel(wheel);
   
10.         }
    
11. 
    
12.         //表示轮子的个数
    
13.         private int wheel;
    
14. 
    
15.         /**
    
16.          * 获取轮子的个数
    
17.          * @return
    
18.          */
    
19.         public int getWheel() {
    
20.                 return wheel;
    
21.         }
    
22. 
    
23.         public void setWheel(int wheel) {
    
24.                 //如果让创建出来车的对象：
    
25.                 //轮子个数小于4个或者是单数
    
26.                 //肯定不合适
    
27.                 //所以将wheel成员设成private在此加上入参校验，是必须的
    
28.                 if(wheel>=4 && wheel%2==0)
    
29.                         this.wheel = wheel;
    
30.                 else
    
31.                         throw new RuntimeException();
    
32.         }
    
33. }

复制代码

至于protected权限，主要用于将成员、方法暴露给其子类。