當前位置：首頁 » 編程語言 » 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的用法相關的閱讀推薦