Question

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

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

Answer 1

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

包私有类，其它包的类是不能访问的 ，那如果包私有类中的方法是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

追问

我说的不是内部类哦 问的是包私有

追答

包没有访问权限的概念，也就是说不可以修饰一个包，让它成为私有的公有的保护等等

也没有私有外部类的概念

比如

private class PrivateTest{//Illegal modifier for the class PrivateTest; only public, abstract & final are permitted

}

直接报错，这里的PrivateTest不是内部类

一个外部类要么只有这个包可以访问，要么其他所有包，包括这个包都可以访问

不好意思，我看出了，不过你也要说明白，那是包访问权限，不是包私有，至少我没有看过这种说法

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

不可以，因为包都访问不了

package Lianxi.yong;

class DefaultTest {
public void publicTest(){

}
}

package Lianxi.yong2;

import Lianxi.yong.DefaultTest;//The type Lianxi.yong.DefaultTest is not visible

public class OtherPackageTest {
public  void test() {
new DefaultTest();//
}
}

我也是这么认为 但是就是不太肯定 那如果我一定要调用这个包私有类中的方法呢

给出一种解决方案

package Lianxi.yong;
class DefaultTest {
public void publicTest(){

}
}
public class PublicTest{
private DefaultTest dt = new DefaultTest();
public void method(){
dt.publicTest();
}
}

 

package Lianxi.yong2;
import Lianxi.yong.PublicTest;
public class OtherPackageTest {
//首先必须把这个类暴露出来，一般是作为另一个公有类的私有属性，然后这个公有类就可以任意操纵这个包私有类了
public void test(){
new PublicTest().method();
}
}

追问

越来越乱了 我知道你说的是啥意思 只是好像和我问的不太一样

追答

我想你最好是给出代码来，我真的是不知道你要问什么，可以私信

追问

谢谢啦 你已经解决我的疑问了 无意中解决了 哈哈

Answer 2

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

说的私有类只可能是内部类，因为外部类是只有包或者公开访问权限的，
那如果包私有类中的方法是Public呢 其它包的类还能访问这个方法吗
假设提问的是内部类，不可以，因为它连这个类都访问不了,可以这样理解，一个私有内部类中的方法访问权限也肯定是private，不然的话，别人就可以访问了

Answer 3

private class TTT{}
内部类用private做修饰可以的，只有这个内部类的外部类可以访问这个内部类。

Answer 4

不能，私有类跟private 变量其实一样，这么理解

Answer 5

private类里是不能声明public方法的，语法报错

追问

我说的是类的访问控制 一种是公共 一种是包私有的 你们都理解错了