java 关于继承中的super() 方法

要讲super就不能不提this，下面从4个角度讲解一下super（需要对比的时候拿this对比一下，加深理解）

创新互联是一家集网站建设,盐池企业网站建设,盐池品牌网站建设,网站定制,盐池网站建设报价,网络营销,网络优化,盐池网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。

1. super关键字表示超（父）类的意思。this变量代表对象本身。

2. super访问父类被子类隐藏的变量或覆盖的方法。当前类如果是从超类继承而来的，当调用super.XX()就是调用基类版本的XX（）方法。其中超类是最近的父类。

3.调用super() 父类构造函数的时候只能调用在子类构造函数的第一行

4.this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this。并且this只和特定的对象关联，而不和类关联，同一个类的不同对象有不同的this

例如：

class Person {

protected void print() {

System.out.println("The print() in class Person.");

}

}

public class DemoSuper extends Person {

public DemoSuper(){

super(); //调用父类的构造方法，而且放第一行，如果不写，系统自动加

}

public void print() {

System.out.println("The print() in class DemoSuper.");

super.print();// 调用父类的方法

}

public static void main(String[] args) {

DemoSuper ds = new DemoSuper();

ds.print();

}

}

java 继承父类 是会先执行父类吗

java中子类继承父类程序执行顺序问题

Java中，new一个类的对象，类里面的静态代码块、非静态代码、无参构造方法、有参构造方法、类的一般方法等部分，它们的执行顺序相对来说比较简单，用程序也很容易验证。比如新建一个测试父类。

public class FatherTest {

private String name;

FatherTest(){

System.out.println("--父类的无参构造函数--");

}

FatherTest(String name){

this.name=name;

System.out.println("--父类的有参构造函数--"+this.name);

}

static{

System.out.println("--父类的静态代码块--");

}

{

System.out.println("--父类的非静态代码块--");

}

public void speak(){

System.out.println("--父类的方法--");

}

}

加入一个main程序后

public static void main(String[] args) {

System.out.println("--父类主程序--");

FatherTest father=new FatherTest("父亲的名字");

father.speak();

}

执行结果为：

--父类的静态代码块--

--父类主程序--

--父类的非静态代码块--

--父类的有参构造函数--父亲的名字

--父类的方法—

可以很明显的看出来执行顺序：静态代码块—主程序—非静态代码块—构造函数—一般方法。

如果加入子类的继承以后，情况就会变得复杂些。比如我们再新建一个测试子类。

public class SonTest extends FatherTest {

private String name;

static{

System.out.println("--子类的静态代码块--");

}

{

System.out.println("--子类的非静态代码块--");

}

SonTest(){

System.out.println("--子类的无参构造函数--");

}

SonTest(String name){

this.name=name;

System.out.println("--子类的有参构造函数--"+this.name);

}

@Override

public void speak(){

System.out.println("--子类Override了父类的方法--");

}

}

然后再加入一个main函数

public static void main(String[] args) {

System.out.println("--子类主程序--");

FatherTest father=new FatherTest("父亲的名字");

father.speak();

SonTest son=new SonTest("儿子的名字");

son.speak();

}

执行结果为：

--父类的静态代码块--

--子类的静态代码块--

--子类主程序--

--父类的非静态代码块--

--父类的有参构造函数--父亲的名字

--父类的方法--

--父类的非静态代码块--

--父类的无参构造函数--

--子类的非静态代码块--

--子类的有参构造函数--儿子的名字

--子类Override了父类的方法--

加入了子类以后，执行顺序有了新的变化，我们可以总结一下。首先第一部分执行的是父类的静态代码块—子类的静态代码块—主程序。这一部分都是执行一次，与建立多少对象没有关系。第二部分new了一个父类对象，并调用了方法。执行了它的非静态代码块—构造函数—一般方法。第三部分new了一个子类的对象，并调用了方法。执行顺序为父类的非静态代码块—父类的无参构造函数，然后是子类的非静态代码块—子类构造函数—子类的方法。

super 在Java继承中的作用？？

关键字super明确显式地指出一个类可以它父类的构造函数、方法和变量。

关键字super和继承一起建立类和它的父类的紧密联系。继承隐含地指出子类对父类所拥有的访问权限。例如，当我们要调用一个实例方法时，如果实例本身并没有定义该方法，那我们自然地会得到它的父类中定义的同名方法。尽管会因为方法的覆盖或者使用定义与父类一样的实例或类变量（叫做“隐藏”）而失去这种访问的权力。这就是为什么要使用super这个关键字，它显式地指出子类可以直接访问父类中的某些部分，尽管有时这种访问会因为种种原因被屏蔽了的方法在其父类中的原始代码。

