java中this关键字的五种用法
java之this关键字用法事例解析

java之this关键字用法事例解析
java之this关键字用法事例解析
java之this关键字用法事例解析
一、this使用范围
1、在类的方法定义中使用的this关键字代表调用该方法对象的引用。
2、当必须指出当前使用方法的对象是谁时,要使用关键字this。
3、有时使用this可以处理方法中成员变量和参数重名的情况。
4、this可以看做是一个变量,它的值是当前对象的'引用。
注:this一般出现在方法中,当方法没有被调用时。
并不知道this 指向那个具体的对象。
当某个对象调用有this的方法时,this就指向调用这个方法的对象。
二、程序代码如下:
public class TestThis{ private int i; public TestThis(int i){ this.i = i; } private TestThis increment(){ i += 1; return this; } public static void main (String[] args){ TestThis mTestThis = new TestThis(100); System.out.println(mTestThis.increment().increment().i); }} 输出结果如下图所示:。
java中this的用法代码

java中this的用法代码一、Java中this关键字的作用及含义在Java编程语言中,this是一个特殊的关键字,代表当前对象的引用。
它可以被用来引用当前对象的实例变量、方法以及构造函数。
在代码中使用this关键字,能够明确指示当前对象,并且具有以下几个主要作用:1. 指向实例变量当类中存在与方法参数同名的实例变量时,为了区分二者,在方法内部使用this关键字就能够将调用该方法的对象与方法参数进行区分。
2. 调用本类其他方法通过使用this关键字,可以调用该类中的其他成员方法。
这对于多个成员方法之间需要相互调用或者需要在一个成员方法中调用另一个重载版本的成员方法时非常有用。
3. 在构造函数中调用另一个构造函数Java允许一个构造函数内部通过this关键字来调用同一个类中的其他构造函数。
这种方式通常被称为构造器链。
4. 返回当前对象在某些情况下,需要将当前对象作为返回值返回。
通过在方法内部使用return this语句,可以返回当前对象。
二、指向实例变量当类中存在与参数同名的实例变量时,为了避免歧义性和混淆,在局部范围内使用this关键字可以明确指向实例变量。
下面是一个简单的示例代码:public class Person {private String name;public void setName(String name) { = name; // 使用this关键字将参数值赋给实例变量}public void printName() {System.out.println("Name: " + ); // 使用this关键字引用实例变量 }}```在上述代码中,setName方法中的表示当前对象的实例变量name,而printName方法中的也同样表示当前对象的实例变量name。
三、调用本类其他方法在Java中,使用this关键字能够很方便地调用本类的其他方法,特别是在多个成员方法之间需要相互调用时。
Javathis关键字详解

Javathis关键字详解this 关键字⽤来表⽰当前对象本⾝,或当前类的⼀个实例,通过this可以调⽤对象的所有⽅法和属性。
1public class Demo {2private int x = 10;3private int y = 15;45public void sum(){6//通过this获取成员变量,this可以省略。
7int z = this.x + this.y;8 System.out.println("x+y = "+z);9 }1011public static void main(String[] args) {12 Demo demo = new Demo();13 demo.sum();14 }15 }使⽤this区分同名变量1public class Demo {2private String name;3private int age;45public Demo(String name,int age){6//this不能省略, 指的是成员变量,等于后⾯的name 是传⼊参数的变量,this可以很好的区分两个变量名⼀样的情况。
= name;8this.age = age;9 }10public static void main(String[] args){11 Demo demo = new Demo("微学院",3);12 System.out.println( + "的年龄是" + demo.age);13 }14 }使⽤this作为⽅法名来实例化对象1public class Demo {2private String name;3private int age;45public Demo(){6/**7 * 构造⽅法中调⽤另⼀个构造⽅法,调⽤动作必须置于最起始位置。
8 * 不能在构造⽅法之外调⽤构造⽅法。
java中this关键字的使用

java中this关键字的使⽤⼀个对象创建后会有⼀个this指针指向它。
所以this只能在类中的⾮静态⽅法中使⽤,静态⽅法和静态的代码块中绝对不能出现this,并且this只和特定的对象关联,⽽不和类关联,同⼀个类的不同对象有不同的this。
⼀、使⽤this来区分当前对象。
Java中为解决变量的命名冲突和不确定性问题,引⼊关键字this代表其所在⽅法的当前对象的引⽤:1) 构造⽅法中指该构造器所创建的新对象;2) ⽅法中指调⽤该⽅法的对象;3) 在类本⾝的⽅法或构造器中引⽤该类的实例变量(全局变量)和⽅法。
this只能⽤在构造器或者⽅法中,⽤于获得调⽤当前的构造器⽅法的对象引⽤。
可以和任何的对象引⽤⼀样来处理这个this对象。
说明:(1)当实例变量和局部变量重名,JAVA平台会按照先局部变量、后实例变量的顺序寻找。
即,⽅法中使⽤到的变量的寻找规律是先找局部变量,再找实例变量。
如果没⽤找到,将会有⼀个编译错误⽽⽆法通过编译。
(2)如果使⽤this.a,则不会在⽅法(局部变量)中寻找变量a,⽽是直接去实例变量中去寻找,如果寻找不到,则会有⼀个编译错误。
(3)在⼀个⽅法内,如果没有出现局部变量和实例变量重名的情况下,是否使⽤this关键字是没有区别的。
(4)在同⼀个类中,Java普通⽅法的互相调⽤可以省略this+点号,⽽直接使⽤⽅法名+参数。
因为Java编译器会帮我们加上。
public class dududu {/*因为xx是⼀个动态的内部类,创建这样的对象必须有实例与之对应,程序是在静态⽅法中直接调⽤动态内部类会报这样错误。
这样的错误好⽐类中的静态⽅法不能直接调⽤动态⽅法。
可以把该内部类声明为static。
或者不要在静态⽅法中调⽤。
*/public static class desktop{public int h=10,w=10;public desktop(int h,int w) {System.out.println("这是对象的h属性:"+this.h);System.out.println("这是对象的w属性:"+this.w);System.out.println("这是参数h的值:"+h);System.out.println("这是参数w的值:"+w);this.h=h;this.w=w;}public void show() {int h=33,w=44;System.out.println("我的⾼为:"+this.h+",宽为:"+this.w);}}public static void main(String[] args) {// TODO Auto-generated method stubdesktop a = new desktop(1,2);desktop b = new desktop(10,20);a.show();b.show();}}⼆、构造函数中使⽤this调⽤其他构造函数在构造器中可以通过this()⽅式来调⽤其他的构造器。
java this用法举例

java this用法举例Java是一门非常强大的编程语言,它被广泛应用于各种领域。
在Java中,this关键字是一个非常有用的工具,它可以帮助我们更好地理解和使用类和对象。
本文将通过几个示例来介绍this用法的用法。
一、指向当前对象的引用在Java中,this关键字指向当前对象的引用。
当我们需要在代码中引用当前对象时,可以使用this。
例如:```javapublic class MyClass {private String name;public MyClass(String name) { = name; // 使用this引用当前对象}}```在上面的例子中,我们在构造函数中使用this来引用当前对象的name属性。
这样就可以在代码中方便地访问当前对象的属性了。
二、构造函数中使用this在构造函数中使用this可以调用同一个类中的另一个构造函数。
这样可以在不重复代码的情况下实现更复杂的初始化逻辑。
例如:```javapublic class MyClass {private int value;public MyClass() {this(0); // 使用this调用另一个构造函数}public MyClass(int value) {this.value = value; // 初始化value属性}}```在上面的例子中,我们在构造函数中使用this来调用带有一个int类型参数的构造函数,并将value属性初始化为传入的参数值。
这样就可以在不重复代码的情况下实现更复杂的初始化逻辑了。
三、方法中使用this在方法中使用this可以访问当前对象的属性或调用当前对象的方法。
例如:```javapublic class MyClass {private String name;private int value;public void setName(String name) { = name; // 使用this访问当前对象的name属性}public void setValue(int value) {this.value = value; // 使用this调用当前对象的方法,并将value属性设置为传入的参数值}}```在上面的例子中,我们在方法中使用this来访问当前对象的name属性或调用当前对象的方法。
java中this和super的用法

java中this和super的用法
一、this的用法
1、当this表示当前对象时:
在类的方法中,this表示当前对象,它总是指向调用该方法的对象,这就是说,在类的方法中,“this”永远指向当前对象。
2、局部变量和属性
当一个局部变量或者成员变量名字相同时,this可以用来区分这两个变量,指明属性,要么this引用实例的属性,要么就是方法的局部变量。
3、用this调用构造函数
有时可以使用this调用同一类中其他构造函数,如:
public class A{
public A(){
}
public A(int a){
this();
}
}
4、强调调用成员变量
当this.x和x表示同一个成员变量时,可以使用this.x来强调x是成员变量,而不是局部变量。
二、super的用法
1、调用父类的构造函数
每个子类构造函数默认都会调用父类的默认的无参数的构造函数,可以使用super来调用父类有参数的构造函数。
2、调用父类的成员函数
子类可以调用自己不具备的父类函数,或者重写父类函数,重写时也可以使用super来调用父类函数。
3、调用父类的成员变量
由于子类不能直接访问父类的成员变量,需要使用super来访问父类的成员变量。
java中this的用法

java中this的用法This,英语单词,发音:[英][ðɪs][美][ðɪs]。
常翻译为:这,这么。
java中this的用法有哪些呢?本文是店铺整理java中this的用法的资料,仅供参考。
java中this的用法11. 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 = Hello2 -> 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的构造函数中,newB(this)把对象A作为参数传递给了对象B的构造函数。
java中this关键字

java中this关键字⼀、this关键字主要有三个应⽤:(1)this调⽤本类中的属性,也就是类中的成员变量;(2)this调⽤本类中的其他⽅法;(3)this调⽤本类中的其他构造⽅法,调⽤时要放在构造⽅法的⾸⾏。
Public Class Student {String name; //定义⼀个成员变量nameprivate void SetName(String name) { //定义⼀个参数(局部变量)name=name; //将局部变量的值传递给成员变量}}应⽤⼀:引⽤成员变量如上⾯这段代码中,有⼀个成员变量name,同时在⽅法中有⼀个形式参数,名字也是name,然后在⽅法中将形式参数name的值传递给成员变量name,虽然我们可以看明⽩这个代码的含义,但是作为Java编译器它是怎么判断的呢?到底是将形式参⼀般情况下,在Java语⾔中引⽤成员变量或者成员⽅法都是以对象名.成员变量或者对象名.成员⽅法的形式。
不过有些程序员即使在没有相同变量的时候,也喜欢使⽤this.成员变量的形式来引⽤变量,这主要是从便于代码的阅读考虑的。
⼀看到这个其实如果是局部变量的话,也是相同的道理。
如在上⾯的代码中,name不是形式参数,⽽是⼀个局部变量。
此时Java也会遇到相同的疑惑,即变量名name代表的到底是局部变量还是形式参数?name=name到底代表的是什么含义?根据局部变量的作应⽤⼆:调⽤类的构造⽅法public class Student { //定义⼀个类,类的名字为student。
public Student() { //定义⼀个⽅法,名字与类相同故为构造⽅法this(“Hello!”);}public Student(String name) { //定义⼀个带形式参数的构造⽅法}}this关键字除了可以调⽤成员变量之外,还可以调⽤构造⽅法。
在⼀个Java类中,其⽅法可以分为成员⽅法和构造⽅法两种。
java中this关键字与this()基础用法

java中this关键字与this()基础⽤法⼀、this关键字this关键字最常⽤于构造⽅法中,初始化实例属性(和python中的self是⼀样的性质)class Dog {int age ;String name ;public Dog(int age, String name){//1、在构造⽅法中⽤于初始化参数(⽤于区分属性和⼊参)this.age =age; =name;}public void demo(){System.out.println("demo执⾏");}public void demo1(){//在普通的实例⽅法中,可以添加this调⽤属性/⽅法this.age =1000;this.demo();//⼀般情况,我们调⽤实例属性/实例⽅法时不需要添加this,编译器会⾃动添加name ="⼩⿊";demo();}}⼆、this()⽅法this()表⽰调⽤构造⽅法,此种调⽤只能⽤在构造⽅法中,即构造⽅法中调⽤构造⽅法this(实参)。
1、this()、this(实参)必须⽅法构造⽅法的第⼀⾏2、在有参数构造⽅法中调⽤⽆参数构造⽅法this();在⽆参数的构造⽅法中调⽤有参数的构造⽅法this(实参)⼀、如下是⽆参数构造⽅法调⽤有参数构造⽅法:public class Constractor{int year;int month;int day;//⽆参数构造⽅法public Constractor(){this(2019,1,1);}//有参数构造⽅法Constractor(int year, int month, int day){this.year = year;this.month = month;this.day = day;}}⼆、如下是有参数构造⽅法调⽤⽆参数构造⽅法:public class Constractor{int year;int month;int day;//⽆参数构造⽅法public Constractor(){}//有参数构造⽅法Constractor(int year, int month, int day){this();this.year = year;this.month = month;this.day = day;}}三、this()/this(实参)必须出现在构造⽅法的第⼀⾏,否则报错。
this用法java

this用法java在 Java 中,`this`关键字有以下几种常见用法:1. **表示当前对象**:在类的方法中,`this`可以用来引用当前对象。
通过`this`,可以访问类的属性、调用其他方法。
```javapublic class ThisExample {private int id;private String name;// 访问属性public void setId(int id) {this.id = id;}// 调用方法public void printName() {System.out.println();}}```2. **区分参数和类的属性**:当方法中的参数和类的属性同名时,可以使用`this`来区分。
```javapublic class ThisExample {private int id;public void setId(int id) {// 使用 this 区分参数和属性this.id = id;}}```3. **在内部类中使用**:在内部类中,可以使用`this`来引用外部类的成员。
```javapublic class OuterClass {private int outerVariable;public class InnerClass {public void accessOuterVariable() {System.out.println(ThisExample.this.outerVariable);}}}```4. **在构造器中调用其他构造器**:在一个类中,可以使用`this`在构造器中调用其他构造器。
```javapublic class ThisExample {private int id;private String name;public ThisExample(int id) {// 调用带有两个参数的构造器this(id, "默认名称");}public ThisExample(int id, String name) {this.id = id; = name;}}```使用`this`关键字时需要注意,它只能在方法内部使用,并且它引用的是当前对象的实例变量或方法。
java中this关键字的作用

java中this关键字的作⽤1、this调⽤当前属性:其主要作⽤是当需要给类中的数据进⾏初始化时,可以通过this来进⾏赋值,⽽不⽤随便定义⼀个变量来进⾏赋值,更有利于代码的阅读与理解 如:class Book{//定义书的类private String name;//书本名字private int price;//书本价格public Book(String name,int price){ //使⽤this对类的数据进⾏初始化 = name; this.price = price;}/*public Book(String n,int p){ //若不使⽤this关键字只能这样进⾏赋值,不利于将变量与属性统⼀起来name = n;price = p;}*/public String getInfo(){return "书籍:" + name + ",价格:" + price;}}public class ThisDemo{public static void main(String args[]){System.out.printIn(new Book("Java",89.9).getInfo())}}2、this调⽤⽅法(普通⽅法、构造⽅法) (1)普通⽅法:1class Book{//定义书的类2private String name;//书本名字3private int price;//书本价格4public Book(String name,int price){//使⽤this对类的数据进⾏初始化 = name; 6this.price = price;7this.print();//调⽤本类普通⽅法,虽然可以不⽤使⽤this也可以进⾏本类普通⽅法的调⽤,但是好的习惯最好应该加上,⽬的是可以区分⽅法的定义来源8 }9public String getInfo(){10return "书籍:" + name + ",价格:" + price;11 }12public void print(){13 System.out.printIn("***********");14 }15 }16public class ThisDemo{17public static void main(String args[]){18 System.out.printIn(new Book("Java",89.9).getInfo())19 }20 } (2)构造⽅法:普通⽅法与构造⽅法的区别是构造⽅法在创建后只能掉⽤⼀次,⽤来初始化数据,⽽普通⽅法在创建后可以调⽤多次。
java语言this的用法

java语言this的用法一、介绍this关键字在Java编程语言中,关键字this代表当前对象的引用。
this可以被用于多种场景下,比如在方法内部访问实例变量、调用其他构造方法等。
本文将深入探讨Java语言中this关键字的用法和使用场景。
二、this关键字的使用方式2.1 访问实例变量在一个类的方法中,通过使用this关键字可以访问当前对象的实例变量。
this 可以理解为对当前对象的引用,所以利用它可以很方便地操作该对象的属性。
例如,假设有一个Person类,其中包含了name和age两个实例变量。
我们可以利用在Person类的方法中使用this关键字来访问这些实例变量:```javapublic class Person {private String name;private int age;public void setName(String name) { = name;}public void setAge(int age) {this.age = age;}public String getName(){return ;}public int getAge(){return this.age;}}```上述代码中,在setName()和setAge()方法中,通过使用和this.age来指代当前对象(即调用方法的对象)的name和age属性。
2.2 调用其他构造方法在类中定义多个构造方法时,有时候需要从一个构造方法中调用另一个构造方法,这时可以使用this关键字来实现。
例如,我们可以定义一个包含两个参数的构造方法和一个不带参数的构造方法。
在不带参数的构造方法中通过this关键字调用带有参数的构造方法,以避免代码的冗余。
```javapublic class Person {private String name;private int age;public Person() {this("Tom", 18); // 调用有参构造方法}public Person(String name, int age) { = name;this.age = age;}}```上述代码中,在不带参数的构造方法Person()中使用了this("Tom", 18)来调用有参构造方法Person(String name, int age),从而实现代码的复用。
Java中的this有哪四种用法

Java中的this有哪四种⽤法
JAVA中的this是⼀个⾮常重要的模块。
在编程中有⾮常重要的地位。
擅长⽤this的⼈常常可以使程序更加简洁和⽅便。
今天来了解⼀下this的⽤法。
java中this关键字必须放在⾮静态⽅法⾥⾯,this关键字代表⾃⾝,在程序中主要的⽤途有以下⼏个⽅⾯:
1、引⽤成员变量;
2、在⾃⾝构造⽅法内部引⽤其它构造⽅法;
3、代表⾃⾝类的对象;
4、引⽤成员⽅法;
下⾯我们来分别看⼀下这四种⽤法:
⼀、引⽤成员变量
在⼀个类的⽅法或构造⽅法内部,可以使⽤“this.成员变量名”这样的格式来引⽤成员变量名,有些时候可以省略,有些时候不能省略。
⼆、引⽤构造⽅法
在⼀个类的构造⽅法内部,也可以使⽤this关键字引⽤其它的构造⽅法,这样可以降低代码的重复,也可以使所有的构造⽅法保持统⼀,这样⽅便以后的代码修改和维护,也⽅便代码的阅读。
三、代表⾃⾝对象
在⼀个类的内部,也可以使⽤this代表⾃⾝类的对象,或者换句话说,每个类内部都有⼀个隐含的成员变量,该成员变量的类型是该类的类型,该成员变量的名称是this,实际使⽤this代表⾃⾝类的对象。
四、引⽤成员⽅法
在⼀个类的内部,成员⽅法之间的互相调⽤时也可以使⽤“this.⽅法名(参数)”来进⾏引⽤,只是所有这样的引⽤中this都可以省略。
总之,this的重点在于“当前对象”,只有理解了“当前对象”的概念才能灵活的掌握它的⽤法。
有需要资料的朋友,请评论“求资料”,就可以了。
我会⼀个个分享给留⾔的⼩伙伴,先到先发。
java中的this用法

java中的this用法
在Java中,this关键字有以下用法:
1. 指代当前对象:this可以用来指代当前对象,即当前方法被调用的对象。
可以使用this来调用当前对象的属性或方法。
2. 区分局部变量和成员变量:当方法的参数名或局部变量与成员变量重名时,可以通过使用this关键字来引用成员变量。
3. 作为构造器:在一个构造器内部,可以使用this关键字来调用同一类的另一个构造器。
这样可以避免重复的初始化代码。
4. 作为方法参数传递:this关键字可以作为参数传递给其他方法,以便在其他方法中使用当前对象。
5. 作为返回值:this关键字也可以作为返回值返回给调用者。
这样可以实现方法链式调用。
总的来说,this关键字的主要作用是指代当前对象,帮助在类中访问成员变量、方法或调用构造器的重载版本。
Java中this关键字用法

另外,使用this访问属性和方法时,如果在本类中未找到,会从父类中查找。
举例1:class Person{ // 定义Person类public void speak(){System.out.println(“年龄:”+this.age);}}举例2:public class Rectangle {int length;int width;public int area() {return this.length*this.width;}public int perimeter(){return2* (this.length+this.width);}public void print(char sign) {for (int i=1; i<=this.width; i++) {for (int j=1; j<=this.length; j++) {System.out.print(sign);}System.out.println();}}public String getInfo(){return"长:"+this.length+",宽:"+this.width+",面积:"+ this.area() +",周长:"+this.perimeter();}}测试类:public class TestRectangle {public static void main(String[] args) {Rectangle r1=new Rectangle();Rectangle r2=new Rectangle();System.out.println("r1对象:"+r1.getInfo());System.out.println("r2对象:"+r2.getInfo());r1.length=10;r1.width=2;System.out.println("r1对象:"+r1.getInfo());System.out.println("r2对象:"+r2.getInfo());r1.print('#');System.out.println("---------------------");r1.print('&');System.out.println("---------------------");r2.print('#');System.out.println("---------------------");r2.print('%');}}1.2.2 同一个类中构造器互相调用this可以作为一个类中构造器相互调用的特殊格式。
this关键字的使用

this关键字的使⽤1、this可以⽤来修饰、调⽤:属性和⽅法、构造器2、this修饰属性和⽅法this可以理解为:当前对象或当前正在创建的对象1. 在类的⽅法当中,可以使⽤this.属性或this.⽅法的⽅式,调⽤当前对象的属性或⽅法,但是通常省略this。
特殊情况下,如果⽅法的形参和类的属性同名时,必须显式使⽤this,表明此变量是属性⽽⾮形参。
2. 在类的构造器当中,可以使⽤this.属性或this.⽅法的⽅式,调⽤当前正在创建的对象的属性或⽅法,但是通常省略this。
特殊情况下,如果构造器的形参和类的属性同名时,必须显式使⽤this,表明此变量是属性⽽⾮形参。
3、this调⽤构造器1. 在类的构造器中,可以显式的使⽤“this(形参列表)”⽅式,调⽤本类中指定的其他构造器。
2. 构造器中不能通过this调⽤⾃⼰。
3. 如果⼀个类中有n个构造器,则最多有n-1构造器中使⽤了this调⽤。
4. 规定:this调⽤构造器必须声明在当前构造器的⾸⾏。
5. 构造器内部,最多只能声明⼀个this来调⽤其他的构造器。
package org.lyk.entities;public class Emp implements Comparable<Emp>{private long empno;private String ename;private String job;private float sal;public long getEmpno(){return empno;}public void setEmpno(long empno){this.empno = empno;}public String getEname(){return ename;}public void setEname(String ename){this.ename = ename;}public String getJob(){return job;}public void setJob(String job){this.job = job;}public float getSal(){return sal;}public void setSal(float sal){this.sal = sal;}@Overridepublic String toString(){return "Emp [empno=" + empno + ", ename=" + ename + ", job=" + job + ", sal=" + sal + "]";}public Emp(){this(-1, "⽆名⽒", "未指定", 0);}public Emp(long empno){this(empno,"⽆名⽒","未指定",0);}public Emp(long empno, String name){this(empno, name, "未指定", 0);}public Emp(long empno, String ename, String job, float sal) {super();this.empno = empno;this.ename = ename;this.job = job;this.sal = sal;}@Overridepublic int compareTo(Emp o){if(this.sal < o.sal)return -1;else if(this.sal > o.sal)return 1;if(this.empno < o.empno)return -1;else if(this.empno > o.empno)return 1;return 0;}}。
java中this的三种用法

在Java中,“this”关键字有三种主要的用法:1. **引用当前对象**:这是“this”最常用的用法。
在类的方法中,你可以使用“this”关键字引用当前实例。
例如:```javapublic class MyClass {private int myField;public void myMethod() {// 使用"this" 引用当前实例this.myField = 5;}}```在这个例子中,“this”关键字用于引用当前实例,并设置`myField`的值为5。
2. **在构造函数中使用**:在构造函数中,“this”关键字可以用来调用其他构造函数。
例如:public class MyClass {private int myField;public MyClass() {this(0); // 使用"this" 调用另一个构造函数}public MyClass(int myField) {this.myField = myField;}}```在这个例子中,“this”关键字用于调用另一个构造函数。
这允许我们在一个构造函数中使用另一个构造函数的初始化代码,而不必重复代码。
3. **在接口中定义默认方法**:从Java 8开始,接口可以包含默认方法和静态方法。
默认方法是一种有默认实现的方法,可以被实现接口的类选择性覆盖。
使用“this”关键字可以引用接口自身,从而在默认方法中调用其他接口方法。
例如:public interface MyInterface {default void myMethod() {// 使用"this" 调用另一个接口方法this.anotherMethod();}void anotherMethod(); // 接口中的另一个方法}```在这个例子中,“this”关键字用于引用接口自身,并在默认方法`myMethod`中调用另一个接口方法`anotherMethod`。
this的用法

1.this关键字:super代表父类对象。
this指对象本身。
this,super都不能放在静态方法里,因为他们时实例(对象)相关的。
注意,main 方法也是静态方法。
用法1:private int stuNo;public void setStuNo(int stuNo){this.stuNo=stuNo;}public int getStuNo(){return this.stuNo;}用法2:类的构造器可以相互调用,调用方式是使用this关键字来实现。
如:public Point(){this(0,0);相当于this.x=0;this.y=0;有this了,super就没有了。
不 } 执行super了。
public Point (double x,double y){//super();this.x=x;this.y=y;}在构造器中,super()和this(0,0);这样的,不能同时出现。
如:super();生成一个对象this(0,0);又生成一个对象都显示就有问题,super构造与this构造不能同时出现。
☆:this代表的是对象的本身。
Java语言中,方法重载要求( A )A.采用不同的参数列表。
B.采用不同的返回值类型。
C.调用时,用类名或对象名做前缀。
D.在参数列表中使用的参数名不同。
this:构造器中指该构造器所创建的新对象。
方法中指调用该方法的对象。
顺序:比如创建Person p=new Person(); extends Animal首先执行构造方法中Super这时,先走Animal类的变量定义,有赋值的给变量赋值。
然后走Animal的构造方法,然后走person类的变量定义,然后走person的构造方法。
(这是一步步递归)。
2.初始化块:不管使用哪个构造器创建对象,它都会被首先运行,在成员运行之后,然后才是构造器的主体部分被执行。
如下面的初始化块:作用是给属性赋值。
java中this的N种使用方法

java中this的N种使⽤⽅法 this可能是⼏乎所有有⼀点⾯向对象思想的语⾔都会引⽤到的变量,java⾃然不例外。
只是,this有多少种⽤法,我也不知道了,让我们来see see。
由简⼊奢!易。
来个例⼦说明下:public class DebugerTest {public static void main(String[] args) {UserExample samp1 = new UserExample("amy");System.out.println("who are u? ");System.out.println(samp1.whoAreU());System.out.println("intro yourself?");System.out.println(samp1.introYourself());}}class UserExample {private String name;private Integer age;private MyDoll myDoll;public UserExample() {this(null);}// 3. 调⽤本类的其他构造⽅法public UserExample(String name) {this(name, -1);}public UserExample(String name, Integer age) { = name;this.age = age;this.myDoll = new MyDoll("prize");}// 2. 调⽤本类属性public void changeMyName(String name) { = name;}public void changeMyAge(Integer age) {this.age = age;}public String whoAreU() {return "I am " + name + ". ";}public String haoOldAreU() {return "i am " + age + " old.";}// 1. 调⽤本类⽅法public String introYourself() {return this.whoAreU() +this.haoOldAreU() +"\r\n whoAmI@ " + this.myDoll.whoAmI() +"\r\n whoAreSuper@ " + this.myDoll.whoAreSuper();}class MyDoll {private String name;public MyDoll(String name) { = name;}public void changeMyName(String name) { = name;}// 5. 隐藏式的调⽤public String whoAmI() {return whoAreU();}public String whoAreU() {return "I am a Doll, my name is " + name + ". ";}// 4. 调⽤⽗类的或指定的其他的类的同名⽅法public String whoAreSuper() {return "super is " + UserExample.this.whoAreU() + ". ";}}}1. 调⽤本类⽅法,表达更清晰public String introYourself() {return this.whoAreU() + this.haoOldAreU();}2. 调⽤本类属性,基本功亮出来public void changeMyName(String name) { = name;}3. 调⽤本类的其他构造⽅法,更灵活public UserExample(String name) {this(name, -1);}4. 调⽤⽗类的或指定的其他的类的同名⽅法,为避免歧义⽽⽣的⽅法public String whoAreSuper() {return "super is " + UserExample.this.whoAreU() + ". ";}5. 隐藏式的调⽤,为了写代码⽅便(更常⽤),不指定范围,java会在全类范围内向上查找变量或⽅法public String whoAmI() {return whoAreU();}以上样例输出结果如下所⽰: this是个基本的关键字,我们平时也⼀直在⽤,只是也不⼀定所有同学都清楚怎么⽤。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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!");
System.out.println("s=" + x.s);//验证成员变量值的改变}
}
结果为:s = HelloWorld!
1 -> this.s = Hello
2 -> this.s = HelloWorld!
s=HelloWorld!
在这个例子中,构造函数Hello中,参数s与类Hello的成员变量s同名,这时如果直接对s进行操作则是对参数s进行操作。
若要对类Hello的成员变量s进行操作就应该用this进行引用。
运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果;第二行是对成员变量s的打印;第三行是先对成员变量s赋传过来的参数s值后再打印,所以结果是HelloWorld!而第四行是主函数中直接打印类中的成员变量的值,也可以验证成员变量值的改变。
2.把自己当作参数传递时,也可以用this.(this作当前参数进行传递)
class A {
public A() {
new B(this).print();// 调用B的方法
}
public void print() {
System.out.println("HelloAA from A!");
}
}
class B {
A a;
public B(A a) {
this.a = a;
}
public void print() {
a.print();//调用A的方法
System.out.println("HelloAB from B!");
}
}
public class HelloA {
public static void main(String[] args) {
A aaa = new A();
aaa.print();
B bbb = new B(aaa);
bbb.print();
}
}
结果为:HelloAA from A!
HelloAB from B!
HelloAA from A!
HelloAA from A!
HelloAB from B!
在这个例子中,对象A的构造函数中,用new B(this)把对象A自己作为参数传递给了对象B的构造函数。
3.有时候,我们会用到一些内部类和匿名类,如事件处理。
当在匿名类中用this时,这个this则指的是匿名类或内部类本身。
这时如果我们要使用外部类的方法和变量的话,则应该加上外部类的类名。
如:
public class HelloB {
int i = 1;
public HelloB() {
Thread thread = new Thread() {
public void run() {
for (int j=0;j<20;j++) {
HelloB.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 HelloB();
}
}
在上面这个例子中, thread 是一个匿名类对象,在它的定义中,它的run 函数里用到了外部类的run 函数。
这时由于函数同名,直接调用就不行了。
这时有两种办法,一种就是把外部的run 函数换一个名字,但这种办法对于一个开发到中途的应用来说是不可取的。
那么就可以用这个例子中的办法用外部类的类名加上this 引用来说明要调用的是外部类的方法run。
4.在构造函数中,通过this可以调用同一类中别的构造函数。
如:
public class ThisTest {
ThisTest(String str) {
System.out.println(str);
}
ThisTest() {
this("this测试成功!");
}
public static void main(String[] args) {
ThisTest thistest = new ThisTest();
}
}
为了更确切的说明this用法,另外一个例子为:
public class ThisTest {
private int age;
private String str;
ThisTest(String str) {
this.str=str;
System.out.println(str);
}
ThisTest(String str,int age) {
this(str);
this.age=age;
System.out.println(age);
}
public static void main(String[] args) {
ThisTest thistest = new ThisTest("this测试成功",25);
}
}
结果为:this测试成功
25
值得注意的是:
1:在构造调用另一个构造函数,调用动作必须置于最起始的位置。
2:不能在构造函数以外的任何函数内调用构造函数。
3:在一个构造函数内只能调用一个构造函数。
5.this同时传递多个参数。
public class TestClass {
int x;
int y;
static void showtest(TestClass tc) {//实例化对象
System.out.println(tc.x + " " + tc.y);
}
void seeit() {
showtest(this);
}
public static void main(String[] args) {
TestClass p = new TestClass();
p.x = 9;
p.y = 10;
p.seeit();
}
}
结果为:9 10
代码中的showtest(this),这里的this就是把当前实例化的p传给了showtest()方法,从而就运行了。