java怎么调用另一个类的方法_java中怎样调用另一个类的main方法

父类的构造方法不能被子类继承。以下语句中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节(静态工厂方法)对此做了进一步的介绍。

◆◆

评论读取中....

请登录后再发表评论!

◆◆

修改失败，请稍后尝试