关键字super的作用

super代表父类对应的对象，所以用super访问在子类中无法直接使用的父类成员和方法





 Java内存区域



JAVA的JVM的内存可分为3个区：堆(heap)、栈(stack)和方法区(method)

栈区:
每个线程包含一个栈区，栈中只保存方法中（不包括对象的成员变量）的基础数据类型和自定义对象的引用(不是对象)，对象都存放在堆区中
	
每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
	
栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
堆区:
存储的全部是对象实例，每个对象都包含一个与之对应的class的信息(class信息存放在方法区)。
	
jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身，几乎所有的对象实例和数组都在堆中分配。
方法区:
又叫静态区，跟堆一样，被所有的线程共享。它用于存储已经被虚拟机加载的类信息、常量、静态变量，即时编译器编译后的代码等数据。
程序计数器是一个比较小的内存区域，用于指示当前线程所执行的字节码执行到了第几行，是线程隔离的


原则上讲，所有的对象都是在堆区上分配内存，是线程之间共享的

Java方法执行内存模型，用于存储局部变量，操作数栈，动态链接，方法出口等信息，是线程隔离的



有一个源代码，只包含import java.util.* ; 这一个import语句，

能访问java/util目录下的所有类，不能访问java/util子目录下的所有类

    由于子类可以覆盖父类的实例方法、隐藏父类的类方法、隐藏父类的字段等,但是我们有时候需要引用到父类的一些方法,这时候需要借助关键字super.
 
1.使用super关键字访问父类中的成员.
    1-1.调用父类中被覆盖的方法
    示例:
public class Superclass {
    public void printMethod() {
        System.out.println("在Superclass中的输出。");
    }
}
public class Subclass extends Superclass {
	//重写超类Superclass中的printMethod方法
    	public void printMethod() { 
        	super.printMethod();							//使用super关键字调用超类中的方法
        	System.out.println("在Subclass中的输出。");
    	}
}
public class ExtendsDemo7{
    	public static void main(String[] args) {    	
    		Subclass s = new Subclass();
    		s.printMethod();	
    	}
}
输出结果:
在Superclass中的输出.
在Subclass中的输出.
 
    1-2.访问父类中被隐藏的字段
    示例:  
// 父类A
class A{
	public String name = "张小明";
}

// A的子类B
class B extends A{
	public String name = "赵红丽";
	public void self( ){
		System.out.println("我的名字是：" + name);
		System.out.println("我原来的名字是：" + super.name);	//使用super访问超类中被隐藏的字段
	}
}
// 主程序ExtendsDemo8
public class ExtendsDemo8{
  public static void main(String[ ] args){
	B b = new B( );
	b.self( );
  }
}
输出结果:
我的名字是: 赵红丽
我原来的名字是: 张小明


2.使用super关键字调用父类的构造器:
    子类是不继承父类的构造器.因此,如果要初始化父类中的字段,可以在子类的构造器中,通过关键字super调用父类的构造器.对父类的构造器的调用必须放在子类的构造器的第一行.
    示例:
// 父类A
class A{
	A(){
		System.out.println("这里是超类A的构造器。");
	}
}

// A的子类B
class B extends A{
	B(){
		super();
		System.out.println("这里是子类B的构造器。");
	}
}

// 主程序ExtendsDemo9.java
public class ExtendsDemo9{
    public static void main(String[] args) {
		B b = new B();
    }
}
输出结果:
这里是超类A的构造器.
这里是子类B的构造器.


3.构造器连
    如果一个子类的构造器显式或隐式地调用其父类的一个构造器,而其父类会再显式或隐式地调用父类的父类的构造器.形成一个完整的构造器链.
    示例:
class Book {
    private String ISBN;
    Book(String isbn){
			this.ISBN = isbn;
    }
    public String getISBN(){
			return this.ISBN;
    }
    public boolean equals(Object obj) {
        if (obj instanceof Book)
            return ISBN.equals(((Book)obj).getISBN()); 
        else
            return false;
    }
}

public class ExtendsDemo11{
    public static void main(String[] args) {
		Book firstBook  = new Book("0201914670"); 
		Book secondBook = new Book("0201914670");
		if (firstBook.equals(secondBook)) {
    			System.out.println("两个对象相等.");
		} else {
    			System.out.println("两个对象不相等.");
		}
    }
}






输出结果:
这里是超类A的构造器.
这里是超类B的构造器.
这里是子类C的构造器.


 

package org.westos_01_继承;

/*

 * 问题:

 * 不仅要在控制台输出子类中的局部变量的值,还要输出子类的成员位置的变量的值,怎么办?

 * 

 * 现在要访问子类的成员变量num =20 ;

 * 谁能代表Zi2类,this关键字:代表的是当前类对象

 * 问题:要输出父类中的成员变量的值:

 * super:代表的是父类的存储的空间标识(代表的是父类的对象或者是父类的引用)

 * 应用场景:

 * 访问成员变量:

 * this.成员变量;访问的是本类的成员变量

 * super.成员变量:访问的父类的成员变量

 * 访问成员方法:

 * this.成员方法(); 访问的是本类的成员方法

 * super.成员方法();访问拿到父类的成员方法

 * 访问构造方法:

 * this():访问的是本类中的空参构造;this("..."):访问拿到是本类中的带参构造

 * super():访问拿到是父类中无参构造

 * super(".."):访问的是父类中的带参构造

 * */

class Fu2{

public int num = 10;

}



class Zi2 extends Fu2{
public int num = 20 ;

public void show(){
int num = 30 ;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(super.num);//10
}

}



//测试类

public class ExtendsDemo5 {
public static void main(String[] args) {
//创建子类对象
Zi2 z = new Zi2() ;

z.show() ;
}
}
package org.westos_01_继承;

/*

 * 继承中构造访问的访问特点:

 * 1)子类中的构造方法默认访问的是父类的无参构造方法

 * 2）子类的构造方法默认的第一句话：super();

 * 

 * 为什么子类中的构造方法默认访问父类中的无参构造方法

 * 子类继承父类的时候,可能会使用父类的数据,所以在继承的时候,想让父类进行初始化,父类初始化完毕之后,子类才进行自己的初始化!

 * 子类的无参和有参第一句话有一个默认语句:super() ; 

 * 

 * */

class Father3{
public Father3(){
System.out.println("这是父类的无参构造方法...");
}

public Father3(String name){
System.out.println("这是父类的带参构造方法...");
}

}

//子类

class Son3 extends Father3{
public Son3(){
///super() ;
System.out.println("这是子类的无参构造方法...");
}



public Son3(String name){
//super() ;
System.out.println("这是子类的有参构造方法...");
}



} 



//测试类

public class ExtendsDemo6 {
public static void main(String[] args) {
//创建对象
Son3 s = new Son3() ;
System.out.println("-------------------");
Son3 s2 = new Son3("高圆圆") ;


}

}

                                                    
1.调用父类的构造方法
 
 
 子类可以调用由父类声明的构造方法.但是必须是在子类的构造方法中使用super关键字来调用.
 
 
语法格式:super([参数列表]);
 
 
如果父类的构造方法中包括参数,则参数列表为必选项,用于指定父类构造方法的入口参数.
 
 
 2.操作被隐藏的成员变量和被重写的成员方法
 
 
 如果想在子类中操作父类中被隐藏的成员变量和被重写的成员方法,也可以使用super关键字.
                                                    
转载于:https://my.oschina.net/u/3820364/blog/1818437