java调用另一个类的方法：1、类方法用static修饰，代码为【public static void sayStatic()】；2、没有static修饰的方法，代码为【 public void sayInstance()】。
java调用另一个类的方法：
java类有两种方法一种是类方法就是用static修饰的，一种是实例方法，就是没有static修饰的方法。类方法可以同时类名，方法名的方式调用。而实例方法必须先生存类的实例在通过实例.方法名的方式调用。例如：public class MethodCall
{
public static void main(String[] args)
{
Test.sayStatic();
Test test = new Test();
test.sayInstance();
}
}
class Test
{
public static void sayStatic()
{
System.out.println("这是一个静态方法。");
}
public void sayInstance()
{
System.out.println("这是一个实例方法。");
}
}相关免费学习推荐：java基础教程

在一个类中访问另一个类的方法
由于Java应用程序是由若干个类构成的，因此经常需要在一个类中访问另一个类中的成员和方法，请问应该如何在一个类中访问另一个类的方法?下面是由百分网小编为大家整理的在一个类中访问另一个类的方法，喜欢的可以收藏一下!了解更多详情资讯，请关注应届毕业生考试网!
使用Java开发的软件，通常是由若干个类和接口组成的.，所以需要在类之间进行方法调用，以完成所需要的软件功能，这可以通过在一个类中定义另一个类的实例，然后通过该实例访问那个类中的方法。
例如有两个类Student和Teacher，分别代表学生类和教师类，接下来看下面的代码：
Ø 学生类Student
01 package com.mingrisoft;
02 public class Student {
03     private int id;                                                                // 编号
04     private String name;                                                // 姓名
05     private boolean pass;                                                // 是否通过考试，true表示通过，false表示未通过
06     public void setId(int id) {
07         this.id = id;
08     }
09     public int getId() {
10         return id;
11     }
12     public void setName(String name) {
13         this.name = name;
14     }
15     public String getName() {
16         return name;
17     }
18     public void setPass(boolean pass) {
19         this.pass = pass;
20     }
21     public boolean isPass() {
22         return pass;
23     }
下面代码在教师类中创建学生类的实例，并调用学生类中的方法，完成为学生评分的功能，如果通过考试，则将其pass属性设置为true，否则设置为false。
Ø 教师类Teacher
01 package com.mingrisoft;
02 public class Teacher {
03     public static void main(String[] args) {
04         Student student = new Student();                                                // 创建学生类的实例
05         student.setId(110100);                                                                // 指定编号
06         student.setName("张*超");                                                        // 指定姓名
07         student.setPass(true);                                                                // 指定是否通过考试
08         System.out.println("编号：" + student.getId());                        // 输出编号
09         System.out.println("姓名：" + student.getName());                // 输出姓名
10         System.out.println("是否通过考试：" + student.isPass());        // 输出是否通过考试
11         System.out.println();
12         student.setId(110108);                                                                // 指定编号
13         student.setName("李*明");                                                        // 指定姓名
14         student.setPass(false);                                                                // 指定是否通过考试
15         System.out.println("编号：" + student.getId());                        // 输出编号
16         System.out.println("姓名：" + student.getName());                // 输出姓名
17         System.out.println("是否通过考试：" + student.isPass());        // 输出是否通过考试
18     }
19 }
运行程序，在控制台输出两个学生的信息，效果如图1所示。
专家点评
在一个类中访问另一个类中的方法，与在同一个类中创建类的实例，然后通过该实例访问这个类中的方法是一样的，只不过是将创建类的实例与通过该实例访问方法的代码放到另一个类中而已。
【在一个类中访问另一个类的方法】相关文章：

父类的构造方法不能被子类继承。以下语句中MyException类继承了java.lang.Exception类。
public class MyException extends Exception{} // MyException类只有一个隐含的默认构造方法
尽管在Exception类中定义了如下形式的构造方法：
public Exception(String msg)
但MyException类不会继承以上Exception类的构造方法，因此以下代码是不合法的。
//编译出错，MyException类不存在这样的构造方法
Exception e=new MyException("Something is error");
在子类的构造方法中，可以通过super语句调用父类的构造方法。例如：
public class MyException extends Exception{
public MyException(){
//调用Exception父类的Exception(String msg)构造方法
super("Something is error");
}
public MyException(String msg){
//调用Exception父类的Exception(String msg)构造方法
super(msg);
}
}
用super语句来调用父类的构造方法时，必须遵守以下语法规则。
l 在子类的构造方法中，不能直接通过父类方法名调用父类的构造方法，而是要使用super语句，以下代码是非法的：
public MyException(String msg){
Exception(msg); //编译错误
}
l 假如在子类的构造方法中有super语句，它必须作为构造方法的第一条语句，以下代码是非法的：
public MyException(){
String msg= "Something wrong";
super(msg); //编译错误，super语句必须作为构造方法的第一条语句
}
在创建子类的对象时，Java虚拟机首先执行父类的构造方法，然后再执行子类的构造方法。在多级继承的情况下，将从继承树的最上层的父类开始，依次执行各个类的构造方法，这可以保证子类对象从所有直接或间接父类中继承的实例变量都被正确地初始化。例如以下父类Base和子类Sub分别有一个实例变量a和b，当构造Sub实例时，这两个实例变量都会被初始化。
public class Base{
private int a;
public Base(int a){ this.a=a;}
public int getA(){return a;}
}
public class Sub extends Base{
private int b;
public Base(int a,int b){super(a); this.b=b;}
public int getB(){return b;}
public static void main(String args[]){
Sub sub=new Sub(1,2);
System.out.println("a="+sub.getA()+" b="+sub.getB()); //打印a=1 b=2
}
}
在例程11-3(Son.java)中，Son类继承Father类，Father类继承Grandpa类。这3个类都显式定义了默认的构造方法，此外还定义了一个带参数的构造方法。
例程11-3 Son.java
class Grandpa{
protected Grandpa(){
System.out.println("default Grandpa");
}
public Grandpa(String name){
System.out.println(name);
}
}
class Father extends Grandpa{
protected Father(){
System.out.println("default Father");
}
public Father(String grandpaName,String fatherName){
super(grandpaName);
System.out.println(fatherName);
}
}
public class Son extends Father{
public Son(){
System.out.println("default Son");
}
public Son(String grandpaName,String fatherName,String sonName){
super(grandpaName,fatherName);
System.out.println(sonName);
}
public static void main(String args[]){
Son s1= new Son("My Grandpa", "My Father", "My Son"); //①
Son s2=new Son(); //②
}
}
执行以上main()方法的第①条语句，打印结果如下：
My Grandpa
My Father
My Son
此时构造方法的执行顺序如图11-1所示。
如果子类的构造方法没有用super语句显式调用父类的构造方法，那么通过这个构造方法创建子类对象时，Java虚拟机会自动先调用父类的默认构造方法。执行以上Son类的main()方法的第②条语句，打印结果如下：
default Grandpa
default Father
default Son
此时构造方法的执行顺序如图11-2所示。
图11-1 调用Son类的带参数的构造方法时
图11-2 调用Son类的默认构造方法时
所有构造方法的执行顺序 所有构造方法的执行顺序
当子类的构造方法没有用super语句显式调用父类的构造方法，而父类又没有提供默认构造方法时，将会出现编译错误。例如把例程11-3做适当修改，删除Grandpa类中显式定义的默认构造方法。
// protected Grandpa(){
// System.out.println("default GrandPa");
// }
这样，Grandpa类就失去了默认构造方法，此时编译Father类的默认构造方法，因为找不到Grandpa类的默认构造方法而编译出错。如果把Grandpa类的默认构造方法的protected访问级别改为private访问级别，也会导致编译错误，因为Father类的默认构造方法无法访问Grandpa类的私有默认构造方法。
在以下例子中，子类Sub的默认构造方法没有通过super语句调用父类的构造方法，而是通过this语句调用了自身的另一个构造方法Sub(int i)，在Sub(int i)中通过super语句调用了父类Base的Base(int i)构造方法。这样，无论通过Sub类的哪个构造方法来创建Sub实例，都会先调用父类Base的Base(int i)构造方法。
class Base{
Base(int i){System.out.println("call Base(int i)");}
}
public class Sub extends Base{
Sub(){this(0); System.out.println("call Sub()");}
Sub(int i){super(i); System.out.println("call Sub(int i)");}
public static void main(String args[]){
Sub sub=new Sub();
}
}
执行以上Sub类的main()方法的new Sub()语句，打印结果如下：
call Base(int i)
call Sub(int i)
call Sub()
图11-3 调用Sub类的默认构造方法时所有构造方法的执行顺序
此时构造方法的执行顺序如图11-3所示。
在下面的例子中，Base类中没有定义任何构造方法，它实际上有一个隐含的默认构造方法：
Base(){}
Sub类的Sub(int i)构造方法没有用super语句显式调用父类的构造方法，因此当创建Sub实例时，会先调用Base父类的隐含默认构造方法。
class Base{} //具有隐含默认构造方法
public class Sub extends Base{
Sub(int i){System.out.println(i);}
public static void main(String args[]){
System.out.println(new Sub(1)); //打印1
}
}
构造方法只能通过以下方式被调用：
当前类的其他构造方法通过this语句调用它。
当前类的子类的构造方法通过super语句调用它。
在程序中通过new语句调用它。
对于例程11-4(Sub.java)的代码，请读者自己分析某些语句编译出错的原因。
例程11-4 Sub.java
class Base{
public Base(int i,int j){}
public Base(int i){
this(i,0); //合法
Base(i,0); //编译出错
}
}
class Sub extends Base{
public Sub(int i,int j){
super(i,0); //合法
}
void method1(int i,int j){
this(i,j); //编译出错
Sub(i,j); //编译出错
}
void method2(int i,int j){
super(i,j); //编译出错
}
void method3(int i,int j){
Base s=new Base(0,0); //合法
s.Base(0,0); //编译出错
}
}
11.2.5 构造方法的访问级别
构造方法可以处于public、protected、private和默认这4种访问级别之一。本节着重介绍构造方法处于private级别的意义。
当构造方法为private级别时，意味着只能在当前类中访问它：在当前类的其他构造方法中可以通过this语句调用它，此外还可以在当前类的成员方法中通过new语句调用它。
在以下场合之一，可以把类的所有构造方法都声明为private类型。
(1)在这个类中仅仅包含了一些供其他程序调用的静态方法，没有任何实例方法。其他程序无须创建该类的实例，就能访问类的静态方法。例如java.lang.Math类就符合这种情况，在Math类中提供了一系列用于数学运算的公共静态方法，为了禁止外部程序创建Math类的实例，Math类的惟一的构造方法是private类型的。
private Math(){}
在第7章的7.2节(abstract修饰符)提到过，abstract类型的类也不允许实例化。也许你会问，把Math类定义为如下abstract类型，不是也能禁止Math类被实例化吗？
public abstract class Math{…}
如果一个类是抽象类，意味着它是专门用于被继承的类，可以拥有子类，而且可以创建具体子类的实例。而JDK并不希望用户创建Math类的子类，在这种情况下，把类的构造方法定义为private类型更合适。
(2)禁止这个类被继承。当一个类的所有构造方法都是private类型的时，假如定义了它的子类，那么子类的构造方法无法调用父类的任何构造方法，因此会导致编译错误。在第7章的7.3.1节(final类)中提到过，把一个类声明为final类型，也能禁止这个类被继承。这两者的区别是：
如果一个类允许其他程序用new语句构造它的实例，但不允许拥有子类，那么就把类声明为final类型。
如果一个类既不允许其他程序用new语句构造它的实例，又不允许拥有子类，那么就把类的所有构造方法声明为private类型。
由于大多数类都允许其他程序用new语句构造它的实例，因此用final修饰符来禁止类被继承的做法更常见。
(3)这个类需要把构造自身实例的细节封装起来，不允许其他程序通过new语句创建这个类的实例。这个类向其他程序提供了获得自身实例的静态方法，这种方法称为静态工厂方法，本章第11.3节(静态工厂方法)对此做了进一步的介绍。
◆◆
评论读取中....
请登录后再发表评论!
◆◆
修改失败，请稍后尝试

如果另一个类中的那个方法是私有的话，就不能直接调用到，如果是其他类型的话看情况，如果是静态的（static）话，直接用类名可以调用到，如果是非静态的，就需要利用另一个类的实例（也就是用那个类生成的对象）来调用。

如

class A{
public static void a(){}
public void b(){}

}

public class B{
public static void main(String[] args){
A.a();//静态

new A().b();//非静态
}
}