1.访问父类成员的三种方法
- 在子类内部访问。
- 通过子类创建的对象，用对象名.成员名访问。
- 如果成员是静态的，通过子类名.成员名或者父类名.成员名访问。
class A
{
public int i;
public static int j;
}
class B extends A
{
public void f()
{
i = 1; //在子类内部访问父类成员
}
}
public class Test
{
public static void main(String[] args)
{
B b1 = new B();
A.j = 1; //通过父类名访问静态成员
b1.i = 2; //通过子类对象名访问
B.j = 3; //通过子类名访问静态成员
}
}
2.在子类中对父类成员初始化
- 子类中没有与父类同名的成员
class A
{
int i;
}
class B extends A
{
int j;
B()
{
}
B(int i, int j)
{
this.i = i; //对父类成员赋值，如果父类成员有很多，使用这种方法效率太低
this.j = j; //对子类的成员进行赋值
}
}
public class Test
{
public static void main(String[] args)
{
B b1 = new B();
B b2 = new B(1, 2);
System.out.printf("%d, %d\n", b1.i,b1.j);
System.out.printf("%d, %d\n", b2.i,b2.j);
}
}
- 子类中有与父类同名的成员（需要使用this和super来区分）
class A
{
int i;
}
class B extends A
{
int i; //子类中有与父类同名的成员,需要用this和super来区分
int j;
B()
{
}
B(int i, int j, int k)
{
this.i = i; //对子类自身成员赋值，this说明成员是子类的
this.j = j; //对子类的成员进行赋值
super.i = k; //对父类成员赋值，因为子类中有与父类同名的成员，就需要用super来说明当前成员是父类的
}
void f()
{
System.out.println(super.i);
System.out.println(this.i);
}
}
public class Test
{
public static void main(String[] args)
{
B b1 = new B();
B b2 = new B(1, 2, 3);
System.out.printf("%d, %d\n", b1.i,b1.j);
System.out.printf("%d, %d\n", b2.i,b2.j);
b2.f();
}
}
输出结果：
0, 0
1, 2
3
1
2.子类中super的使用
- 通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
class Animal
{
void eat()
{
System.out.println("animal : eat");
}
}
class Dog extends Animal
{
void eat()
{
System.out.println("dog : eat");
}
void eatTest()
{
this.eat(); // this 调用自己的方法
super.eat(); // super 调用父类方法，只有在子类的成员和父类的成员同名的情况下需要用super进行区分
}
}
public class Test
{
public static void main(String[] args)
{
Animal a = new Animal();
a.eat();
Dog d = new Dog();
d.eatTest();
}
}
输出结果：
animal : eat
dog : eat
animal : eat
- 使用super对父类成员进行初始化（可以避免对父类成员挨个初始化的问题）
子类是不能继承父类的构造方法的，它只是调用（隐式或显式）。在子类的构造方法中可使用语句super（参数列表）调用父类的构造方法。
如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
class A
{
int i;
A()
{
System.out.println("嘿嘿");
}
A(int i)
{
this.i = i;
}
}
class B extends A
{
int j;
B()
{
super(); //调用A(),super()可不写，不写会隐式地调用
}
B(int k, int j )
{
super(k); //调用A(int i)显式地调用父类中带有参数的构造器，对super的调用必须是构造器中的第一个语句
this.j = j; //对子类的成员进行赋值
}
}
public class Test
{
public static void main(String[] args)
{
B b1 = new B(); /*创建对象时自动调用B的构造器，因为B的构造器中隐式地调用了A类的无参构造器
所以创建B对象时，就会输出“嘿嘿”*/
B b2 = new B(1, 2);
System.out.printf("%d, %d\n", b1.i,b1.j);
System.out.printf("%d, %d\n", b2.i,b2.j);
}
}
输出结果：
嘿嘿
0, 0
1, 2
注意：对super的调用必须是构造器中的第一个语句，必须在子类构造器中才能通过super调用父类构造器，且必须是子类构造器中的第一个语句。
3.对super的理解
- 每个子类构造器都会调用一个父类构造函数，如果没有显式的声明，就会隐含的调用super（），相当于调用父类的无参构造函数，如果父类没有无参构造函数，则会报错。
- 如果显式的使用了super语句，super语句必须是构造函数中第一个语句。
- 调用父类的构造函数必须借助super实现，每个子类构造器只能调用一个构造函数，即在每个子类构造函数中只能使用一次super。
