当前位置：首页 » 编程语言 » superjava的用法

superjava的用法

发布时间: 2021-03-24 21:35:31

① java中super的用法

super．属性，即可在子类函数中访问到父类的属性．super.方法，可在子类函数中访问到父类的方法(一般用于访问父类被覆盖的方法)．
a.f()调用子类的f(),
super.n=n,把子类的n(值为100)赋给父类
ax(写v我觉得会被屏蔽－－）=super.f()/n.调父类的f(),即0加到100,5050，再除以100，不就是50.5了吗

② java中super的用法

class A{
protected float f;
private int k;

public A(){
}

public A(float f) {
this.f = f;
}

/**
* Getter for property k
* @param the k to get
*/
public int getK() {
return k;
}

/**
* Setter for property k
* @param k the k to set
*/
public void setK(int k) {
this.k = k;
}

}

class B extends A{
public boolean b;

public B(float floatValue, boolean flag){
super.f = floatValue;
this.b = flag;
}
}

public class Applet1{
private int n = 123;
private B x;

public static void main(String args[]){
Applet1 applet = new Applet1();
applet.x = new B(68.963f, true);
applet.x.setK(66);

System.out.println("In x, the value is: ");
System.out.println("f: " + applet.x.f);
System.out.println("k: " + applet.x.getK());
System.out.println("b: " + applet.x.b);
System.out.println("n: " + applet.n);

}

}

------------------
In x, the value is:
f: 68.963
k: 66
b: true
n: 123

③ JAVA super的用法

当在子类的构造函数需要调用父类的构造函数时，实用super（），调用，当然super（）,里面可以加形参（根据具体的父类的构造函数是否需要形参），这条语句必须写在子类构造函数的第一句

④ java中super 的两种用法

Java中this、super用法简谈
广告插画创意动漫 Logo 包装绘画鼠绘 3D 时尚卡通网站 CG 艺术摄影

--------------------------------------------------------------------------------

来源：作者： 2006-07-28 出处：巧巧读书

效果 os java c语言

通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。
好了，现在开始讨论this&super这两个关键字的意义和用法。
在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。
在一般方法中
最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法：
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name);
//你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的
setAge(age);
this.print(); br> }
public void setName(String name){
this.name=name;//此处必须指明你要引用成员变量
}
public void etAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" ge="+age);
//在此行中并不需要用this，因为没有会导致混淆的东西
}
public static void main(String[] args){
DemoThis dt=new DemoThis("Kevin","22");
这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(),你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super的用法。
class Person{
public int c;
private String name;
private int age;
protected void setName(String name){
this.name=name;
}
protected void setAge(int age){
this.age=age;
}
protected void print(){
System.out.println("Name="+name+" Age="+age);
}
}
public class DemoSuper extends Person{
public void print(){
System.out.println("DemoSuper:");
super.print();
}
public static void main(String[] args){
DemoSuper ds=new DemoSuper();
ds.setName("kevin");
ds.setAge(22);
ds.print();
}
}
在DemoSuper中，重新定义的print方法覆写了父类的print方法，它首先做一些自己的事情，然后调用父类的那个被覆写了的方法。输出结果说明了这一点：
DemoSuper:
Name=kevin Age=22

这样的使用方法是比较常用的。另外如果父类的成员可以被子类访问，那你可以像使用this一样使用它，用“super.父类中的成员名”的方式，但常常你并不是这样来访问父类中的成员名的。
在构造函数中构造函数是一种特殊的方法，在对象初始化的时候自动调用。在构造函数中，this和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);
}
}
在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟
上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的
构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在
Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你
可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它
是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道
了。
最后，写了这么多，如果你能对“this通常指代当前对象，super通常指代父类”这句话牢记在
心，那么本篇便达到了目的，其它的你自会在以后的编程实践当中慢慢体会、掌握。另外关于本
篇中提到的继承，请参阅相关Java教程。

⑤ java 中super的用法

super调用的是被继承的类的方法，就是父类的方法。

⑥ java中“super”的用法及意义是

java中的super指的就是父类（super class）
例：B继承A
A类
class A {
private String astr;
private String bstr;
public A(string astr, string bstr) {
this.astr = astr; //this指的是本类，在这里就是A
this.bstr = bstr;
}

public String getAstr() {
return this.astr;
}

public String getBstr() {
return this.bstr;
}
}

B类
class B extends A {
private String aa;
private String bb;

public B(String aa, String bb) {
super(aa, bb); //这里就调用了父类的构造方法，给父类的super.astr,super.bstr（super.astr也就是父类的astr变量，super.bstr同理)两个变量赋值了，而不是给this.aa,this.bb（this.aa可以理解为本类的aa变量，this.bb同理）赋值
// this.aa = aa;
// this.bb = bb;
}

puplic String getAA() {
return this.aa;
}

public String getBB() {
return this.bb;
}
}

