???????????????

开始这个系列是因为想总结一下面试中比较常见的考点。。不喜勿喷~~~~~~

 

1、静态代码块、构造代码块、普通代码块和构造函数的执行顺序

静态代码块:在java中使用static关键字声明的代码块。静态块用于初始化类,为类的属性初始化。每个静态代码块只会执行一次。由于JVM在加载类时会执行静态代码块,所以静态代码块先于主方法执行。

构造代码块:直接在类中定义且没有加static关键字的代码块称为{}构造代码块。构造代码块在创建对象时被调用,每次创建对象都会被调用,并且构造代码块的执行次序优先于类构造函数。

普通代码块:在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现先执行”

构造函数:也称构造器,和类同名,没有返回类型。(void也没有)

 

那么他们的执行顺序如何呢?用一个小例子可以了解~

 

class A {
	{
		System.out.println("我是构造代码块=======");
	}
	
	static {
		System.out.println("我是静态代码块=======");
	}
	
	A() {
		System.out.println("我是构造函数=========");
	}
	
	public void test() {
		System.out.println("我是普通代码块=========");
	}

        public static void main(String[] args) {
		System.out.println("我是main普通代码块=========");
	}
}

我们先运行A本身:

我是静态代码块=======

我是main普通代码块=========

 

我们再用另一个类调用下:

 

 

		A a = new A();
		a.test();
		System.out.println();
		A a1 = new A();
		a1.test();

 打印结果:

 

我是静态代码块=======

我是构造代码块=======

我是构造函数=========

我是普通代码块=========

 

我是构造代码块=======

我是构造函数=========

我是普通代码块=========

 

由此可见:每个类的静态代码块只会执行一次,无论你初始化多少次;而构造代码块、构造函数是每初始化一次就执行一次的。

执行顺序:静态代码块>mian方法>构造代码块>构造方法

 

2、构造函数与继承

每个类都有一个默认的构造函数(不带参数),可以不用定义;但是当你重载了一个带参的构造函数,则默认的构造函数将会被覆盖,如果你想同时拥有默认的构造器和重载的带参的构造器,则默认构造器必须定义出来。

而构造函数的继承也是常见考点~也是比较蛋疼的地方。。

class Aoo {
	public Aoo() {
		System.out.println("Aoo 默认构造器");
	}
	
	public Aoo(int i) {
		System.out.println("Aoo 带参构造器:" + i);
	}
	
	public void test() {
		System.out.println("Aoo 的test方法");
	}
	
	public void test(int i) {
		System.out.println("Aoo 的test带参方法:" + i);
	}
}

class Boo extends Aoo{
	public Boo() {
		System.out.println("Boo 默认构造器");
	}
	
	public Boo(int i) {
		System.out.println("Boo 带参构造器:" + i);
	}
	
	public void test() {
		System.out.println("Boo 的test方法");
	}
	
	public void test(int i) {
		System.out.println("Boo 的test带参方法:" + i);
	}
}

 我们再调用:

		Boo boo = new Boo();//或Aoo boo = new Boo(); 结果都一样
                boo = new Boo(1);
		boo.test();
		boo.test(1);

 打印结果:

Aoo 默认构造器

Boo 默认构造器

Aoo 默认构造器

Boo 带参构造器:1

Boo 的test方法

Boo 的test带参方法:1

 

说明:

1)子类永远会默认继承父类的默认(不带参)的构造函数,子类每初始化一次,必然会调用一次父类的不带参的默认构造器。

2)当子类和父类都有相同方法声明的函数时,具体调用子类还是父类的方法是看初始化的谁,例如本例中是new B,而与变量类型无关;

 

3、重载和重写

重载:在一个类里,方法名相同,方法声明不同(参数声明不同,返回值类型也可能不同);

重写:涉及集成,子类和父类拥有相同的方法名和方法声明,返回值类型必须和父类相同。

重载是一个类里的多态性,重写是子类和父类的多态性体现~

 

我们先定义2个父子类:

class Super {
	public void t() {
		System.out.println("Super t()");
	}
} 

class Sub extends Super {
	public void t() {
		System.out.println("Sub t()");
	}
}

 这里Sub子类重写了父类的t()方法,

我们再定义一个类,里面有重载的2个方法:

class Goo {
	public void test(Super obj) {
		System.out.println("test Super");
		obj.t();
	}
	
	public void test(Sub obj) {
		System.out.println("test Sub");
		obj.t();
	}
}

 再调用:

		Goo goo = new Goo();
		Super obj = new Sub();
		goo.test(obj);

 

打印结果:

test Super

 

Sub t()

这说明:

1)Goo类里有重载的test方法,goo.test(obj);里的参数obj的类型是Super,所以调用的是Goo的第一个test方法;所以打印出:test Super

2)虽然Super obj = new Sub();但调用涉及重写的方法时,看的是真正实例化的类,这里虽然用父类Super定义,但实例化的是子类Sub,所以调用的子类的t()方法~

 

 

 

你可能感兴趣的:(??,??,??,??,?????)