JAVA一个包里建立好两个类，一个类如何调用另一类的里的数据？

1、先在eclipse中创建一个Java工程文件。并在src下创建demo包，在demo包下创建类DemoClass。

2、接下来在DemoClass类中添加一个静态属性和静态方法。被static修饰的属性或方法就是静态的。

3、对于静态方法的调用，可以使用调用非静态方法的方式去调用，即创建一个类的对象，然后再调用静态方法。

4、编辑好代码后，通过java应用程序的方式运行DemoClass.java文件。

5、直接通过类名来调用的。用调用例子中的staticFunction为例，正确调用该方法的代码为DemoClass.staticFunction。当用类来调用静态方法时，可以看到eclipse就不报警告了。

6、再次运行该文件，运行结果和刚刚一样，说明也成功调用了静态方法。

A类想调用B类中的变量c：给A一个属性，属性类型是B，然后再对B进行封装，用A对象调用B封装后的方法，然后就可以访问c了

代码：

public class B {

    private int c;

    public int getC() {

        return c;

    }

    public void setC(int c) {

        this.c = c;

    }

}

public class A {

    private B b;

    public B getB() {

        return b;

    }

    public void setB(B b) {

        this.b = b;

    }

    public static void main(String[] args) {

        A a=new A();

        a.getB().getC();

    }

}

扩展资料：

若出现了A类不能引用B类的方法时，有可能是以下情况：

1、B类中的方法为私有(private),则不能直接调用；

2、B类的方法为静态的(static),则使用：“类名.方法名”的方式调用；

3、B类的方法为非静态，则需要A类的实例(用B类生成的对象)来调用：

如果是同一个包的话，调用是比较简单的，主要看类里面数据的权限修饰符。
　一 访问权限修饰符修饰成员变量和方法

　　public：表明该成员变量和方法是共有的，能在任何情况下被访问。

　　protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了)

　　Java代码

　class A
　　{
　　protected int weight ;
　　protected int f( int a,int b )
　　{
　　// 方法体
　　}
　　}

　　假设B与A在同一个包中，则

　　Java代码

　class B
　　{
　　void g()
　　{
　　A a=new A();
　　A.weight=100;//合法
　　A.f(3,4); //合法
　　}
　　}

　　特别说明：什么是在同一个包中?

　　答：用package打包在一起的class ,叫在同一个包中。(不明白，举个例子)

　　eg:在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io;

　　没有使用package打包的，在同一目录下的类也会被视做同一个包。

　　friendly：在这种情况下中，同protected。区别在第二和第三种情况中。

　　Java代码

　class A
　　{
　　int weight ;
　　int f( int a,int b )
　　{
　　// 方法体
　　}
　　}

　　假设B与A在同一个包中，则

　　Java代码

　　class B
　　{
　　void g()
　　{
　　A a=new A();
　　A.weight=100;//合法
　　A.f(3,4); //合法
　　}
　　}

　　private: 只能在本类中访问。

　　Java代码

　class Test
　　{
　　private int money;
　　Test()
　　{
　　money=2000;
　　}
　　private int getMoney()
　　{
　　return money;
　　}
　　public static void main(String args[])
　　{
　　Test te=new Test();
　　te.money=3000; //合法
　　int m=te.getMoney(); //合法
　　System.out.println("money="+m);
　　}
　　}

　　PS： 实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。

你好，调用当时是通过对象来调用啦。例子：
public class A{
int num ;
public void print(){
System.out.println(num) ;
}
}
public class B{
public static void main(String[] args){
A a = new A() ;
a.num = 10 ; //操作数据
a.print() ; //调用方法
}
}

静态直接用类名调用，非静态的把那个类的对象实例化了再调用！