1、当父类与子类的成员变量不一样的时候，根据变量名进行访问
2、当父类与子类的成员变量的名字一样的时候
子类中查找变量的顺序：
1）现在子类方法局部范围内找，找到就返回
2）子类中成员范围内去找，找到就返回
3）在父类的成员范围内去找，找到就返回
4）如果在父类中都没有找到该变量，报错
package extendsDemo;
class Person{
int num = 10;
public void show2(){
int num3 = 50;
}
}
class Student extends Person{
int num =20;
public void show(){
int num = 30;
System.out.println(num);
}
}
public class Demo2 {
public static void main(String[] args) {
Student s = new Student();
s.show();
}
}
结果为 30，优先调用了子类方法局部范围内的num变量
如果去掉方法局部范围的num变量
package extendsDemo;
class Person{
int num = 10;
public void show2(){
int num3 = 50;
}
}
class Student extends Person{
int num =20;
public void show(){
System.out.println(num);
}
}
public class Demo2 {
public static void main(String[] args) {
Student s = new Student();
s.show();
}
}
结果为 20，优先调用子类的成员变量
当子类的成员变量和方法局部范围的变量都没有的时候，会调用子类从父类继承下来的父类的成员变量，最后输出的结果会是 10
而如果想绕过这个优先级的顺序来调用变量，就可以用 super 和 this 关键字
package extendsDemo;
class Person{
int num = 10;
public void show2(){
int num3 = 50;
}
}
class Student extends Person{
int num =20;
public void show(){
int num = 30;
System.out.println(num);
System.out.println(this.num);
System.out.println(super.num);
}
}
public class Demo2 {
public static void main(String[] args) {
Student s = new Student();
s.show();
}
}
结果为
this.成员变量 调用的是本类中的成员变量
super.成员变量 调用的是父类的成员变量
同样的，成员方法也有调用的优先级顺序
继承与成员方法的关系
1、子类的成员方法与父类的成员方法的方法名不一样的时候，就按照方法名来访问不同的方法
2、子类的成员方法与父类的成员方法的方法名一样的时候
1）先找子类中，看有没有这个方法，如果有，就直接调用
2）如果子类中没有这个方法，去父类找，如果有，就调用
3）如果连父类都没有这个方法，报错
class Person1{
public void show(){
System.out.println("父类的show方法");
}
}
class Student1 extends Person1{
public void show(){
System.out.println("子类的show方法");
}
}
public class Demo3 {
public static void main(String[] args) {
Student1 s = new Student1();
s.show();
}
}
结果为
其实父类和子类的方法名重复的情况叫重写。重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
class Person1{
public void show(){
System.out.println("父类的show方法");
}
}
class Student1 extends Person1{
public void change_show(){
System.out.println("子类的show方法");
}
}
public class Demo3 {
public static void main(String[] args) {
Student1 s = new Student1();
s.show();
}
}
结果为
同样的，可以通过super强行调用父类中的方法
this.成员方法 调用本类的成员方法
super.成员方法 调用父类的成员方法
class Person1{
public void walk(){
System.out.println("父类的walk方法");
}
}
class Student1 extends Person1{
public void run(){
System.out.println("子类的run方法");
walk();
}
public void walk(){
System.out.println("子类的walk方法");
}
}
public class Demo3 {
public static void main(String[] args) {
Student1 s = new Student1();
s.run();
}
}
结果为
通过super调用父类的walk方法
class Person1{
public void walk(){
System.out.println("父类的walk方法");
}
}
class Student1 extends Person1{
public void run(){
System.out.println("子类的run方法");
super.walk();
}
public void walk(){
System.out.println("子类的walk方法");
}
}
public class Demo3 {
public static void main(String[] args) {
Student1 s = new Student1();
s.run();
}
}
结果为
这里再拓展一下super与this在构造方法中的应用
this(…) 调用本类中构造方法
super(…) 调用父类中构造方法
注意，this调用本类的其他形式的构造方法，即一个构造方法不能通过this调用自身
package extendsDemo;
class Person2{
String name;
public Person2(){
System.out.println("父类的无参构造方法");
}
public Person2(String n){
name = n;
System.out.println("父类的带参构造方法");
}
}
class Student2 extends Person2{
public Student2(){
System.out.println("子类的无参构造方法");
}
public Student2(String n){
System.out.println("子类的带参构造方法");
}
}
public class Demo4 {
public static void main(String[] args) {
Student2 s = new Student2();
System.out.println("————————————");
Student2 s1 = new Student2("名字");
}
}
运行后发现结果是
在调用子类的构造方法之前，先调用了父类的无参构造方法
1、子类中所有的构造方法默认都会访问父类中无参构造方法
2、因为子类会继承父类的数据，可能还会使用父类的数据。所以在初始化子类之前，一定会先完成父类的初始化
所以实际上，上面的代码都可以写成这样的形式，即子类的每个构造方法都默认有一个super()，括号里面的参数列表为空，所以调用的是父类的无参构造方法
package extendsDemo;
class Person2{
String name;
public Person2(){
System.out.println("父类的无参构造方法");
}
public Person2(String n){
name = n;
System.out.println("父类的带参构造方法");
}
}
class Student2 extends Person2{
public Student2(){
super();
System.out.println("子类的无参构造方法");
}
public Student2(String n){
super();
System.out.println("子类的带参构造方法");
}
}
public class Demo4 {
public static void main(String[] args) {
Student2 s = new Student2();
System.out.println("————————————");
Student2 s1 = new Student2("名字");
}
}
super的括号里面也可以放入参数，这样调用的就是父类的带参构造方法
子类的构造方法中写this()，会调用子类中的构造方法，具体调用哪个构造方法，根据this()括号中的参数列表决定，括号里面为空则是调用子类的无参构造方法
package extendsDemo;
class Person2{
String name;
public Person2(){
System.out.println("父类的无参构造方法");
}
public Person2(String n){
name = n;
System.out.println("父类的带参构造方法");
}
}
class Student2 extends Person2{
public Student2(){
super("名字");
System.out.println("子类的无参构造方法");
}
public Student2(String n){
this();
System.out.println("子类的带参构造方法");
}
}
public class Demo4 {
public static void main(String[] args) {
Student2 s = new Student2();
System.out.println("————————————");
Student2 s1 = new Student2("名字");
}
}
结果为
这里还有一个需要注意的地方
public Student2(String n){
this();
System.out.println("子类的带参构造方法");
}
里面是this()，而没有写super(“名字”); 但是最后输出的结果中，是父类的带参构造方法，说明调用了父类的带参构造方法
这里是因为this调用了子类的无参构造方法
public Student2(){
super("名字");
System.out.println("子类的无参构造方法");
}
而无参构造方法中调用的是父类的带参构造方法，所以最后打印的结果是带参构造方法
注意事项：
1、super(…)和this(…)必须出现在构造方法的第一条语句上
2、在Java中不允许对一个类进行多次初始化，
如果调用了多次super，相当于调用多次父类构造方法，就是对父类数据进行多次初始化。所以无论是super（）还是this（），在子类的某一个构造方法中只能出现其中一个而且只能出现一次。
