java访问包里私有_在java中包私有类的公共方法,其它包的类能访问吗

展开全部

我知道你不想看测试的，所以直接给答案：

包私有类，其它包的类是e69da5e6ba903231313335323631343130323136353331333335303561不能访问的 ，那如果包私有类中的方法是Public呢 其它包的类还能访问这个方法吗

你说的私有类只可能是内部类，因为外部类是只有包或者公开访问权限的，

那如果包私有类中的方法是Public呢 其它包的类还能访问这个方法吗

我假设你提问的是内部类，不可以，因为它连这个类都访问不了,可以这样理解，一个私有内部类中的方法访问权限也肯定是private，不然的话，别人就可以访问了

测试一下内部类的情况：package Lianxi.yong;

public class Test{

private class privateTest3{//内部类是可以声明为私有的

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

protected class ProtectedTest3{//内部类是可以声明为保护的

public ProtectedTest3(){}//要想要子类访问，这里必须把构造方法设置为public

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

class DefaultTest3{//内部类是可以声明为默认的

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

public class PublicTest3{//内部类是可以声明为公开的

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

public static void main(String[] args) {

(new Test()).new privateTest3().publciTest();//这个私有类这里可以访问,公有方法可以访问

(new Test()).new privateTest3().privateTest();//这个私有类这里可以访问,私有方法可以访问

(new Test()).new privateTest3().protectedTest();//这个私有类这里可以访问,保护方法可以访问

(new Test()).new privateTest3().defaultTest();//这个私有类这里可以访问,默认访问权限方法可以访问

(new Test()).new ProtectedTest3().publciTest();//这个保护类这里可以访问,公有方法可以访问

(new Test()).new ProtectedTest3().privateTest();//这个保护类这里可以访问,私有方法可以访问

(new Test()).new ProtectedTest3().protectedTest();//这个保护类这里可以访问,保护方法可以访问

(new Test()).new ProtectedTest3().defaultTest();//这个保护类这里可以访问,默认访问权限方法可以访问

(new Test()).new DefaultTest3().publciTest();//这个默认访问权限类这里可以访问,公有方法可以访问

(new Test()).new DefaultTest3().privateTest();//这个默认访问权限类这里可以访问,私有方法可以访问

(new Test()).new DefaultTest3().protectedTest();//这个默认访问权限类这里可以访问,保护方法可以访问

(new Test()).new DefaultTest3().defaultTest();//这个默认访问权限类这里可以访问,默认访问权限方法可以访问

(new Test()).new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

(new Test()).new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法可以访问

(new Test()).new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法可以访问

(new Test()).new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法可以访问

}

}

//private class Test2{//根本就无法声明私有类

//

//}

测试不同包的情况：package Lianxi.yong2;

import Lianxi.yong.Test;

public class Test2 {

public void test(){

(new Test()).new privateTest3().publciTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().privateTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().protectedTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().defaultTest();//这个私有类这里不可以访问

(new Test()).new ProtectedTest3().publciTest();//这个保护类这里不可以访问

(new Test()).new ProtectedTest3().privateTest();//这个保护类这里不可以访问

(new Test()).new ProtectedTest3().protectedTest();//这个保护类这里不可以访问

(new Test()).new ProtectedTest3().defaultTest();//这个保护类这里不可以访问

(new Test()).new DefaultTest3().publciTest();//这个默认访问权限类这里不可以访问

(new Test()).new DefaultTest3().privateTest();//这个默认访问权限类这里不可以访问

(new Test()).new DefaultTest3().protectedTest();//这个默认访问权限类这里不可以访问

(new Test()).new DefaultTest3().defaultTest();//这个默认访问权限类这里不可以访问

(new Test()).new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

(new Test()).new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法不可以访问

(new Test()).new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法不可以访问

(new Test()).new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法不可以访问

}

}

测试相同包的情况：package Lianxi.yong;

import Lianxi.yong.Test.DefaultTest3;

import Lianxi.yong.Test.ProtectedTest3;

import Lianxi.yong.Test.PublicTest3;

import Lianxi.yong.Test.privateTest3;

public class SamePackageTest {

public static void main(String[] args) {

(new Test()).new privateTest3().publciTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().privateTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().protectedTest();//这个私有类这里不可以访问

(new Test()).new privateTest3().defaultTest();//这个私有类这里不可以访问

(new Test()).new ProtectedTest3().publciTest();//这个保护类这里可以访问,公有方法可以访问

(new Test()).new ProtectedTest3().privateTest();//这个保护类这里可以访问，私有方法不可以访问

(new Test()).new ProtectedTest3().protectedTest();//这个保护类这里可以访问，保护方法可以访问

(new Test()).new ProtectedTest3().defaultTest();//这个保护类这里可以访问，默认访问权限方法可以访问

(new Test()).new DefaultTest3().publciTest();//这个默认访问权限类这里可以访问，公有方法可以访问

(new Test()).new DefaultTest3().privateTest();//这个默认访问权限类这里可以访问，私有方法不可以访问

(new Test()).new DefaultTest3().protectedTest();//这个默认访问权限类这里可以访问，保护方法可以访问

(new Test()).new DefaultTest3().defaultTest();//这个默认访问权限类这里可以访问，默认访问权限方法可以访问

(new Test()).new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

(new Test()).new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法不可以访问

(new Test()).new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法可以访问

(new Test()).new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法可以访问

}

}

测试子类的情况：package Lianxi.yong2;

import Lianxi.yong.Test;

import Lianxi.yong.Test.DefaultTest3;

import Lianxi.yong.Test.ProtectedTest3;

import Lianxi.yong.Test.PublicTest3;

import Lianxi.yong.Test.privateTest3;

public class SubTest extends Test {

public void test(){

new privateTest3().publciTest();//这个私有类这里不可以访问

new privateTest3().privateTest();//这个私有类这里不可以访问

new privateTest3().protectedTest();//这个私有类这里不可以访问

new privateTest3().defaultTest();//这个私有类这里不可以访问

new ProtectedTest3().publciTest();//这个保护类这里可以访问,公有方法可以访问

new ProtectedTest3().privateTest();//这个保护类这里可以访问,私有方法不可以访问

new ProtectedTest3().protectedTest();//这个保护类这里可以访问,保护方法不可以访问

new ProtectedTest3().defaultTest();//这个保护类这里可以访问,默认访问权限方法不可以访问

new DefaultTest3().publciTest();//这个默认访问权限类这里不可以访问

new DefaultTest3().privateTest();//这个默认访问权限类这里不可以访问

new DefaultTest3().protectedTest();//这个默认访问权限类这里不可以访问

new DefaultTest3().defaultTest();//这个默认访问权限类这里不可以访问

new PublicTest3().publciTest();//这个公有类这里可以访问,公有方法可以访问

new PublicTest3().privateTest();//这个公有类这里可以访问,私有方法不可以访问

new PublicTest3().protectedTest();//这个公有类这里可以访问,保护方法不可以访问

new PublicTest3().defaultTest();//这个公有类这里可以访问,默认访问权限方法不可以访问

}

}

内部类相当于外部类的一个属性，所以一般的访问权限的规则都适合于内部类，而且内部类的方法相当于外部类的方法来对待，如果内部类的访问权限是protected，则内部类中的方法的访问权限也是protected,这也是为什么protected class ProtectedTest3{//内部类是可以声明为私有的

public ProtectedTest3(){}//要想要子类访问，这里必须把构造方法设置为public

public void publciTest(){}

private void privateTest(){}

protected void protectedTest(){}

void defaultTest(){}

}

ProtectedTest3的构造方法访问权限是protected，跟内部类的访问权限一样，所以需要写明是public