Ⅰ java 中this關鍵字的作用,求詳細的解答
this 關鍵字只能在方法內部使用,表示"對調用方法的那個對象"的引用.this的用法和其他對象的引用並無不同.但要注意,如果在方法內部調用同一個類的另一個方法,就不必使用this,直接調用即可.當前方法中的this應用會自動應用於同一類中的其他方法.
this關鍵字對於將當前對象傳遞給其他方法很有用.
可用this關鍵字在一個構造器中引用另一個構造器,避免代碼重復.
Ⅱ Java Eclipse 中 在類與方法調用中 （this）的用法
this表示類實例本身。
this的用法
1、表示對當前對象的引用！
public class A{
public A getA(){
return this;//表示獲取當前實例本身
}
}
2、表示類的成員變數，而非函數參數，注意在函數參數和成員變數同名是進行區分！
public class A{
privateint a = 0;//位置1
public A getA(int a){
this.a = a;//前面this.a表示 位置1 的a，賦值=號右側的表示參數a
}
}
3、用於在構造方法中引用滿足指定參數類型的構造器。
public class A{
public A(int a){
}
public A(){
this(1);//這里調用自身的構造函數public A(int a){
}
}
Ⅲ java 中this的使用方法怎麼用盡可能詳細！ 謝謝！
this代表本類，比如你寫了一個類Dog，在本類中this就代表Dog。this在某些情況下可以讓變數變得明顯，當外來變數和本類變數名稱相同時，我們要利用this來區分。
public class Dog{
public String name;
public Dog(String name){
this.name = name;
}
}
很多人寫程序的時候在類中定義了全局變數，然後用到的地方就加this.這樣很清晰。
當然，如果本類中調用其他類的方法，該方法可以把這個類傳過去，比如：
Man man = new Man();
man.parseDog(this);
只要本類有得方法和屬性，我們就可以this.一般情況下我們都省略，默認是本類的。
Ⅳ java中關鍵字 this 和super的作用及用法
Java關鍵字this、super使用總結
一、this
Java關鍵字this只能用於方法方法體內。當一個對象創建後，Java虛擬機（JVM）就會給這個對象分配一個引用自身的指針，這個指針的名字就是this。因此，this只能在類中的非靜態方法中使用，靜態方法和靜態的代碼塊中絕對不能出現this，這在「Java關鍵字static、final使用總結」一文中給出了明確解釋。並且this只和特定的對象關聯，而不和類關聯，同一個類的不同對象有不同的this。下面給出一個使用this的綜合實例，以便說明問題：
package org.leimin;
public class Test6 {
private int number;
private String username;
private String password;
private int x = 100;
public Test6(int n) {
number = n; // 這個還可以寫為: this.number=n;
}
public Test6(int i, String username, String password) {
// 成員變數和參數同名,成員變數被屏蔽,用"this.成員變數"的方式訪問成員變數.
this.username = username;
this.password = password;
}
// 默認不帶參數的構造方法
public Test6() {
this(0, "未知", "空"); // 通過this調用另一個構造方法
}
public Test6(String name) {
this(1, name, "空"); // 通過this調用另一個構造方法
}
public static void main(String args[]) {
Test6 t1 = new Test6();
Test6 t2 = new Test6("遊客");
t1.outinfo(t1);
t2.outinfo(t2);
}
private void outinfo(Test6 t) {
System.out.println("-----------");
System.out.println(t.number);
System.out.println(t.username);
System.out.println(t.password);
f(); // 這個可以寫為: this.f();
}
private void f() {
// 局部變數與成員變數同名,成員變數被屏蔽,用"this.成員變數"的方式訪問成員變數.
int x;
x = this.x++;
System.out.println(x);
System.out.println(this.x);
}
//返回當前實例的引用
private Test6 getSelf() {
return this;
}
}
運行結果如下：
-----------
0
未知
空
100
101
-----------
0
遊客
空
100
101
通過上面的例子，說明在什麼情況下需要用到this：
第一、通過this調用另一個構造方法，用發是this(參數列表)，這個僅僅在類的構造方法中，別的地方不能這么用。
第二、函數參數或者函數中的局部變數和成員變數同名的情況下，成員變數被屏蔽，此時要訪問成員變數則需要用「this.成員變數名」的方式來引用成員變數。當然，在沒有同名的情況下，可以直接用成員變數的名字，而不用this，用了也不為錯，呵呵。
第三、在函數中，需要引用該函所屬類的當前對象時候，直接用this。
其實這些用法總結都是從對「this是指向對象本身的一個指針」這句話的更深入的理解而來的，死記不然容易忘記而且容易搞錯，要理解！
二、super
super關鍵和this作用類似，是被屏蔽的成員變數或者成員方法或變為可見，或者說用來引用被屏蔽的成員變數和成員成員方法。
不過super是用在子類中，目的是訪問直接父類中被屏蔽的成員，注意是直接父類（就是類之上最近的超類）。下面是一個綜合運用super的例子，有兩個類：一個Father類，一個Father類的子類Son，通過這兩個類完全演示了super的用法，一下是代碼：
package org.leimin;
public class Father {
public String v="Father";
public String x="輸出了Father類的public成員變數x!!!";
public Father() {
System.out.println("Father構造方法被調用!");
}
public Father(String v){
this.v="Father類的帶參數構造方法!運行了.";
}
public void outinfo(){
System.out.println("Father的outinfo方法被調用");
}
public static void main(String[] args) {
// TODO 自動生成方法存根
}
}
package org.leimin;
public class Son extends Father{
public String v="Son";
public Son() {
super(); //調用超類的構造方法,只能放到第一行.
System.out.println("Son無參數構造方法被調用!");
//super(); //錯誤的,必須放到構造方法體的最前面.
}
public Son(String str){
super(str);
System.out.println("Son帶參數構造方法被調用!");
}
//覆蓋了超類成員方法outinfo()
public void outinfo(){
System.out.println("Son的outinfo()方法被調用");
}
public void test(){
String v="哈哈哈哈!"; //局部變數v覆蓋了成員變數v和超類變數v
System.out.println("------1-----");
System.out.println(v); //輸出局部變數v
System.out.println(this.v); //輸出(子類)成員變數v
System.out.println(super.v); //輸出超類成員變數v
System.out.println("------2-----");
System.out.println(x); //輸出超類成員變數v,子類繼承而來
System.out.println(super.x); //輸出超類成員變數v
System.out.println("------3-----");
outinfo(); //調用子類的outinfo()方法
this.outinfo(); //調用子類的outinfo()方法
super.outinfo(); //調用父類的outinfo()方法
}
public static void main(String[] args) {
new Son().test();
}
}
子類Son運行結果：
Father構造方法被調用!
Son無參數構造方法被調用!
------1-----
哈哈哈哈!
Son
Father
------2-----
輸出了Father類的public成員變數x!!!
輸出了Father類的public成員變數x!!!
------3-----
Son的outinfo()方法被調用
Son的outinfo()方法被調用
Father的outinfo方法被調用
說明：次例子僅僅為了說明super的用法，實際在設計類的時候一般都盡可能私有(private)化。
通過上面的例子，下面總結一下super的用法：
第一、在子類構造方法中要調用父類的構造方法，用「super(參數列表)」的方式調用，參數不是必須的。同時還要注意的一點是：「super(參數列表)」這條語句只能用在子類構造方法體中的第一行。
第二、當子類方法中的局部變數或者子類的成員變數與父類成員變數同名時，也就是子類局部變數覆蓋父類成員變數時，用「super.成員變數名」來引用父類成員變數。當然，如果父類的成員變數沒有被覆蓋，也可以用「super.成員變數名」來引用父類成員變數，不過這是不必要的。
第三、當子類的成員方法覆蓋了父類的成員方法時，也就是子類和父類有完全相同的方法定義（但方法體可以不同），此時，用「super.方法名(參數列表)」的方式訪問父類的方法。
Ⅳ java中「this」的用法是什麼
一、指自己所在的對象。
比如在一個方法中，調用其他對象的變數或方法時，可以使用那個對象的對象名，比如aa.abc();
而調用自己所在對象的方法或變數時，不知道別人給起了什麼名，所以直接用this.abc()就可以了。
二、看一個小例子中「this」的用法！
/**
* @author feng-neusoft
*
* 本示例為了說明this的三種用法！
*/
package test;
public class ThisTest {
private int i=0;
//第一個構造器：有一個int型形參
ThisTest(int i){
this.i=i+1;//此時this表示引用成員變數i，而非函數參數i
System.out.println("Int constructor i——this.i: "+i+"——"+this.i);
System.out.println("i-1:"+(i-1)+"this.i+1:"+(this.i+1));
//從兩個輸出結果充分證明了i和this.i是不一樣的！
}
// 第二個構造器：有一個String型形參
ThisTest(String s){
System.out.println("String constructor: "+s);
}
// 第三個構造器：有一個int型形參和一個String型形參
ThisTest(int i,String s){
this(s);//this調用第二個構造器
//this(i);
/*此處不能用，因為其他任何方法都不能調用構造器，只有構造方法能調用他。
但是必須注意：就算是構造方法調用構造器，也必須為於其第一行，構造方法也只能調
用一個且僅一次構造器！*/
this.i=i++;//this以引用該類的成員變數
System.out.println("Int constructor: "+i+"/n"+"String constructor: "+s);
}
public ThisTest increment(){
this.i++;
return this;//返回的是當前的對象，該對象屬於（ThisTest）
}
public static void main(String[] args){
ThisTest tt0=new ThisTest(10);
ThisTest tt1=new ThisTest("ok");
ThisTest tt2=new ThisTest(20,"ok again!");
System.out.println(tt0.increment().increment().increment().i);
//tt0.increment()返回一個在tt0基礎上i++的ThisTest對象，
//接著又返回在上面返回的對象基礎上i++的ThisTest對象！
}
}
運行結果：
Int constructor i——this.i: 10——11
String constructor: ok
String constructor: ok again!
Int constructor: 21
String constructor: ok again!
14
細節問題注釋已經寫的比較清楚了，總結一下，其實this主要要三種用法：
1、表示對當前對象的引用！
2、表示用類的成員變數，而非函數參數，注意在函數參數和成員變數同名是進行區分！其實這是第一種用法的特例，比較常用，所以那出來強調一下。
3、用於在構造方法中引用滿足指定參數類型的構造器（其實也就是構造方法）。但是這里必須非常注意：只能引用一個構造方法且必須位於開始！
還有就是注意：this不能用在static方法中！所以甚至有人給static方法的定義就是：沒有this的方法！雖然誇張，但是卻充分說明this不能在static方法中使用！
Ⅵ 求教：Java中,this的用法，請舉例...
java中的this:
java中的保留字this僅限於在構造函數，類的方法和類的實例中使用。
1) 在類的構造函數中出現的this作為一個值類型，它表示對正在構造的對象本身的引用
2)在類的方法中出現的this作為一個值類型，表示對調用該方法的對象的引用
3) 在結構的構造函數中出現的this作為一個變數類型，表示對正在構造的結構的引用
4) 在結構的方法中出現this作為一個變數類型，表示對調用該方法的結構的引用
除此之外，其他地方使用this保留字都是不合法的。在方法內部，this引用可以用於指向任何當前執行的對象。
例如：在一個叫做ChessPiece的類中，可以有個方法叫Move，它可能包含下列行：
if(this.position=piece.position)
result=false;
在這種情況下，this引用用來澄清是哪個position被引用了。this引用指向觸發方法的對象。所以如果下面這行用
於觸發方法，this引用指向firstshop：
firstshop.Move();
但是，如果另外一個對象用於觸發方法，this引用就指向它。所以，如果使用了下面的調用，Move方法中的this引
用就指向secondshop：
secondshop.Move();
經常地，this引用用於區分構造函數的參數和它們相對應的同名的實例變數。例如：一個叫做Account類的構造函數
如下所示：
public Account(string owner, long account, double initial)
{
name=owner;
acctNumber=account;
balance=initial;
}
在編寫這個構造函數時，我們特意為參數去了不同的名字來區分它們與實例變數name，accNumber，和balance。這個區分是任意的。構造函數分來可以用this引用寫成如下所示：（這用更容易讓人理解和接受)
public Account(string name, long acctNumber, double balance)
{
this.name=name;
this.acctNumber=acctNumber;
this.balance=balance;
}
在這個版本的構造函數（非靜態的構造函數是在創建類的對象的時候被自動調用的）中，this引用特別指向對象的實例變數。賦值語句右邊的變數指向形參。這個方法消除了為了變數取不同的但是等價的名字的需要。這種情況有事在其它方法中發生，但通常出現在構造函數中。
好好的理解下~！
Ⅶ java 中this具體什麼時候能用,用了又代表什麼
this用在類內部，表示類實例本身。
this 關鍵字是類內部當中對自己的一個引用，可以方便類中方法訪問自己的屬性。
舉例：
publicclassA{
privateinta;//定義一個成員變數a
publicvoidshow(inta){
this.a=2;//通過this表示訪問的是類A中的屬性a
}
}
Ⅷ 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的構造函數。
Ⅸ java 中的this 如何用啊
1. this是指當前對象自己。
當在一個類中要明確指出使用對象自己的的變數或函數時就應該加上this引用。如下面這個例子中:
public class A {
String s = "Hello";
public A(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) {
new A("HelloWorld!");
}
}
運行結果：
s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!
在這個例子中，構造函數A中，參數s與類A的變數s同名，這時假如直接對s進行操作則是對參數s進行操作。若要對類A的變數s進行操作就應該用this進行引用。運行結果的第一行就是直接對參數s進行列印結果；後面兩行分別是對對象A的變數s進行操作前後的列印結果。
2. 把this作為參數傳遞
當你要把自己作為參數傳遞給別的對象時，也可以用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的構造函數。
3. 注重匿名類和內部類中的中的this。
有時候，我們會用到一些內部類和匿名類。當在匿名類中用this時，這個this則指的是匿名類或內部類本身。這時假如我們要使用外部類的方法和變數的話，則應該加上外部類的類名。如下面這個例子：
public class A {
int i = 1;
public A() {
Thread thread = new Thread() {
public void run() {
for(;;) {
A.this.run();
try {
sleep(1000);
} catch(InterruptedException ie) {
}
}
}
};
thread.start();
}
public void run() {
System.out.println("i = " + i);
i++;
}
public static void main(String[] args) throws Exception {
new A();
}
}
在上面這個例子中, thread 是一個匿名類對象，在它的定義中，它的 run 函數里用到了外部類的 run 函數。這時由於函數同名，直接調用就不行了。這時有兩種辦法，一種就是把外部的 run 函數換一個名字，但這種辦法對於一個開發到中途的應用來說是不可取的。那麼就可以用這個例子中的辦法用外部類的類名加上 this 引用來說明要調用的是外部類的方法 run。
Ⅹ 為什麼this關鍵字不能出現在類方法中
不可以，因為super（） 或this（）如果出現在構造方法里 都要放在構造方法的第一行
如果同時出現，
那到底是誰放第一行呢？
自相矛盾了
所以肯定不能
希望對你有幫助