Java继承 学习 && 类初始化顺序

reference

private是私有成员，子类不可访问，和被override的类都要通过super访问。变量没有重写之说，只有屏蔽。

类的继承知识点

（1）java不支持多重继承，也就是说子类至多只能有一个父类

（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法

（3）子类中定义的成员变量和父类中定义的成员变量相同时，则父类中的成员变量不能被继承

（4）子类中定义的成员方法，并且这个成员方法的名字，返回类型，及参数个数和类型与父类的某个成员方法完全相同，则父类的成员方法不能被继承。

class Ttest {
public static void main(String[] args){
B b=new B(0);
int y=b.getY();
}
}

class A {
public static int x=2; //1.
private int y=2;      //2.
protected int z=3;      //5.
A(){                      //3.
x=x+1;
showX();        //4.
}
public void showX(){
System.out.println("A.x="+x);
}
public int getY(){
return y;
}
}

class B extends A {
B(int x){
x=x+2;                 //只对局部x操作
showX();
}
public void showX(){
System.out.println("B.x="+x);
}
public int getY(){ //6.
System.out.println("B.z=" + z);
System.out.println("B.y="+(super.getY()+x));
return super.getY()+x;
}
}
/**
//B.x=3 会默认先调用父类的super，A，但是输出函数是多态的
//B.x=3 B自己输出
//B.z=3
//B.y=5
1. public static int x被继承到B，成为B的私有域。
2. B中仍然有一个名为y的域，但是无法直接访问，需要通过super.getY()
3. 如果子类构造函数没有显式调用超类构造函数，将会自动调用超类的无参构造函 数，若超类没有无参构造函数，子类中又没有显式调用，则编译器报错
4. java默认动态绑定机制，若不需要动态绑定则将方法定义为final阻止继承
5. 类A的protected修饰符的数据或方法，可以被同个包中的任何一个类访问(包括子类），也可以被不同包中的A的子类访问。
6. 覆盖一个方法时，子类的方法可见性不能低于父类方法的可见性。
*/

public abstract class A {
int i=1;
// 有没有是一样的
// public void printI() {
//   System.out.println("i="+i);
// }
}
public class B extends A{
public int i=2;
public void printI(){
super.printI();
}
public static void main(String[] args){
B b= new B();
b.printI();

}
}
/**
输出1
jvm的执行过程
（1）子类B 的构造方法被调用，实例化一个B对象，B对象的成员被初始化
（2）jvm隐含的调用父类的构造方法,实例化一个A对象，A对象的成员被初始化。
（3）由于A对象的printI()未被屏蔽，所以调用的A对象的printI()函数。
那么，在这里A的成员函数当然是访问自己的成员变量了。
*/

/**
super关键字在java中的作用是使被屏蔽的成员变量或者成员方法或变为可见，或者说用来引用被屏蔽的成员变量和成员成员方法。super是用在子类中，目的是访问直接父类中被屏蔽的成员
*/

---
public class A {

public int m = 1;

public void view(){
System.out.println(this.m);
System.out.println(this.getClass());
}

}

public class B extends A{
public int m = 2;
/**
*  @Override
*  public void view(){
*      System.out.println(this.m);
*      System.out.println(super.m);
*      System.out.println(this.getClass());
*  }
*/

public static void main(String[] args) {
B b = new B();
b.view();
}
}
/**
看执行结果：
1
class B

而如果将注释去掉，即重写view方法，再看结果：
2
1
class B

从结果即可以看出子类中有两个相同名称的成员变量，所以成员变量没有重写
*/

更新一道携程笔试题

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. static按照写的顺序随类加载一起初始化
2. 其他写上初始值的都是在构造函数时初始化（有父类的先去父类中初始化隐含）
3. 由于多态，Base调用的callName是子类的函数，此时this指向为子类的baseName，还没初始化。因此为null
*/

再来一发面试题：

import java.awt.print.Book;
import java.io.Serializable;
import java.lang.reflect.ParameterizedType;

/**
* Created by bingone on 15/11/13.
*/
public class hibernate<T extends Number> {
public T v;
public static void main(String[] args) throws NoSuchFieldException {
hibernate<Double> h = new hibernate<Double>();
System.out.println( h.getClass().getField("v").getGenericType() );
}
}
class T  implements Cloneable{
public static int k = 0;
public static T t1 = new T("t1");
public static T t2 = new T("t2");
public static int i = print("i");
public static int n = 99;

public int j = print("j");
{
print("构造块");
}

static {
print("静态块");
}

public T(String str) {
System.out.println((++k) + ":" + str + "    i=" + i + "  n=" + n);
++n; ++ i;
}

public static int print(String str){
System.out.println((++k) +":" + str + "   i=" + i + "   n=" + n);
++n;
return ++ i;
}

public static void main(String[] args){
T t = new T("init");
}
}
/**
1:j   i=0   n=0
2:构造块   i=1   n=1
3:t1    i=2  n=2
4:j   i=3   n=3
5:构造块   i=4   n=4
6:t2    i=5  n=5
7:i   i=6   n=6
8:静态块   i=7   n=99
9:j   i=8   n=100
10:构造块   i=9   n=101
11:init    i=10  n=102
*/