javathis什麼時候用
1. 在java中什麼時候用this，什麼時候用super
定義類的時候對本類對象和方法的引用this
this.^^^表示的是引用當前類的對象和方法,其中^^^表示當前類的對象名和方法名
而super是引用父類的對象和方法
super.^^^表示的是引用當前類的父類的對象和方法,其中^^^表示當前類的父類的對象名和方法名
2. Java中怎麼使用this關鍵字,和在什麼時候可以使用.內容越詳細越好.我在這里先謝過了......
請看下面的這段文字，你看懂了這個文章，也就理解this了。。。。這是我空間收藏的文章，拜讀之後，受益匪淺。。。。=======================================================在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();
}
public void setName(String name){
this.name=name;//此處必須指明你要引用成員變數
}
public void setAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" Age="+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教程。
3. java中this的用法
1. this指當前對象。
當在一個類中要明確指出使用對象變數或函數時加上this引用。如下面例子中:
public class Hello {
String s = "Hello";
public Hello(String s){
System.out.println("s = " + s);
System.out.println("1 -> this.s = " + this.s);
this.s = s;
System.out.println("2 -> this.s = " + this.s);
}
public static void main(String[] args) {
Hello x=new Hello("HelloWorld!");
}
}
運行結果：
s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!
在這個例子中，構造函數Hello中，參數s與類Hello的變數s同名，這時直接對s進行操作則是對參數s進行操作。對類Hello的成員變數s進行操作就應該用this進行引用。運行結果的第一行就是直接對構造函數中傳遞過來的參數s進行列印結果；
第二行是對成員變數s的列印；第三行是先對成員變數s賦傳過來的參數s值後再列印，所以結果是HelloWorld!
2. this作為參數傳遞
當你要把自己作為參數傳遞給別的對象時如：
public class A {
public A() {
new B(this).print();
}
public void print() {
System.out.println("Hello from A!");
}
}
public class B {
A a;
public B(A a) {
this.a = a;
}
public void print() {
a.print();
System.out.println("Hello from B!");
}
}
運行結果：
Hello from A!
Hello from B!
在這個例子中，對象A的構造函數中，new
B(this)把對象A作為參數傳遞給了對象B的構造函數。
4. java中this的作用及用法在什麼情況下需要用this
使用this調用本類中的屬性
現在觀察以下代碼，看會有那些問題：
public void setName(String name){
name = name ;
}
這裡面的兩個name都是setName方法中的name參數。
此時，特別希望可以通過一個指定的標識明確的表示要把傳入的name參數的值給類中的屬性，所以此時就需要使用this關鍵字，使用this.name就表示類中的屬性。
class Person{
private String name ;
private int age ;
public Person(String name,int age){
this.setName(name) ;
this.setAge(age) ;
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
public void print(){
System.out.println("姓名："+this.name+"，年齡："+this.age) ;
}
};
public class Demo35{
public static void main(String args[]){
Person p1 = new Person("張三",30) ;
p1.print() ;
}
};
使用this還可以從一個構造方法中調用其他構造方法。
例如：有以下一個要求，一個類中存在了三個構造方法，但是要求，不管怎麼調用，最終都要求可以在對象實例化的時候列印一個「新的對象產生了」的提示。
class Person{
private String name ;
private int age ;
public Person(){
System.out.println("新的對象產生了。。。") ;
}
public Person(String name){
System.out.println("新的對象產生了。。。") ;
this.setName(name) ;
}
public Person(String name,int age){
System.out.println("新的對象產生了。。。") ;
this.setName(name) ;
this.setAge(age) ;
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
public void print(){
System.out.println("姓名："+this.name+"，年齡："+this.age) ;
}
};
以上代碼雖然可以實現功能，但是同樣的代碼出現了三次，而且後面的兩次出現純屬多餘吧。用this()的形式可以調用類中的無參構造方法。
class Person{
private String name ;
private int age ;
public Person(){
System.out.println("新的對象產生了。。。") ;
}
public Person(String name){
// 最終都是調用無參構造方法
this() ;
this.setName(name) ;
}
public Person(String name,int age){
this(name) ;
this.setAge(age) ;
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
public void print(){
System.out.println("姓名："+this.name+"，年齡："+this.age) ;
}
};
public class Demo36{
public static void main(String args[]){
Person p1 = new Person("張三",30) ;
p1.print() ;
}
};
注意點1：
如果使用了this調用其他構造方法，則此語句，必須寫在構造方法的首行。
public void fun(){
// 發現在調用fun方法的時候，必須先設置name的值
this("zhangsan") ;
}
public Person(String name,int age){
this.setAge(age) ;
this(name) ; //--> 必須放在首行
}
注意點2：
使用this可以調用本類中的其他構造方法，但是至少留一個構造方法，作為程序的出口。
public Person(){
this("a",10) ;
System.out.println("新的對象產生了。。。") ;
}
public Person(String name){
// 最終都是調用無參構造方法
this() ;
this.setName(name) ;
}
public Person(String name,int age){
this(name) ; //--> 必須放在首行
this.setAge(age) ;
}
this最重要的特性 —— 表示當前對象
當前對象在程序中用以下形式體現：
· 當前操作此方法的對象，就稱為當前對象。
class Demo{
public void print(){
System.out.println(this) ;
}
};
public class Demo38{
public static void main(String args[]){
Demo d1 = new Demo() ;
System.out.println(d1) ;
d1.print() ;
System.out.println("---------------------") ;
Demo d2 = new Demo() ;
System.out.println(d2) ;
d2.print() ;
}
};
回顧：
之前講解的兩個對象比較的程序。
// 在類的內部增加一個比較的方法
public boolean compare(Person p){
Person p1 = this ;
Person p2 = p ;
if(p1.name.equals(p2.name)&&p1.age==p2.age){
return true ;
}else{
return false ;
}
}
分析程序的運行過程：
class A{
private B b = null ;
public A(){
this.b = new B(this) ;
this.b.fun() ;
}
public void hello(){
System.out.println("Hello World!!!") ;
}
};
class B{
private A a = null ;
public B(A a){
this.a = a ;
}
public void fun(){
this.a.hello() ;
}
};
public class OODemo40{
public static void main(String args[]){
A aa = new A() ;
}
};
5. java編程中，何時要用到"this"這個語句
如果你在一個類中定義了多個方法的話，比如A、B、C、D方法，你在D方法體用到了A方法的話，就可以用this. this就是本類（自己），所以，自己調用自己的方法用this
6. JAVA this關鍵字在什麼時候必須使用或者說在什麼情況下使用它會更方便
this代表當前對象，不是說用了方便，而是為了區分
比如構造函數
classTest
{
privatestringname;
publicTest(stringname)
{
//這種情況下怎麼區分用哪個name呢？
//this.name代表當前Test對象的成員name
//而直接寫name則代表參數中的name
this.name=name;
}
}
7. java 中this具體什麼時候能用,用了又代表什麼
this用在類內部，表示類實例本身。
this 關鍵字是類內部當中對自己的一個引用，可以方便類中方法訪問自己的屬性。
舉例：
publicclassA{
privateinta;//定義一個成員變數a
publicvoidshow(inta){
this.a=2;//通過this表示訪問的是類A中的屬性a
}
}
8. Java中怎麼使用this關鍵字什麼時候可以使用
當你想要引用當前對象的某種東西，比如當前對象的某個方法，或當前對象的某個成員，你便可以利用this來實現這個目的。
比如說吃飯這個方法它是由上帝來定義的，世界上所有的人來執行。吃飯這個行為發生的時候，主體就是在吃飯的這個人，也就是要有人執行吃飯這個行為。 有時候我們需要在一個行為（方法）里，能明確知道這個行為是誰來執行的，確切的說就是我要知道誰在吃飯。
function eatSomthing() { this.eat }
在編程語言裡面每一個定義的方法里，都會有一個this關鍵字，這個this關鍵不是由在那兒定義來決定的，而是由誰來執行的決定的。這是判斷this關鍵。
his表示的對像，是這個方法活動的"上下文"。所謂的"上下文"，也就是表示當前的這些代碼的活動范圍，當前的活動（代碼的執行）在那個對像上的發生的意思。
吃飯這個活動，是在張三這個對像上發生的，則張三是吃飯的下下文。在body里去查找的div元素，則body是這個查找活動的上下文。那這個this，就是這個方法運行活動的范圍了。
方法里this當前這個方法運行的上下文，但上下文不僅限於是this(就是整體與個體的區別)。
9. java 中 .this有什麼用
Student.this是一個Student實例的引用，並沒有進行初始化，正確的說，他早已進行了初始化。
Student.this的應用與this不太一樣。
舉個.this的應用例子：
import java.applet.Applet;
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class MyApplet extends Applet{
public void init(){
Button b=new Button("print");
b.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
MyApplet.this.print(e);
/*！！看到吧，想要調用print()，就可以這樣。
我的例子還不太到位，因為直接print(e);也可以。
但是假如ActionEvent也有print方法，而我想掉用MyApplet的print就可以這樣用；還有假如我需要調用一個方法為print(MyApplet m);，他需要將MyApplet實例作為參數傳進去，也可以這樣用print(MyApplet.this);。
*/
}
});
setLayout(new BorderLayout());
add(b,"Center");
}
public void print(ActionEvent e){
this.showStatus(String.valueOf(e.getWhen()));
}
}
也就是說.this應用於同一文件內的類或內部類或匿名內部類，一般是不需要這樣用的。
說了這么多不知道你明白了嗎，這個用法不常用，不明白也不是很礙事，到了必須要用他的時候自然會了解。
10. java中this的用法
1、this指向當前類的對象，也就是TwoListen類的對象。由於MouseMotionListener,MouseListener 都是介面，因此
f.addMouseMotionListener(this);//(************************)
f.addMouseListener(this); //(************************)
中分別需要一個實現了MouseMotionListener和MouseListener介面的類的實例。
在本例子中 TwoListen類都實現了這兩個介面，因此可以用本類的實例來做參數。或者新建一個實現了這兩個介面的類，再用這個類的實例做參數。
2、在該例子中，this指向生成的two對象。為什麼用two替換後就不能運行了呢?
因為two是在main方法中定義的，是局部變數；而在go方法中並不能訪問其他方法中定義的局部變數。
如果把two定義為全局變數，如：
static TwoListen two;
再在main方法中定義：
two=new TwoListen();
這時就可以用two代替this了