下面是我今天复习的一段代码 ，对修饰符什么时候使用不是很明确，代码里有两个问题！另外各位大神们如果能总结一下各修饰符什么时候用，就感激涕零了

1. /*
   
2. 创建线程的方式之一
   
3. 1，定义一个继承thread类的子类
   
4. 2，覆盖thread的run()方法
   
5. 3，直接thread的子类对象来创建线程
   
6. 4，调用对象的start功能开启线程，并启动run()方法
   
7. */
   
8. 
   
9. class Demo extends Thread
   
10. {
    
11.        
    
12.         private String name;//为什么一定要私有name 不私有就会报错 不用private修饰是在整个类中有效 有什么不可以的呢？
    
13.        
    
14.         Demo(String name)
    
15.         {
    
16.                 super(name);
    
17.        
    
18.         }
    
19.        
    
20.        
    
21.         public void run()//为什么要用公共的public修饰？是因为他是子类，只有权限比父类大，才能覆盖父类的run方法，是这样理解吗？
    
22.         {
    
23.                
    
24.                 for (int x=1;x<10 ;x++ )
    
25.                 {
    
26.                
    
27.                         System.out.println("name="+name+x+Thread.currentThread().getName());
    
28.                 }
    
29.         }
    
30. 
    
31. }
    
32. 
    
33. 
    
34. class ThreadDemo
    
35. {
    
36.         public static void main(String[] args)
    
37.         {
    
38.         Demo T = new Demo("安卓");
    
39.         Demo T2 = new Demo("苹果");
    
40.         Demo T3 = new Demo("微软");
    
41. 
    
42.         T.start();
    
43.         T2.start();
    
44.         T3.start();
    
45.        
    
46.         System.out.print("塞班");
    
47.         }
    
48. }

复制代码

搞清楚访问控制修饰符的访问范围就行了。
第一个问题好像不存在吧，用public应该可以啊。
第二个的话，Demo类中的run()方法覆盖了Thread类中的run()方法，覆盖有一个条件是不能缩小被覆盖方法的访问权限，Thread类中的run()方法是public类型的，所以Demo类中的run()方法只能是public

private首先明白这是一个成员修饰符，所以可以修饰的有成员变量，成员方法。所以对于不必要暴露出去的成员变量加以修饰；对于成员函数当然就是不允取被其他类创造的对象调用。
public 这个一修饰，当然就权限了，在包这里体现得很明显，不同包之间的调用。权限不够大是不能被调用的 。

第一次回答问题，不足之处，海涵了。
对于问题一：按照你的代码编译运行不存在你说的问题啊，private是一个成员修饰符，对于类似于姓名、年龄等这类成员变量没有对外暴露的必要，就private修饰一下。
对于问题二：public是必须的。将public去掉后编译结果是： ，从结果中可以看出，在复写父类中的方法时，是不能缩小父类访问权限的，而父类Thread中的run()方法是public的。

一、java修饰符分为访问控制符和非访问控制符
（一）访问控制符  :public、protected、default、private；不加其他三个控制符则默认为default
            包外   子类     包内    类内  使用对象
public      可     可       可      可    类、接口、构造器、成员（全局变量、方法）
protected   否     可       可      可    构造器、成员（全局变量、方法）
default     否     否       可      可    类、接口、构造器、成员（全局变量、方法）
private     否     否       否      可    构造器、成员（全局变量、方法）
（二）非访问控制符:final、abstract、static、transient、volatile、native、synchronized、strictfp
1、final         ：最终修饰符；使用对象为类、成员（全局变量、方法)、局部变量
2、abstract      ：抽象修饰符；使用对象为类、接口、方法
3、static        ：静态修饰符；使用对象为类、成员（全局变量、方法)
4、native        ：本地修饰符；使用对象为方法
5、synchronized  ：同步修饰符；使用对象为方法
6、transient     ：暂时性修饰符；使用对象为方法
7、strictfp      ：精确浮点修饰符；使用对象为类、接口、方法
8、volatile      ：易失(共享)修饰符；使用对象为全局变量
二、换个角度看修饰符
（一）类修饰符      ：public、default、abstract、final、strictfp
（二）接口修饰符    ：public、default、abstract、strictfp
（三）构造器修饰符  ：public、protected、default、private
（四）全局变量修饰符：public、protected、default、private、static、transient、volatile、final
（五）方法修饰符    : public、protected、default、private、abstract、static、final、native、synchronized、strictfp
（六）内部类        ：public、protected、default、private、static、abstract、final
（七）局部变量修饰符：final



不可将Java 简单想象成一系列特性的集合；如孤立地看，有些特性是没有任何意义的。只有在考虑“设计”、而非考虑简单的编码时，才可真正体会到Java的强大。



面向对象编程（OOP）具有多方面的吸引力。对管理人员，它实现了更快和更廉价的开发与维护过程。对分析与设计人员，建模处理变得更加简单，能生成清晰、易于维护的设计方案。对程序员，对象模型显得如此高雅和浅显。此外，面向对象工具以及库的巨大威力使编程成为一项更使人愉悦的任务。每个人都可从中获采用形象思维，而不是程序化的思维。



解决问题的复杂程度直接取决于抽象的种类及质量。这儿的“种类”是指准备对什么进行“抽象”？汇编语言是对基础机器的少量抽象。后来的许多“命令式”语言（如FORTRAN，BASIC 和C）是对汇编语言的一种抽象。与汇编语言相比，这些语言已有了长足的进步，但它们的抽象原理依然要求我们着重考虑计算机的结构，而非考虑问题本身的结构。在机器模型（位于“方案空间”）与实际解决的问题模型（位于“问题空间”）之间，程序员必须建立起一种联系。

那个private是可以去掉的，之所以加上是为了不让别的类调用，加了private后本类还是可以调用的，至于那个public必须得加，原因如你所说，子类继承父类时，如果要复写父类的方法则子类方法的权限不得低于父类（可以相同，但父类的方法不能用private修饰否则无法复写），具体几个权限修饰符的权限大小和用法可参看楼上。