Super在构造函数的使用中是非常重要的，和方法不同，构造函数是不能继承的；因此super是访问父类中构造函数的惟一途径。在子类的构造函数中，使用super(...)和适当的参数表可以触发对父类构造函数的一个调用，如果父类没有相应的构造函数，编译器会报错，这就是每个实例实现的初始化的过程链。实例先把自己作为一个Object实例进行初始化，然后从它的直接子类开始按照继承链依次调用构造函数直到最后将与当前类直接相关的内容初始化完毕。

举例说明：

例一、

class Base...{Base()...{

System.out.println("Base");

}

}

public class Checket extends Base...{ Checket()...{

System.out.println("Checket");

super();

} public static void main(String argv[])...{

Checket c = new Checket();

// super();

}

}

A．Compile time error

B．Checket followed by Base

C．Base followed by Checket

D．runtime error

解析：这是一个考查super构造函数的面试例题。子类的构造函数如果要引用super的话，必须把super放在函数的首位，不然会出现这样的报错：

Checket.java:10: call to super must be first statement in constructor

super();

如果一定要引用super构造函数，则必须把super()放在前面，代码如下。

class Base...{Base()...{

System.out.println("Base");

}}

public class Checket extends Base...{ Checket()...{

super();

System.out.println("Checket");

} public static void main(String argv[])...{

Checket c = new Checket();

// super();

}

}

例二、[]里在类中用super调用父类构造函数时，为什么调用语句必须是子类的第一条语句？

答案：如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法。那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。如下面的程序所示。

class Father

...{

public Father()

...{String name=null;

int age=0;}

}

class Son extends Father

...{

public Son()

...{String name="学生";

super();

}

}

扩展知识（Java中的super类）

在Java中， 有时还会遇到子类中的成员变量或方法与超类（有时也称父类）中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或 方法就隐藏了超类的成员变量或方法，但是我们如果想要使用超类中的这个成员变量或方法，就需要用到super。请看下面的类。

class Country

...{

String name;

void value()

...{

name="China";

}

}

在下面的子类中，子类的成员变量和方法隐藏了超类的成员变量name和方法value()。

class City extends Country

String name;

void value()

...{

name="Hefei";

super.value();

System.out.println(name);

System.out.println(super.name);

}

为了在子类中引用超类中的成员变量name和方法value()，在代码中使用了super、super.name和super.value()，所以显示的结果为：

Hefei

China

如果想要使用超类的构造函数，则应当使用super(参数列表)的形式

面试例题3：给定下面的代码，哪个选项在替代"//Here"后可以被编译并且改变变量oak的值？

class Base...{

static int oak=99;

}

public class Doverdale extends Base...{

public static void main(String argv[])...{

Doverdale d = new Doverdale();

d.amethod();

}

public void amethod()...{

//Here

}

}

A．super.oak=1;

B．oak=33;

C．Base.oak=22;

D．oak=50.1;

解析：因为变量oak被声明是静态的，如果它存在只能有一个本体，则它可以通过本类的名字或者通过定义本类的任何一个实例被改变。

答案：A、B、C

面试例题4：当编译和运行下列代码时会发生下列哪种情况？

class Base...{

Base()...{

System.out.println("Base");

}

}

public class Checket extends Base...{

public static void main(String argv[])...{

Checket c = new Checket();

super();

}

Checket()...{

System.out.println("Checket");

}

}

A．Compile time error

B．Checket followed by Base

C．Base followed by Checket

D．runtime error

解析：

用Sun的JDK运行会出现下列出错信息。

"Only constructors can invoke constructors"

Checket作为一个构造方法应该在调用时从最老的祖先类开始向下调用，调用super会引起程序在编译和运行时间上的错误。

Java中的关键字super：调用父类的属性，一个类中如果有int x属性，如果其子类中也定义了int x属性的话，在子类中调用父类的x属性时应用super.x＝6，表示该x是引用的父类的属性，而要表示子类中的x属性的话，使用this.x。

this和super：在Java中，this通常指当前对象，super则指父类的对象。若想要引用当前对象的某种东西，比如当前对象的某个方法，或当 前对象的某个成员，便可以利用this来实现这个目的。当然，this的另一个用途是调用当前对象的另一个构造函数。如果想引用父类的某种东西，则非 super莫属。

Java里在子类中用super调用父类构造函数时，调用函数必须放在子类的第一条语句的位置，如果想用super继承父类构造的方法，但是没有放在第一 行的话，那么在super之前的语句，也许是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法，以前所做的修改就都回到以前 了，也就是说又成了父类的构造方法了。

是什么意思？'>JAVA 中的 -> 是什么意思？

“-”是Java 8新增的Lambda表达式中，变量和临时代码块的分隔符，即：

(变量)-{代码块}

如果代码块只有一个表达式，大括号可以省略。如果变量类型可以自动推断出来，可以不写变量类型。

网站题目：java代码块继承 java 构造代码块
本文来源：http://azwzsj.com/article/ddsegcp.html