class A { public A() { System.out.println("A"); } class B extends A { public B() { System.out.println("B"); } public static void main(String[] args) { B b=new B(); } }
class Base{ public int status=0; Base(int status) {this.status=status;} public void print() { System.out.println("base"); } } class Sub extends Base { public int status; Sub(int status) { super(status-1); this.status=status; } public void printSub() { System.out.println("sub"); System.out.println("status="+status); } public void printBase() { super.print(); System.out.println("status="+super.status); } } public class Test { public static void main(String args[]) { Sub s=new Sub(2); s.printBase(); s.printSub(); } }
public class Outer { public void someOuterMethod() { //Line 3 ) public class Inner{} public static void main(String[]argv) { Outer o=new Outer(); //Line 8 } }
public class Test{ public Yest(){System.out.println("construct");} public void Test(){ System.out.println("call Test");} public static void main(String[]args){ Test a=new Test();//调用构造方法 a.Test();//调用Test方法 } }
class Base { Base() { System.out.print("Base");} } public class Alpha extends Base { public static void main(String[] args) { new Alpha(); new Base(); } }
class People{ String name; public People() {System.out.print(1);} public People(String name){ System.out.print(2); this.name=name; } } class Child extends People{ People father; public Child(String flame){ System.out.print(3); this.name=name; father=new People(name+":F"); } public Child() {System.out.print(4);} }
public class Test { public static void main(String argv[]) { Test h=newTest(); } protected Test() { for(int i=0;i<10;i++) { System.out.println(i); } } }
classB { public B(){System.out.println("construct B");} } class C extends B { public C(){super();} } public class Test{ public static void main(String args[]) { new C(); } }
class Person{ String name="Jack"; public Person(){ System.out.println("construct"); } public String toString(){ return name;} } public class Test{ public static void main(String[]args){ Class classType; try{ classType=Class.forName("Person"); Person p=(Person)classType.newInstance(); System.out.println(p); }catch(Exception e){ e.printStackTrace(); } } }
程序的运行结果为:
construct
Jack
从以上运行结果可以看出,这种方法也调用了构造方法。
3)通过反序列化的方式创建对象,示例代码如下:
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectlnputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class People implements Serializable {
private String name;
public People() {
this.name="lili";
System.out.println("construct");
}
public String toString() {retum this.name;}
public static void main(String[] args) {
People p=new People();
System.out.println(p);
ObjectOutputStream oos=null;
ObjectInputStream ois=null;
try {
FileOutputStream fos=new FileOutputStream("perple.out");
oos = new ObjectOutputStream(fos);
oos.writeObject(p);
oos.close(),
} catch (Exception ex) { }
People p1;
try {
FileInputStream fis = new FileInputStream("perple.out");
ois = new ObjectlnputStream(fis);
p1=(People) ois.readObject();
System.out.println(p);
if(p!=p1)
System.out.println("two different object");
ois.close();
}catch (Exception ex) {}
}
}
interface IFTest{ public static final String name;//1 void f();//2 public void g();//3 } abstract class ABTest implements IFTest {//4 public void f(){ } }
public class Test { public static void main(String[]args) { String a="hello"; //print(a);//没有实例化对象,编译错误 Testt=newTest(); t.print(a);//有实例化对象,可以执行 } public void print(String str) { System.out.println(str); } }
public class Ex { public static void main(String[]args) { Fx f=new Fx(5); } Ex(){System.out.println("Ex,no-args");} Ex(int i){System.out.println("Ex,int");} } class Fx extends Ex { Fx(){ super(); System.out.println("Fx,no-args"); } Fx(int i){ this(); System.out.println("Fx,int"); } }
class Base { public Base() {g();} public void f() {System.out.println("Base f()");} public void g() {System.out.pfintln("Base g()");} } class Derived extends Base { public void f(){System.out.println("Derived f()");} public void g() {System.out.println("Derived g()");} } public class Test { public static void main(String[]args) { Base b=new Derived(); b.f(); b.g(); } }
public class HelloB extends HelloA { public HelloB() { System.out.pfintln("HelloB"); } { System.out.println("I'm B class"); } static { System.out.pfintln("static B"); } public static void main(String[]args) { new HelloB(); } } class HelloA { public HelloA() { System.out.pfintln("HelloA"); } { System.out.println("I'm A class"); } static{ System.out.println("static A"); } }
不存在问题,程序的运行结果为:
static A static B I'm A class HelloA I'm B class HelloB
在Java语言中,当实例化对象时,对象所在类的所有成员变量首先要进行初始化,只有当所有类成员完成初始化后,才会调用对象所在类的构造函数创建对象。
Java程序的初始化一般遵循以下三个原则(以下三原则优先级依次递减):①静态对象(变量)优先于非静态对象(变量)初始化,其中,静态对象(变量)只初始化一次,而非静态对象(变量)可能会初始化多次;②父类优先于予类进行初始化;③按照成员变量定义顺序进行初始化,即使变量定义散布于方法定义中,它们依然在任何方法(包括构造函数)被调用之前先初始化。
Java程序初始化工作可以在许多不同的代码块中完成(例如静态代码块、构造函数等),它们执行的顺序如下:父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类非静态变量、父类非静态代码块、父类构造函数、子类非静态变量、子类非静态代码块和子类构造函数。
根据以上分析可知,本题中,当代码运行时,首先执行父类静态代码块,输出static A;接着执行子类静态代码块,输出static B;执行父类非静态代码块,输出I'm A class;执行父类构造函数,输出HelloA;执行子类非静态代码块,输出I'm B class,最后执行子类构造函数,输出HelloB。
2. 下面代码的运行结果是______。
class Base{ int num=1; public Base() { this.print(); num=2; } public void print() { System.out.println("Base.num="+num); } } class Sub extends Base{ int num=3; public Sub(){ this.print(); num=4; } public void print() { System.out.println("Sub.num="+num); } } public class Test{ public static void main(String[]args) { Baseb=new Sub(); System.out.println(b.num); } }