「java包访问」导入java包
本篇文章给大家谈谈java包访问，以及导入java包对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
- 1、JAVA跨包访问对象如何实现？
- 2、在java中包私有类的公共方法,其它包的类能访问吗
- 3、JAVA中包如何使用
- 4、在java中如何访问其他包中的project类,知道的说下..谢谢啦
- 5、北大青鸟设计培训：java封装的访问控制级别？
- 6、在Java中，如果类中成员的变量可以被同一包访问，则应使用（？）关键字来约束？
JAVA跨包访问对象如何实现？
类A
package com.common;
public class A{
.......
}
在类B中访问A类
package com.util;
import com.common.*;
public class B{
A a = new A();
public B(){
a.xxx();
}
}
在java中包私有类的公共方法,其它包的类能访问吗
我知道你不想看测试的，所以直接给答案：
包私有类，其它包的类是不能访问的 ，那如果包私有类中的方法是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
JAVA中包如何使用
自定义包实际上就是相对项目的一个文件夹路径。可以项目上右击，选择“new”，之后选择“Package”的形式创建一个文件夹路径（路径之间用英文“点”）。
举例：
创建的包路径：com.icardpay.business.core.remit.bank.handler.impl；
引用包路径：import com.icardpay.business.core.remit.bank.handler.impl.*;
在java中如何访问其他包中的project类,知道的说下..谢谢啦
package com.test
class A{
public void sayHello(){
System.out.println("Hello world");
}
}
public class B{
public static void main(String [] args){
com.test.A a = new com.test.A();
a.sayHello();
}
}
北大青鸟设计培训：java封装的访问控制级别？
java培训过程中，我们常接触到的一个知识点是关于java的封装，封装提供了4中访问控制级别。
1、public公用的，最高的访问级别，类的public成员所以类的成员都可以访问。
2、protected受保护的，类的protected成员只能被该类的成员及其子类成员访问，还可以被同一个包中其他类的成员访问。
3、private私有的，不对外公开，类的private成员只能被该类的成员访问，访问级别最低。
4、默认，类的成员什么修饰符都没有，又叫包修饰符，只有类本身成员和当前包下类的成员可以访问。
那么封装是如何实现的呢?其实可以通过以下方法来实现哦。
1、修改属性的可见性来限制对属性的访问。
2、为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问。
3、在赋值和取值方法中，加入对属性的存取权限。
在学习java的过程中，我们要多看多写，盐城电脑培训认为只有在不断的编写程序中，我们才能学习到更多java方面的知识。
在Java中，如果类中成员的变量可以被同一包访问，则应使用（？）关键字来约束？
A(private) ：私有的 作用域：当前类B (void):无返回值： 我认为不能修饰类中的成员C(protected):保护的 作用域：当前类、同一package(包)、子类 D（采用默认的修饰符）friendly :友好的 作用域：当前类、同一package(包)
关于java包访问和导入java包的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。