下载文档原格式
super关键字super关键字super代表的是“当前对象（this）”的⽗类型特征。
super的特征1. super是⼀个关键字,全部⼩写。
2. super和this对⽐着学习。
this:this能出现在实例⽅法和构造⽅法中.this的语法是:"this."、"this ()"this不能使⽤在静态⽅法中。
**this. ** ⼤部分情况下是可以省略的。
this. 什么时候不能省略呢? 在区分局部变量和实例变量的时候不能省略public void setName ( string nane) { = name ;}this()只能出现在构造⽅法第⼀⾏，通过当前的构造⽅法去调⽤"本类"中其它的构造⽅法，⽬的是:代码复⽤。
this可以单独使⽤super:super能出现在实例⽅法和构造⽅法中.this的语法是:"super. "、"super ()"super不能使⽤在静态⽅法中。
super. ⼤部分情况下是可以省略的。
super. 什么时候不能省略呢? ⽗类和⼦类有同名属性时，你想在⼦类调⽤⽗类的那个属性，这个时候“super.”是不可以省略的。
super()只能出现在构造⽅法第⼀⾏，通过当前的构造⽅法去调⽤"⽗类"中其它的构造⽅法，⽬的是:在创建⼦类对象的时候，先初始化⽗类型特征。
super不能单独使⽤，否则编译会报错！要么"super."要么"super()",由此可以得出，super不是引⽤，不存内存地址，也不指向任何对象，3. super ()表⽰通过⼦类的构造⽅法调⽤⽗类的构造⽅法。
模拟现实世界中的这种场景:要想有⼉⼦，需要先有⽗亲。
4. 重要的结论当⼀个构造⽅法第⼀⾏：既没有this()有没有super()，默认会有⼀个super()，表⽰通过当前⼦类的构造⽅法调⽤⽗类的⽆参数构造⽅法。
班级：姓名：学号：《JAVA程序设计》试题1一、单项选择填空（每小题2分，共50分）1.下列有关Java语言的叙述中，正确的是（B）A、Java是不区分大小写的B、源文件名与public权限的类名必须相同C、源文件名其扩展名为.jarD、源文件中public类的数目不限2.在Java中，负责对字节代码解释执行的是（B）。
字节就是class 文件A、垃圾回收器B、虚拟机C、编译器D、多线程机制3.在Java程序设计中，由Java编译器默认导入的包是（D）A、java.appletB、java.awtC、java.util 输入语言D、ng4.编译Java application源程序文件将产生相应的字节码文件，这些字节文件的扩展名为（B）A、.javaB、.classC、.htmlD、.exe5.在Java中，用package语句定义一个包时，该包的层次结构即是（b）A、与文件的结构相同B、与文件目录的层次相同C、与文件类型相同D、与文件大小相同6.有时在程序设计中采用分治算法而选择递归，“递归”的基本思想是（c）A、“让别人反复调用自己”B、“自己反复调用别人”C、“自己反复调用自己”D、以上说法都不对7.main方法是Java Application程序执行的入口，含有main方法的类是主类，且main方法的定义是唯一的，以下哪项是正确的（b）A、public static void main（）B、public static void main(String args[ ])C、public static int main(String arg[])D、public void main(String arg[])8.按照Java的标识符的行业命名规范，下列分别表示一个类和一个方法的标识符比较合适的是（b）A、Helloworld,GetSwimmingScoreB、HelloWorld,getSwimmingScoreC、helloworld,getswimmingscoreD、helloWorld,Getswimmingscore9.以下程序的运行结果为（d）public class IfTest{public static void main(String args[]){int x=3;{int y=1;}if(x==y)System.out.println(“equal”);elseSystem.out.println(“Not Equal”);}}A、Not equalB、EqualC、无输出D、编译出错，找不到y10.下列说法不正确的是（c）A、IOException必须被捕获或抛出B、java语言不自动初始化变量的值C、java语言不允许同时继承一个类并实现一个接口D、java语言会自动回收内存中的垃圾11.在Java中，所有类的根类是（a）A、ng.ObjectB、ng.ClassC、java.applet.AppletD、java.swing.Jframe12.下列方法中可以用来创建一个新线程的是（b）A、实现ng.Runnable接口并重写start()方法B、实现ng.Runnable接口并重写run()方法C、实现ng.Thread接口并重写run()方法D、实现ng.Thread类并重写start()方法13.启动Applet小程序时，即调用类似于应用程序main方法的入口方法（b）A、stop()B、init()C、start()D、destroy()14.Java的字符类型采用的是Unicode编码方案，每个Unicode码占用____个比特位。
java语言super使用方法java语言super使用方法super是Java语言的保留字,用来指向类的超类.假设在T eacher类中定义了一个类变量boolean gender;在子类的方法中gender就应该是指子类的gender变量,如果要引用超类的gender变量的话就必须使用super.genderthis对象在类的构造方法中,要给对象的域进行初始化,这时如果参数和类变量同名,则类变量的`名字将会被参数名屏蔽,必须知道当前的对象名称,才能用对象名引用对象的域复制代码代码如下:public DotLoc(double XX,double YY,double ZZ){X=XX;Y=YY;Z=ZZ;}如果参数与类变量名同名复制代码代码如下:public DotLoc(double X,double Y,double Z){this.X=X;this.Y=Y;this.Z=Z;}又如：在Java类中使用super来引用基类的成分。
实例：TestInherit.java:复制代码代码如下:import java.io.* ;class FatherClass {public int value ;public void f() {value = 100 ;System.out.println("FatherClass.value=" + value) ; }}class ChildClass extends FatherClass {public int value ;public void f() {super.f() ;value = 200 ;System.out.println("ChildClass.value=" + value) ; System.out.println(value) ;System.out.println(super.value) ;}}public class TestInherit {public static void main(String args[]) { ChildClass cc = new ChildClass() ;cc.f() ;}}【java语言super使用方法】。
三．解释名词术语1.面向对象的四大特征1. 抽象：其实也是所有计算机语言的特征。
指从众多的事物中舍弃个别的、非本质的部分，提炼出计算机系统所关注的、共同的、本质的部分（属性和功能）的过程。
抽象包括过程抽象和数据抽象。
2．封装（Encapsulation）封装指属性和方法的定义都封装在类定义中，然后通过其可见性（public、protected、private）来细粒度控制外部对类成员的可访问性。
3．继承（Inheritance）继承以原有的类为基础来创建一个新的子类，子类继承父类的所有特性，并可以扩充自己的特性，从而达到代码复用的目的。
通过extends关键字继承原有类派生出子类，进而构造出更为复杂的数据类型。
继承为共享数据和操作提供了一种良好的机制，提高了软件的重用性、可用性和一致性。
4．多态（polymorphism）多态性是指程序中出现的方法或变量的“同名”现象。
多态性又被称为“一个名字，多个方法”。
四大特征：抽象、封装、继承和多态2.方法的重载（Overload）方法的重载指同一类中有相同的方法名但有不同的形式参数的语法现象。
与方法的返回值类型、方法修饰符等没有关系。
3.构造方法的重载创建对象时根据参数的不同引用不同的构造方法。
4.成员方法和成员变量的覆盖（Override）Java允许子类对父类的同名方法进行重新定义或修改。
可以用this.和super.来区分是调用父类还是子类的。
5.接口（interface）：与抽象类相似，接口中的方法只做了声明，没有定义任何具体实现的操作方法。
接口是若干完成某些特定功能的没有方法体的方法（抽象方法）和常量的集合，是一种引用数据类型。
接口中指定类做什么，而不是去解决如何做。
6.构造方法的调用与一般方法的调用不同，必须采用以下语句格式：类名对象名=new 构造方法名（[参数1][，参数2]…）；说明：如果类中没有构造方法，系统会自动调用默认的构造方法。
Java——补充：构造⽅法super（）与构造⽅法⽆参有参构造⽅法this（）与构造⽅法参考⽂章：构造⽅法在new的时候⾃动执⾏。
且只执⾏⼀次。
new⼀次执⾏⼀次每个类都有构造⽅法，即使不写也有，编译时javac会⾃动检查类是否有构造⽅法，如果有，就执⾏，没有就⾃动添加⼀个如果⽗类有含参构造⽅法，则⼦类也必须添加含参构造⽅法如果⽗类没有含参构造⽅法，⼦类⽆需添加构造⽅法this在构造⽅法之间的应⽤super在构造⽅法中的应⽤⾸先要明⽩super关键字的作⽤：1、super是调⽤⽗类的成员⽅法或成员变量。
但是还有⼀个问题：.也就是说⼦类对象中，⽗类的构造⽅法会先执⾏。
那么为什么要执⾏⽗类构造⽅法呢？假设，创建了⼀个⽗类，含有⼀个成员属性a=1;含有⼀个构造⽅法，将a=5;。
因为如果⼦类创建的对象调⽤⽗类的成员变量a时，在不添加super()时，会得到a=1;如果添加super()就会得到a=5;我们都知道，构造⽅法在创建对象时执⾏，a应该等于5，故如果不调⽤super()就会得到错误的值。
2、super()在构造⽅法中是调⽤⽗类构造⽅法的意思。
当创建⼦类对象时，⽗类对象先进内存。
这样⼦类才能⾃动拥有⽗类的成员。
3、⼦类的构造器，⽆论重载多少个，第⼀⾏必须是super（）；当你不写时表⽰空参super()；是否写参数，要根据⽗类决定，⽗类有参数，那么⼦类的super()必须有参数。
4、构造⽅法⽆法继承，⾃然也没有重写这个概念。
5、super()语句必须是构造⽅法的第⼀⾏代码。
总结⼀下：其实这些内容说⽩了，就是在说⼀句话。
super是⽗类对象引⽤，this是本类对象引⽤。
super()，this()都必须放在构造⽅法的第⼀⾏，super()和this()绝不能⼀块⽤，super(),this()⽆参时可以省略不写。
会报错：快捷键：ctrl+T ⽤于打开继承关系图。
⼦类的构造函数必须要 super() 吗？不是必须，是⾃动必须的情况：————指明调⽤哪个含参构造函数public class Father {public String name;public Father(String name) { = name;}}public class Son extends Father{public Son(String name) {super(name);//必须调⽤，否则他会默认调⽤⽗类的⽆参构造函数，⽽⽗类的⽆参构造函数已经被有参的覆盖，所以找不到}this()只能⽤在构造函数中，且它必须是第⼀⾏语句？1.在构造函数中，如果你不指定构造器之间的调⽤关系，那么编译器会给你加上super（）；⽬的是在初始化当前对象时，先保证了⽗类对象先初始化。
Java中的两个关键字——super、thisJava中的两个关键字——super、this ⼀、supersuper 是java中⽅的⼀个关键字，⽤它可以引⽤⽗类中的成员：super可⽤于访问⽗类中定义的属性super可⽤于调⽤⽗类中定义的成员⽅法super可⽤于在⼦类构造器中调⽤⽗类的构造器使⽤super关键字注意事项：1、当⼦类和⽗类都有同名的属性时，在⼦类中如果要使⽤⽗类的属性 super . 属性2、 super只能应⽤在成员⽅法和构造⽅法中，不能⽤在静态⽅法中（和this是⼀样的）3、如果在构造⽅法中使⽤必须放在第⼀⾏4、在构造⽅法中this()和super()不能同时出现super没有什么需要解释的地⽅，我们⽤代码来看看super具体的⼀些强⼤功能吧⽰例⼀、使⽤super调⽤基类的属性：public class Father { int num=20;}public class Child extends Father{ int num; public void print(){ num=10; super.num=30; System.out.println("num="+num); System.out.println("="+super.num); }}public class Test { public static void main(String[] args) { Child xm=new Child(); xm.print(); }}运⾏结果：⽰例⼆、使⽤super调⽤基类中的构造⽅法：public class Father { int num; public Father() { System.out.println("⽗类中的⽆参构造⽅法---"); } public Father(int num){ System.out.println("⽗类中的有参的构造⽅法----"+num); }}public class Child extends Father{ int num; public Child() { super(30); System.out.println("⼦类⽆参构造⽅法---"); } public Child(int num) { this.num = num; System.out.println("⼦类中的有参的构造⽅法---"+num); }}解释⼀下上⾯的这段代码：在Child类中的第⼀个构造函数⾥⾯，super(30);它会去调⽤⽗类中嗲有⼀个int型参数的构造⽅法。
This和Super的区别
⼀：this
java中this关键字的作⽤和词义很接近：
它在⽅法内部使⽤，即这个⽅法所属对象的引⽤
它在构造器内部使⽤，表⽰该构造器正在初始化的对象。
this表⽰当前对象，可以调⽤类的属性、⽅法和构造器。
注意
使⽤this()必须放在构造器的⾸⾏！
使⽤this()调⽤本类中其他的构造器，保证⾄少有⼀个构造器不是⽤this的。
⼆：super
java类中使⽤super来调⽤⽗类中的指定操作：
super可⽤于访问⽗类中定义的属性
super可⽤于调⽤⽗类中定义的成员⽅法
super可⽤于在⼦类构造⽅法中调⽤⽗类的构造器
注意
尤其当⼦⽗类出现同名成员是，可以⽤super进⾏区分。
super的追溯不仅限于直接⽗类。
super和this的⽤法相像，this代表本类对象的引⽤，super代表⽗类的内存空间的标识。
三：this和super区别
No.区别点this super
1访问属性访问本类中的属性，如果本类没有此属性则从⽗类中继续查找访问⽗类中的属性
2调⽤⽅法访问本类中的⽅法直接访问⽗类中的⽅法
3调⽤构造器调⽤本类构造器，必须放在构造器⾸⾏调⽤⽗类构造器，必须放在⼦类构造器的⾸⾏4特殊表⽰当前对象⽆。
一、super()的概念在Java编程中，super()是一个关键字，用来调用父类的构造方法。
在子类中使用super()可以调用父类的构造方法，从而实现子类继承父类的属性和方法。
super()必须作为子类构造方法的第一条语句，如果不显式调用super()，则默认调用父类的无参构造方法。
二、super()的用法1. 调用父类的构造方法当子类实例化时，会先调用父类的构造方法，可以使用super()在子类构造方法中调用父类的构造方法。
例如：```javapublic class Parent {public Parent(){System.out.println("Parent类的构造方法");}}public class Child extends Parent {public Child(){super(); //调用父类的构造方法System.out.println("Child类的构造方法");}}在上述例子中，当实例化Child类时，会先调用Parent类的构造方法，然后再调用Child类的构造方法。
2. 访问父类的属性和方法在子类中使用super关键字可以访问父类的属性和方法。
例如：```javapublic class Parent {public String name = "parent";public void sayHello(){System.out.println("Hello, I'm "+ name);}}public class Child extends Parent {public String name = "child";public void sayHello(){super.sayHello(); //调用父类的sayHello方法System.out.println("My name is "+ name);}}在上述例子中，子类可以通过super关键字访问父类的属性和方法，实现对父类的继承和扩展。
java中的this和super的作⽤和异同和C++中调⽤⽗类的构造函数这⼏天看到类在继承时会⽤到this和super，这⾥就做了⼀点总结，与各位共同交流，有错误请各位指正~thisthis是⾃⾝的⼀个对象，代表对象本⾝，可以理解为：指向对象本⾝的⼀个指针。
this的⽤法在java中⼤体可以分为3种：1.普通的直接引⽤这种就不⽤讲了，this相当于是指向当前对象本⾝。
2.形参与成员名字重名，⽤this来区分：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17class Person {private int age = 10;public Person(){System.out.println("初始化年龄："+age);}public int GetAge(int age){this.age = age;return this.age;}}public class test1 {public static void main(String[] args) {Person Harry = new Person();System.out.println("Harry's age is "+Harry.GetAge(12)); }}运⾏结果：初始化年龄：10Harry's age is 12可以看到，这⾥age是GetAge成员⽅法的形参，this.age是Person类的成员变量。
3.引⽤构造函数这个和super放在⼀起讲，见下⾯。
supersuper可以理解为是指向⾃⼰超（⽗）类对象的⼀个指针，⽽这个超类指的是离⾃⼰最近的⼀个⽗类。
super也有三种⽤法：1.普通的直接引⽤与this类似，super相当于是指向当前对象的⽗类，这样就可以⽤super.xxx来引⽤⽗类的成员。
2.⼦类中的成员变量或⽅法与⽗类中的成员变量或⽅法同名12 3 4 5 6 7 8 9 10 11 12 13class Country {String name;void value() {name = "China";}}class City extends Country {String name;void value() {name = "Shanghai";super.value(); //调⽤⽗类的⽅法 System.out.println(name);13 14 15 16 17 18 19 20 21 System.out.println(name);System.out.println();}public static void main(String[] args) { City c=new City();c.value();}}运⾏结果：ShanghaiChina可以看到，这⾥既调⽤了⽗类的⽅法，也调⽤了⽗类的变量。
在Java中，super关键字主要有两个用途：
1.引用当前对象的直接父类对象：在子类中，你可以使用super关键字来引
用父类的实例变量和方法。
这使得子类可以访问和修改父类的属性，或者调用父类的方法。
这在覆盖（override）父类方法时特别有用，当你需要在子类中执行父类的原始实现时。
2.调用父类的构造方法：在子类的构造方法中，你可以使用super关键字来
显式地调用父类的构造方法。
这是必须的，因为Java规定子类的构造方法必须首先调用父类的构造方法（如果没有显式地调用，编译器会自动插入一个默认的调用）。
下面是一个简单的例子，展示了如何在Java中使用super关键字：
在这个例子中，super.show()调用了父类Parent的show方法，而super.x引用了父类Parent的实例变量x。
Java中super和this分别在类的方法和构造方法中使用的区
别
1. 子类的构造函数如果要引用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继承父类的构造方法。
那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。
2．在Java中，有时还会遇到子类中的成员变量或方法与超类（有时也称父类）中的成员变量或方法同名。
因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了超类的成员变量或方法，但是我们如果想要使用超类中的这个成员变量或方法，就需要用到super.
复制代码代码如下:
class Country {String name; void value() {name = "China";}} class City extends Country {String name; void value() {name = "Hefei";super.value();//不调用此方法时，
返回的是父类的成员变量的值
nullSystem.out.println(name);System.out.println(super.na me);} public static void main(String[] args) {City c=new
City();c.value();}}
为了在子类中引用父类中的成员变量name和方法value()，在代码中使用了super、和super.value(),若不
调用super.value()时，返回父类成员变量默认
值null,调用此方法时，super.value()方法把成员变量name
赋值为China,再利用调用父类的成员变量的值。
另外，要注意的是调用的是成员变量的值，
复制代码代码如下:
class Country {String name="xianfan"; String value(String name) {name = "China";return name;}} class City extends Country {String name; String value(String name) {name = "Hefei";super.value("失败");//不调用此方法时， 返回的是父类的成员变量的值
nullSystem.out.println(name);System.out.println(super.na me);return name;} public static void main(String[] args) {City c=new City();c.value("成功");}}
结果为：Hefeixianfan此时，返回的值是父类成员变量的值xianfan,而此时的super.value()方法是不起作用的。
3．用super直接传递参数：
复制代码代码如下:
class Person {public static void prt(String s)
{System.out.println(s);} Person() {prt("A Person.");} Person(String name) {prt("A person name is:" + name);}} public class Chinese extends Person {Chinese() {super(); // 调用父类构造函数（1）prt("A chinese.");// (4)} Chinese(String name) {super(name);// 调用父类具有相同形参的构造函数（2）prt("his name is:" + name);} Chinese(String name, int age) {this(name);// 调用当前具有相同形参的构造函数（3）prt("his age is:" + age);} public static void main(String[] args) {Chinese cn = new Chinese();cn = new Chinese("kevin");cn = new
Chinese("kevin", 22);}}
结果为：A Person.A chinese.A person name is:kevinhis name is:kevinA person name is:kevinhis name is:kevinhis age is:22在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。
super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。
this后加参
数则调用的是当前具有相同参数的构造函数，如3处。
当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正
确运行。
但这样似乎就有点画蛇添足的味道了。
4．super
和this的异同：1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
3)super: 它引用当前对象的直接父类中的成员（用来访问
直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名super.成员函数
据名（实参）4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）5）调用super()必须写在子类构造方法的第一行，否则编译不通过。
每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
6）super()和this()类似,区别是，super()从
子类中调用父类的构造方法，this()在同一类内调用其它方法。
7）super()和this()均需放在构造方法内第一行。
8）尽管可
以用this调用一个构造器，但却不能调用两个。
9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
10）this()和super()都指的是对象，所以，均不可以在static环境中使用。
包括：static变量,static方法，static语句块。
11）从本质上讲，this 是一个指向本对象的指针, 然而super是一个Java关键字。