测试类
public class Test {
public static void main(String[] args) {
B b = new B("aabb", "ccdd"); // 调用B的构造方法，给super.astr,super.bstr赋值了
System.out.println(b.getAa()); // null 没有被赋值
System.out.println(b.getBb()); // null
System.out.println(b.getAstr()); // aabb 调用父类的方法，返回super.astr的值
System.out.println(b.getAstr()); // ccdd 调用父类的方法，返回super.bstr的值
}
}

⑦ JAVA中super（）的用法

第一：可用来在子类构造函数中调用父类的构造函数，且必须是第一句
如：
class aa()
{
aa();
aa(int a,int b);
}
class b extend aa
{
b()
{super();}
b(int a,int b){super(a,b);}
}
第二：可用来调用子类隐藏的父类方法或变量
如：
class a
{ int a;
int fa();
}
class b extends a
{int a;
int fa();
int fb(int c,int d)
{ super.a=c; //次变量a为父类中的a
a=d; //次变量为子类中的定义的a
super.fa();
}
}

⑧ java中super的使用有哪三种情况

1.子类的构造函数如果要引用super的话，必须把super放在函数的首位.

classBase{
Base(){
System.out.println("Base");
}
}

publicclassChecketextendsBase{
Checket(){
super();//调用父类的构造方法，一定要放在方法的首个语句
System.out.println("Checket");
}

publicstaticvoidmain(Stringargv[]){
Checketc=newChecket();
}
}

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

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

classCountry{
Stringname;

voidvalue(){
name="China";
}
}

classCityextendsCountry{
Stringname;

voidvalue(){
name="Hefei";
super.value();//不调用此方法时，super.name返回的是父类的成员变量的值null
System.out.println(name);
System.out.println(super.name);
}

publicstaticvoidmain(String[]args){
Cityc=newCity();
c.value();
}
}

为了在子类中引用父类中的成员变量name和方法value()，在代码中使用了super、super.name和super.value(),若不调用super.value()时，super.name返回父类成员变量默认值null,调用此方法时，super.value()方法把成员变量name赋值为China,再利用super.name调用父类的成员变量的值。

另外，要注意的是super.name调用的是成员变量的值，

classCountry{
Stringname="xianfan";

Stringvalue(Stringname){
name="China";
returnname;
}
}

classCityextendsCountry{
Stringname;

Stringvalue(Stringname){
name="Hefei";
super.value("失败");//不调用此方法时，super.name返回的是父类的成员变量的值null
System.out.println(name);
System.out.println(super.name);
returnname;
}

publicstaticvoidmain(String[]args){
Cityc=newCity();
c.value("成功");
}
}

结果为：Hefei
xianfan
此时，super.name返回的值是父类成员变量的值xianfan,而此时的super.value()方法是不起作用的。

3．用super直接传递参数：

classPerson{
publicstaticvoidprt(Strings){
System.out.println(s);
}

Person(){
prt("APerson.");
}

Person(Stringname){
prt("Apersonnameis:"+name);
}
}

{
Chinese(){
super();//调用父类构造函数（1）
prt("Achinese.");//(4)
}

Chinese(Stringname){
super(name);//调用父类具有相同形参的构造函数（2）
prt("hisnameis:"+name);
}

Chinese(Stringname,intage){
this(name);//调用当前具有相同形参的构造函数（3）
prt("hisageis:"+age);
}

publicstaticvoidmain(String[]args){
Chinesecn=newChinese();
cn=newChinese("kevin");
cn=newChinese("kevin",22);
}
}

结果为：A Person.

A chinese.

A person name is:kevin

his name is:kevin

A person name is:kevin

his name is:kevin

his age is:22

在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。

⑨ SUPER()的JAVA用法

super()其实就是是调用父类的构造方法，如

public class Test
{
public Test()
{
System.out.println("this is class Test");
}
public static void main(String[] args)
{
new B();
}
}

public class B extends Test
{
public B()
{
super();
}
}

打印的结果是

this is class Test

⑩ java super的用法

super具体的说就是父类的对象，既然是父类的对象一般情况下自然可以想对象一样使用，
比如直接调用匪类的一些方法变量等（如：super.math();再如super.variable;）
而放在构造方法中的第一句调用父类的构造方法：如下：
chass Father
{
public Father()
{
}
}

chass Son extends Father
{
public Son()
{
super();//这里就是调用了父类的无参数的构造方法。它必须放在子类的构造方法的有效代码的
//第一句（重点1，放在子类的构造方法中。重点2,必须是有效代码的第一句）
System.Out.Println("第一句是掉用父类的方法，下面的就是子类的初始化了");
}
}
补充：如果要调用父类的含参数的构造方法，则子类的super();括号中就要传入相应的参数

当然还有其他的一些用法。单单一个super当时我给学生讲课的时候就是讲了2节课的，这里也不可能完全戏讲了。有不懂的再问吧。

阅读全文

superjava的用法

与superjava的用法相关的阅读推荐