public class Encapsulation_1{
    public static void main(String[] args){
    person Z=new person();
    Z.setAge(25);
System.out.println(Z.getAge());
new person().setAge(23);
Z.speak();
   }

}

class person
{
private int age;
public void setAge(int a)
{
if(a>0&&a<150)
{
age=a;
}
else
System.out.println("非法年龄");
}
public int getAge()
{
return age;
}
void speak()
{
System.out.println("年龄是"+age);
}
}
问题  class person中
void speak()
{}
前面加public与不加有没有区别？

public 只是一个权限修饰符，在继承里面用到的 还是蛮多的，但是就你这题说的话，不是你不加，前面就没有的，他有一种默认的权限，被隐式了 default ，

菠萝鱼 发表于 2014-3-26 09:16
有 不加public修饰默认是default,访问权限不一样。      
                包外         子类          包 ...

thank so much!

不在同一个包内的子类

修饰符的作用，楼上的都介绍清楚了，另外如果是在同一个文件中，写的2个类，就只能有一个类是你的主类，第二个类就不能在加public等修饰符了

菠萝鱼 发表于 2014-3-26 09:16
有 不加public修饰默认是default,访问权限不一样。      
                包外         子类          包 ...

defult权限修饰符修饰的方法可以被子类访问，都能被包中的类访问的怎么不能被子类访问，

加public 是公共访问权限，不加public是包访问权限，假如speak()前面不加public，其他包中的类就无法调用这个函数就像这样

1. package study;
   
2. 
   
3. public class mytest2 {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 // TODO Auto-generated method stub
   
7. 
   
8.         }
   
9.        
   
10.         public void show(){
    
11.                 System.out.println("public methol show");
    
12.                
    
13.         }
    
14.         void show1(){
    
15.                 System.out.println("defult methol show");
    
16.         }
    
17. 
    
18. }
    
19. 
    
20. package my1;
    
21. import study.mytest2;
    
22. public class mytest1 {
    
23. 
    
24.         public static void main(String[] args) {
    
25.                 // TODO Auto-generated method stub
    
26. mytest2 mytestobj=new mytest2();
    
27. mytestobj.show();//调用public方法没有问题
    
28. //无法调用mytestobj.show1();因为他是包访问权限，只有一个包中的类才能调用这个函数，二mytest2属于包my1不属于包study所以无法访问这个函数
    
29.         }
    
30. 
    
31. }
    
32. 
    
33. package study;
    
34. import study.mytest2;
    
35. public class mytest3 {
    
36. 
    
37.         public static void main(String[] args) {
    
38.                 // TODO Auto-generated method stub
    
39. mytest2 mytestobj=new mytest2();
    
40. mytestobj.show();//可以调用mytest用public修饰的方法
    
41. mytestobj.show1();//也可以调用无权限修饰符修饰的方法，即包访问权限方法，在其他包中这个方法是不能被访问的，就像my1包中的mytest1类就无法访问这个方法
    
42.         }
    
43. 
    
44. }
    

复制代码

public 只是一个权限修饰符，在继承里面用到的 还是蛮多的，但是就你这题说的话，不是你不加，前面就没有的，他有一种默认的权限，被隐式了 default ，如果不加的话计算机会自动给你加上的，就是这样的吧

有 不加public修饰默认是default,访问权限不一样。      
                包外         子类          包内        类内
public        yes           yes            yes         yes
protected   no           yes            yes         yes
default       no            no            yes         yes
private       no            no            no          yes