在 java 的多态调用中,new 的是哪一个类就是调用的哪个类的方法。该说法是否正确?
答案:不正确
例子:
public class Father {
public void say(){
System.out.println("father");
}
public static void action(){
System.out.println ("爸爸打儿子!");
}
}
public class Son extends Father{
public void say() {
System.out.println("son");
}
public static void action(){
System.out.println ("打打!");
}
public static void main(String[] args) {
Father f=new Son();
f.say();
f.action();
}
}
输出:
son
爸爸打儿子!
当调用 say 方法执行的是 Son 的方法,也就是重写的 say 方法
而当调用 action 方法时,执行的是 father 的方法。
普通方法,运用的是动态单分配,是根据 new 的类型确定对象,从而确定调用的方法;
静态方法,运用的是静态多分派,即根据静态类型确定对象,因此不是根据 new 的类型确定调用的方法
一、
(1)在初次 new 一个 Child 类对象时,发现其有父类,则先加载 Parent 类,再加载 Child 类。
(2)加载 Parent 类:
初始化 Parent 类的 static 属性,赋默认值;
执行 Parent 类的 static 初始化块;
(3)加载 Child 类:
初始化 Child 类的 static 属性,赋默认值;
执行 Child 类的 static 初始化块;
(4)创建 Parent 类对象:
初始化 Parent 类的非 static 属性,赋默认值;
执行 Parent 类的 instance 初始化块;
执行 Parent 类的构造方法;
(5)创建 Child 类对象:
初始化 Child 类的非 static 属性,赋默认值;
执行 Child 类的 instance 初始化块;
执行 Child 类的构造方法;
后面再创建 Child 类对象时,就按照顺序执行(4)(5)两步。
static{}//静态块
{}//构造块
静态块在一个程序里面只执行一次;
而构造块是,只要建立一个对象,构造代码块都会执行一次。
静态块优先于主方法的执行,静态块优先于构造快,然后是构造方法的执行,而且只执行一次!
类方法:使用 static 修饰(静态方法),属于整个类的,不是属于某个实例的,只能处理 static 域或调用 static 方法;
实例方法:属于对象的方法,由对象来调用。
当类的字节码文件加载到内存中时,类的实例方法并没有被分配入口地址,只有当该类的对象创建以后,实例方法才分配了入口地址。
当类的字节码文件加载到内存,类方法的入口地址就会分配完成,所以类方法不仅可以被该类的对象调用,也可以直接通过类名完成调用。类方法的入口地址只有程序退出时消失。
class A {
public A() {
System.out.println("class A");
}
{ System.out.println("I'm A class"); }//构造块
static { System.out.println("class A static"); }//static块
}
public class B extends A {
public B() {
System.out.println("class B");
}
{ System.out.println("I'm B class"); }
static { System.out.println("class B static"); }
public static void main(String[] args) {
new B();
}
}
执行结果:
class A static
class B static
I’m A class
class A
I’m B class
class B
一个类在初始化的时候,按照:父类静态初始化块 -> 子类静态初始化块 -> 父类初始化块 -> 父类构造器 -> 子类初始化块 -> 子类构造器,这样的顺序初始化的。当该子类已经加载过之后再次实例化子类对象时,执行:父类初始化块 -> 父类构造器 -> 子类初始化块 -> 子类构造器。
二、
class Base{
public Base(String s){
System.out.print("B");
}
}
public class Derived extends Base{
public Derived (String s) {
System.out.print("D");
}
public static void main(String[] args){
new Derived("C");
}
}
上述代码编译报错
子类构造方法在调用时必须先调用父类的,由于父类没有无参构造,必须在子类中显式调用,修改子类构造方法如下即可:
public Derived(String s){
super(s);
System.out.print("D");
}
解释:在调用子类构造器之前,会先调用父类构造器,当子类构造器中没有使用 “super (参数或无参数)” 指定调用父类构造器时,是默认调用父类的无参构造器,如果父类中包含有参构造器,却没有无参构造器,则在子类构造器中一定要使用 “super (参数)” 指定调用父类的有参构造器,不然就会报错。
三、
public class Demo {
class Super {
int flag = 1;
Super() {
test();
}
void test() {
System.out.println("Super.test() flag=" + flag);
}
}
class Sub extends Super {
Sub(int i) {
flag = i;
System.out.println("Sub.Sub()flag=" + flag);
}
void test() {
System.out.println("Sub.test()flag=" + flag);
}
}
public static void main(String[] args) {
new Demo().new Sub(5);
}
}
//执行结果
Sub.test()flag=1
Sub.Sub()flag=5
在继承中代码的执行顺序为:
1. 父类静态对象,父类静态代码块
2. 子类静态对象,子类静态代码块
3. 父类非静态对象,父类非静态代码块
4. 父类构造函数
5. 子类非静态对象,子类非静态代码块
6. 子类构造函数
父类先初始化了 int flag = 1,然后执行父类的构造函数 Super(),父类构造函数中执行的 test()方法,因子类是重写了 test()方法的,因此父类构造函数中的 test()方法实际执行的是子类的 test()方法(这里要特别说明的是flag是子类从父类继承来的,因为父类的flag是默认修饰符也就是包访问权限),所以输出为 Sub.test () flag=1,接着执行子类构造函数 Sub(5) 将 flag 赋值为 5,因此输出结果 Sub.Sub () flag=5。
四、
public class Base
{
private String baseName = "base";
public Base()
{
callName();
}
public void callName()
{
System. out. println(baseName);
}
static class Sub extends Base
{
private String baseName = "sub";
public void callName()
{
System. out. println (baseName) ;
}
}
public static void main(String[] args)
{
Base b = new Sub();
}
}
//输出为null
首先,需要明白类的加载顺序。
(1) 父类静态代码块 (包括静态初始化块,静态属性,但不包括静态方法)
(2) 子类静态代码块 (包括静态初始化块,静态属性,但不包括静态方法 )
(3) 父类非静态代码块 ( 包括非静态初始化块,非静态属性 )
(4) 父类构造函数
(5) 子类非静态代码块 ( 包括非静态初始化块,非静态属性 )
(6) 子类构造函数
其中:类中静态块按照声明顺序执行,并且 (1) 和 (2) 不需要调用 new 类实例的时候就执行了 (意思就是在类加载到方法区的时候执行的)
其次,需要理解子类覆盖父类方法的问题,也就是方法重写实现多态问题。
Base b = new Sub(); 它为多态的一种表现形式,声明是 Base, 实现是 Sub 类, 理解为 b 编译时表现为 Base 类特性,运行时表现为 Sub 类特性。
当子类覆盖了父类的方法后,意思是父类的方法已经被重写,题中 父类初始化调用的方法为子类实现的方法,子类实现的方法中调用的 baseName 为子类中的私有属性。
由 1. 可知,此时只执行到步骤 4., 子类非静态代码块和初始化步骤还没有到,子类中的 baseName 还没有被初始化。所以此时 baseName 为空。 所以为 null。
文章最后喜欢的小伙伴可以关注下我的或者关注我的专栏,以后给大家带来更多精彩的技术和面试知识点分享
程序员学习之路zhuanlan.zhihu.com![ba221a272701f58f248ee5d11a8cccd4.png](https://i-blog.csdnimg.cn/blog_migrate/a1d9e043f229348fe3cfd899609f7f54.jpeg)