java中this用法

合集下载

java this关键字

java  this关键字
System.out.println("下面是调用方法的值");
me.getname("kate");
}
}
执行上述代码,结果如图6-17所示。
图6-17 this的用法
在该文件中,this表示当前对象。 =name语句表示一个赋值语句,是指当前对象具有的变量name,“name”表示的参数传递过来的数值。
}
public static void main(String[] args)
{
Obj_this me=new Obj_this("luci",20);
System.out.println("输出对象的属性");
System.out.println();
System.out.println(me.age);
public Obj_this(String name,int age) //构造方法
{
=name;
this.age=age;
}
public void getname(String name)
{
=name;
System.out.println(thiΒιβλιοθήκη );
java this
this关键字是Java中常用的关键字,可用于任何实例方法内,指向当前对象。也可指向对其调用当前方法的对象或在需要当前类型的对象引用时使用。
下面通过创建一个实例,来说明this关键字的用法。示例代码如下所示。
public class Obj_this
{
String name;
int age;

Java中的两个关键字——super、this

Java中的两个关键字——super、this

Java中的两个关键字——super、thisJava中的两个关键字——super、this ⼀、supersuper 是java中⽅的⼀个关键字,⽤它可以引⽤⽗类中的成员:super可⽤于访问⽗类中定义的属性super可⽤于调⽤⽗类中定义的成员⽅法super可⽤于在⼦类构造器中调⽤⽗类的构造器使⽤super关键字注意事项:1、当⼦类和⽗类都有同名的属性时,在⼦类中如果要使⽤⽗类的属性 super . 属性2、 super只能应⽤在成员⽅法和构造⽅法中,不能⽤在静态⽅法中(和this是⼀样的)3、如果在构造⽅法中使⽤必须放在第⼀⾏4、在构造⽅法中this()和super()不能同时出现super没有什么需要解释的地⽅,我们⽤代码来看看super具体的⼀些强⼤功能吧⽰例⼀、使⽤super调⽤基类的属性:public class Father { int num=20;}public class Child extends Father{ int num; public void print(){ num=10; super.num=30; System.out.println("num="+num); System.out.println("="+super.num); }}public class Test { public static void main(String[] args) { Child xm=new Child(); xm.print(); }}运⾏结果:⽰例⼆、使⽤super调⽤基类中的构造⽅法:public class Father { int num; public Father() { System.out.println("⽗类中的⽆参构造⽅法---"); } public Father(int num){ System.out.println("⽗类中的有参的构造⽅法----"+num); }}public class Child extends Father{ int num; public Child() { super(30); System.out.println("⼦类⽆参构造⽅法---"); } public Child(int num) { this.num = num; System.out.println("⼦类中的有参的构造⽅法---"+num); }}解释⼀下上⾯的这段代码:在Child类中的第⼀个构造函数⾥⾯,super(30);它会去调⽤⽗类中嗲有⼀个int型参数的构造⽅法。

java中this关键字与this()基础用法

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

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`关键字时需要注意,它只能在方法内部使用,并且它引用的是当前对象的实例变量或方法。

This和Super的区别

This和Super的区别

This和Super的区别
⼀:this
java中this关键字的作⽤和词义很接近:
它在⽅法内部使⽤,即这个⽅法所属对象的引⽤
它在构造器内部使⽤,表⽰该构造器正在初始化的对象。

this表⽰当前对象,可以调⽤类的属性、⽅法和构造器。

注意
使⽤this()必须放在构造器的⾸⾏!
使⽤this()调⽤本类中其他的构造器,保证⾄少有⼀个构造器不是⽤this的。

⼆:super
java类中使⽤super来调⽤⽗类中的指定操作:
super可⽤于访问⽗类中定义的属性
super可⽤于调⽤⽗类中定义的成员⽅法
super可⽤于在⼦类构造⽅法中调⽤⽗类的构造器
注意
尤其当⼦⽗类出现同名成员是,可以⽤super进⾏区分。

super的追溯不仅限于直接⽗类。

super和this的⽤法相像,this代表本类对象的引⽤,super代表⽗类的内存空间的标识。

三:this和super区别
No.区别点this super
1访问属性访问本类中的属性,如果本类没有此属性则从⽗类中继续查找访问⽗类中的属性
2调⽤⽅法访问本类中的⽅法直接访问⽗类中的⽅法
3调⽤构造器调⽤本类构造器,必须放在构造器⾸⾏调⽤⽗类构造器,必须放在⼦类构造器的⾸⾏4特殊表⽰当前对象⽆。

java中的this和super的作用和异同和C++中调用父类的构造函数

java中的this和super的作用和异同和C++中调用父类的构造函数

java中的this和super的作⽤和异同和C++中调⽤⽗类的构造函数这⼏天看到类在继承时会⽤到this和super,这⾥就做了⼀点总结,与各位共同交流,有错误请各位指正~thisthis是⾃⾝的⼀个对象,代表对象本⾝,可以理解为:指向对象本⾝的⼀个指针。

this的⽤法在java中⼤体可以分为3种:1.普通的直接引⽤这种就不⽤讲了,this相当于是指向当前对象本⾝。

2.形参与成员名字重名,⽤this来区分:1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17class Person {private int age = 10;public Person(){System.out.println("初始化年龄:"+age);}public int GetAge(int age){this.age = age;return this.age;}}public class test1 {public static void main(String[] args) {Person Harry = new Person();System.out.println("Harry's age is "+Harry.GetAge(12)); }}运⾏结果:初始化年龄:10Harry's age is 12可以看到,这⾥age是GetAge成员⽅法的形参,this.age是Person类的成员变量。

3.引⽤构造函数这个和super放在⼀起讲,见下⾯。

supersuper可以理解为是指向⾃⼰超(⽗)类对象的⼀个指针,⽽这个超类指的是离⾃⼰最近的⼀个⽗类。

super也有三种⽤法:1.普通的直接引⽤与this类似,super相当于是指向当前对象的⽗类,这样就可以⽤super.xxx来引⽤⽗类的成员。

2.⼦类中的成员变量或⽅法与⽗类中的成员变量或⽅法同名12 3 4 5 6 7 8 9 10 11 12 13class Country {String name;void value() {name = "China";}}class City extends Country {String name;void value() {name = "Shanghai";super.value(); //调⽤⽗类的⽅法 System.out.println(name);13 14 15 16 17 18 19 20 21 System.out.println(name);System.out.println();}public static void main(String[] args) { City c=new City();c.value();}}运⾏结果:ShanghaiChina可以看到,这⾥既调⽤了⽗类的⽅法,也调⽤了⽗类的变量。

java的this用法

java的this用法

java的this用法Java的this用法十分重要,在面向对象编程中经常遇到。

本文将分为以下几步进行阐述:1. 什么是this?在Java中,this关键字代表当前对象的引用。

它可以用于以下两种情况:- 区分实例变量和局部变量。

- 在构造函数中调用同一个类的另一个构造函数。

2. 用法一:区分实例变量和局部变量有时候,在类中会有实例变量和方法内的局部变量重名的情况,这就需要使用this来区别它们,以表示实例变量。

例如:```public class Person {private String name;public void setName(String name) { = name;}}```在这个例子中,表示类中的实例变量name,而name 则是方法中的局部变量。

3. 用法二:在构造函数中调用同一个类的另一个构造函数有时候,一个类会有多个构造函数,它们的方法体内容很相似,只有一些参数不同。

这时候可以使用this调用同一个类的另一个构造函数,减少代码的重复。

例如:```public class Person {private String name;private int age;public Person() {this("Unknown", 0);}public Person(String name) {this(name, 0);}public Person(int age) {this("Unknown", age);}public Person(String name, int age) { = name;this.age = age;}}```在这个例子中,不同的构造函数中调用了同一个类的参数完整的构造函数,减少了代码的重复。

4. 注意事项使用this时需要注意以下几点:- this必须在方法内部使用。

- 如果方法中没有局部变量与实例变量同名,则可以省略this。

java构造方法格式

java构造方法格式

java构造方法格式Java中,构造方法是一种特殊的方法,用于创建和初始化对象。

每当我们创建一个新对象时,都会调用其相应的构造方法。

构造方法的名称必须与类名相同,它没有返回类型,并且不能被直接调用。

下面是Java构造方法的格式:```[public] [private] [protected] ClassName([List of Parameters]) {// Constructor body}```上面的代码中,方括号表示可选项,构造方法名称必须与类名完全相同,构造方法可以使用任何访问修饰符(public、private或protected),并且可以拥有一些参数。

下面是Java构造方法的一些特点和用法:1. 构造方法没有返回值类型,即使有返回语句也不会返回任何值。

2. 当我们不为类定义构造方法时,编译器会自动生成一个默认的无参构造方法。

3. 在创建对象时,我们可以调用重载的构造方法来为对象赋初值。

4. 在一个类中可以定义多个构造方法,只要它们的参数列表不同即可。

5. 构造方法可以使用this关键字调用本类中的其他构造方法,用于重载构造方法时避免重复代码。

下面是一些示例代码,用于演示Java构造方法的使用:```public class Car {private String make;private String model;private int year;// 无参构造方法public Car() {}// 有参构造方法public Car(String make, String model, int year) {this.make = make;this.model = model;this.year = year;}// 使用this关键字调用本类中的其他构造方法public Car(String make, String model) {this(make, model, 2020);}// Getter和Setter方法public String getMake() {return make;}public void setMake(String make) { this.make = make;}public String getModel() {return model;}public void setModel(String model) { this.model = model;}public int getYear() {return year;}public void setYear(int year) {this.year = year;}}```上面的示例代码定义了一个Car类,其中包含三个属性make、model 和year,以及三个构造方法和三个Getter/Setter方法。

java中this的理解

java中this的理解

java中this的理解
在Java中,关键字this代表当前对象的引用。

它可以用来引用当前对象的实例变量、方法和构造函数。

this关键字通常用于消除实例变量和局部变量之间的歧义,或者在构造函数中调用其他构造函数。

当一个对象被创建时,它会在内存中分配一块空间,并且在这块空间中包含了它的实例变量。

当我们在对象的方法中使用this关键字时,实际上是在引用这块内存空间。

这样就可以明确地指出我们要访问或者操作的是当前对象的实例变量,而不是方法中的局部变量。

另外,this关键字还可以用来在一个构造函数中调用另一个构造函数。

这种情况下,使用this()来调用其他构造函数,可以避免重复的初始化代码,并且可以确保所有的构造函数都会被调用到。

总之,this关键字在Java中扮演着非常重要的角色,它可以帮助我们清晰地表达出当前对象的引用,避免歧义,并且在构造函数中起到了很好的辅助作用。

对于Java程序员来说,理解和正确使用this关键字是非常重要的。

java中的this用法

java中的this用法

java中的this用法
在Java中,this关键字有以下用法:
1. 指代当前对象:this可以用来指代当前对象,即当前方法被调用的对象。

可以使用this来调用当前对象的属性或方法。

2. 区分局部变量和成员变量:当方法的参数名或局部变量与成员变量重名时,可以通过使用this关键字来引用成员变量。

3. 作为构造器:在一个构造器内部,可以使用this关键字来调用同一类的另一个构造器。

这样可以避免重复的初始化代码。

4. 作为方法参数传递:this关键字可以作为参数传递给其他方法,以便在其他方法中使用当前对象。

5. 作为返回值:this关键字也可以作为返回值返回给调用者。

这样可以实现方法链式调用。

总的来说,this关键字的主要作用是指代当前对象,帮助在类中访问成员变量、方法或调用构造器的重载版本。

Javathis关键字详解(3种用法)

Javathis关键字详解(3种用法)

Javathis关键字详解(3种⽤法)Java this关键字详解(3种⽤法)this 关键字是常⽤的关键字,可⽤于任何实例⽅法内指向当前对象,也可指向对其调⽤当前⽅法的对象,或者在需要当前类型对象引⽤时使⽤。

下⾯我们根据⽰例分别讲解 this 关键字的作⽤。

this.属性名⼤部分时候,普通⽅法访问其他⽅法、成员变量时⽆须使⽤ this 前缀,但如果⽅法⾥有个局部变量和成员变量同名,但程序⼜需要在该⽅法⾥访问这个被覆盖的成员变量,则必须使⽤ this 前缀。

例 1假设有⼀个教师类 Teacher 的定义如下:1. public class Teacher {2. private String name; // 教师名称3. private double salary; // ⼯资4. private int age; // 年龄5. }在上述代码中 name、salary 和 age 的作⽤域是 private,因此在类外部⽆法对它们的值进⾏设置。

为了解决这个问题,可以为 Teacher 类添加⼀个构造⽅法,然后在构造⽅法中传递参数进⾏修改。

代码如下:1. // 创建构造⽅法,为上⾯的3个属性赋初始值2. public Teacher(String name,double salary,int age) {3. = name; // 设置教师名称4. this.salary = salary; // 设置教师⼯资5. this.age = age; // 设置教师年龄6. }在 Teacher 类的构造⽅法中使⽤了 this 关键字对属性 name、salary 和 age 赋值,this 表⽰当前对象。

=name语句表⽰⼀个赋值语句,等号左边的 是指当前对象具有的变量 name,等号右边的 name 表⽰参数传递过来的数值。

创建⼀个 main() ⽅法对 Teacher 类进⾏测试,代码如下:1. public static void main(String[] args) {2. Teacher teacher = new Teacher("王刚",5000.0,45);3. System.out.println("教师信息如下:");4. System.out.println("教师名称:"++"\n教师⼯资:"+teacher.salary+"\n教师年龄:"+teacher.age);5. }运⾏该程序,输出的结果如下所⽰。

Java中this和super的用法详解

Java中this和super的用法详解

Java中this和super的⽤法详解前⾔这次我们来回顾⼀下this和super这两个关键字的⽤法,作为⼀名Java程序员,我觉得基础是最重要的,因为它决定了我们的上限,所以我的⽂章⼤部分还是以分享Java基础知识为主,学好基础,后⾯的知识我想学起来就变得简单。

废话不多说,进⼊正⽂。

thisthis 关键字只能在⽅法内部使⽤,表⽰对调⽤⽅法的那个对象的引⽤。

其实简单来说 this 关键字就是表⽰当前对象,下⾯我们来具体介绍 this 关键字在Java中的⽤法。

1、调⽤成员变量在⼀个类的⽅法内部,如果我们想调⽤其成员变量,不⽤ this,我们会怎么做?public class ThisTest {private String name = "xiaoming";public String getName() {return name;}public void setName(String name) {name = name;}}看上⾯的代码,我们在ThisTest类中创建了⼀个name属性,然后创建了⼀个setName⽅法,注意这个⽅法的形参也是String name,那么我们通过name = name这样赋值,会改变成员变量name的属性吗?public static void main(String[] args) {ThisTest thisTest = new ThisTest();thisTest.setName("xiaoma");System.out.println(thisTest.getName());}打印结果是xiaoming,⽽不是我们重新设置的xiaoma,显然这种⽅式是不能在⽅法内部调⽤到成员变量的。

因为形参的名字和成员变量的名字相同,setName⽅法内部的name = name,根据最近原则,编译器默认是将这两个name属性都解析为形参name,从⽽导致我们设值操作和成员变量name完全没有关系,当然设置不了。

关键字this和super在Java中的应用分析

关键字this和super在Java中的应用分析

S s m. t r t (新 对 象 实 例 化 ” ; yt o . i l ” e up n n )

p bi Sr gg t a ( { u l tn eN me ) c i

p bi td n ( t n a ) u l Su e t S r gn me c i
rtm ” 名 :+hs a ; eu 姓 ” tinme .
在一个Jv 类中, aa 构造方法是一个与类 同名的方法, 必须 与类的名字相 同。而且在 Jv 类 中必须存在一个构造方法 。 aa 如果在代码中没有 显示 的体现构造方法的话 ,那么编译器在 编译的时候会 自动添加一个没有形式参数的构造方法。在一
和 sp r u 来实现 e 本文就具体来分析一下 ti和 sp r hs u 的用法 e
文章编号 :10 —9 3(0 0) 1・5 -3 0 73 7 2 1 0 20 50
什 么情况下使用它们, 如何正确它们, 该文具体 分析 ti 和 sp r hs u 的使用方法。 e
关键词 :对象
中图分类号 : P T3
文献标识码 :A
也 hs . 在 Jv 中,hs a a t 是一个 引用对象本身的指针, i 用来表示当 有 些程 序 员 即 使在 没 有 相 同 变量 的时 候 , 喜 欢 使用 ti 成 员 前 的对象 , 它只和对象有关。sp r u 关键字适用于子类访 问父 变量 的形式来引用变量。这主要是从便于代码 的阅读考虑 。 e
1ti的 主 要 用 法 及 其 含 义 hs
11使 用 ti 调用本类 中的成员变量(. hs 属性 )
在 方 法 体 内 定 义 的变 量 称 为 局 部 变 量 ,在 类 的 内部 方 法 个类中可以存在 多个构造方法 ,这些构造方法都采用相 同的 体 的 外 部 定 义 的变 量 称 为成 员变 量 。如 果 成 员变 量 和 方 法 中 名 字 ,只 是形 式 参 数 不 同 。Jv 语 言 就 凭 用 户 的 参 数来 判 断 aa 的 局 部 变 量 的 名字 相 同 时 ,那 么 在 方 法 中 成 员变 量 将 会 被 屏 调用哪一个构造方法 。当一个类 中有多个构造方法时,可以 蔽 。 果 这 个 时 候还 要 使 用成 员变 量 , 需 要 使 用 关键 字 ti。 利用 t s 如 就 hs i h 关键字相互调用, 以用 “hs参数列表) 的形式完 可 ti( ”

java中this用法总结

java中this用法总结

java中this⽤法总结1,当局部变量和成员变量重名的时候,在⽅法中使⽤this表⽰成员变量以⽰区分。

class Demo{String str = "这是成员变量";void fun(String str){System.out.println(str);System.out.println(this.str);this.str = str;System.out.println(this.str);}}public class This{public static void main(String args[]){Demo demo = new Demo();demo.fun("这是局部变量");}}分析:上⾯的类Demo中有⼀个成员变量str和⼀个局部变量str(类⽅法中的形式参数),很显然局部变量和成员变量重名,这个时候⼀般在⽅法中直接使⽤str实际上是使⽤局部变量str,对成员变量str没有任何影响,此时如果需要对成员变量做点什么,就必须使⽤this关键字。

有个问题,如果⽅法中没有str,那么在⽅法中使⽤成员变量str会是什么情况呢?实际上是⽅法内的所有操作都是针对成员变量str的。

java编程思想的84页中部有这样⼀句话:如果在⽅法内部调⽤同⼀个类的另⼀个⽅法,就不必使⽤this。

同样,在⼀个⽅法中如果没有局部变量和成员变量同名,那么在这个⽅法中使⽤成员变量也不必使⽤this,可以运⾏下⾯的代码看看。

class Demo{String str = "这是成员变量";void fun(String str1){System.out.println(str1);System.out.println(str);}}public class This{public static void main(String args[]){Demo demo = new Demo();demo.fun("这是局部变量");}}2,this关键字把当前对象传递给其他⽅法这⾥有个很经典的例⼦,就是java编程思想的85页的例⼦。

java中this的三种用法

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`。

Java语言中this关键字的用法详解_王丽丽

Java语言中this关键字的用法详解_王丽丽
由运行结果可以看出,通过n a m e=n a m e并没有正确的将内
容赋给中
的,跟类中的属性完全不沾边。
另外,这个程序代码中,有一个成员变量n a m e,同时在方
法中有个形式参数,参数名也是n a m e。然后在方法中将形式参
数name的值传递给成员变量name。虽然我们可以看明白这个代
}
public Student (String name)
{ System.out.println("新对象实例化") ; = name ;
}
public Student (String name,int age) // 通过构造方
法赋值
{
System.out.println("新对象实例化") ;
也是相同的道理。在方法体内定义的变量称为局部变量,在类的 内部方法体的外部定义的变量称为成员变量。如果成员变量和方 法中的局部变量的名字相同时,那么在方法中成员变量将会被屏 蔽。如果这个时候还要使用成员变量,就需要使用关键字t h i s。 使用this引用成员变量的方法格式:this.成员变量名。
“this(参数列表)”的形式完成,用this修改以上的代码如下:
class Student
{ private String name ; private int age ; public Student(){
System.out.println("新对象实例化") ; } public Student (String name)
示出哪一个是类中的属性,就要加上“t h i s.属性名称”的操作,
将student类的代码改进如下:
class Student { private String name;

Java中this,static,final,const用法详解

Java中this,static,final,const用法详解

Java中this,static,final,const⽤法详解⼀、this⽤类名定义⼀个变量的时候,定义的应该只是⼀个引⽤,外⾯可以通过这个引⽤来访问这个类⾥⾯的属性和⽅法,那们类⾥⾯是够也应该有⼀个引⽤来访问⾃⼰的属性和⽅法纳?JAVA提供了⼀个很好的东西,就是 this 对象,它可以在类⾥⾯来引⽤这个类的属性和⽅法。

Java关键字this只能⽤于⽅法⽅法体内。

当⼀个对象创建后,Java虚拟机(JVM)就会给这个对象分配⼀个引⽤⾃⾝的指针,这个指针的名字就是 this。

因此,this只能在类中的⾮静态⽅法中使⽤,静态⽅法和静态的代码块中绝对不能出现this,这在“Java关键字static、final 使⽤总结”⼀⽂中给出了明确解释。

并且this只和特定的对象关联,⽽不和类关联,同⼀个类的不同对象有不同的this。

总结⼀下,this主要要三种⽤法:1、表⽰对当前对象的引⽤!2、表⽰⽤类的成员变量,⽽⾮函数参数,注意在函数参数和成员变量同名是进⾏区分!其实这是第⼀种⽤法的特例,⽐较常⽤,所以那出来强⼀下。

3、⽤于在构造⽅法中引⽤满⾜指定参数类型的构造器(其实也就是构造⽅法)。

但是这⾥必须⾮常注意:只能引⽤⼀个构造⽅法且必须位于开始!注意:this不能⽤在static⽅法中!所以甚⾄有⼈给static⽅法的定义就是:没有this的⽅法!虽然夸张,但是却充分说明this不能在static⽅法中使⽤!⼆、staticstatic表⽰“全局”或者“静态”的意思,⽤来修饰成员变量和成员⽅法,也可以形成静态static代码块,但是Java语⾔中没有全局变量的概念。

被static修饰的成员变量和成员⽅法独⽴于该类的任何对象。

也就是说,它不依赖类特定的实例,被类的所有实例共享。

只要这个类被加载,Java虚拟机就能根据类名在运⾏时数据区的⽅法区内定找到他们。

因此,static对象可以在它的任何对象创建之前访问,⽆需引⽤任何对象。

this,super关键字

this,super关键字

this和super 和
• private String strain;//品种在子类中使用 在子类中使用this的前提就是 在子类中使用 的前提就是 父类中存在无参构造。 父类中存在无参构造。 • public Dog(String strain){this();父类必须存在无参 父类必须存在无参 • this.strain=strain;} • public Dog(String name1,String strain){ • super(name1);显式调用父类有参 显式调用父类有参 • this.strain=strain; } • public Dog(){ } • 如果子类的构造函数中没有通过 子类的构造函数中没有通过super显式调用父类的有 子类的构造函数中没有通过 显式调用父类的有 参构造方法,则系统默认会调用父类的无参构造方法 系统默认会调用父类的无参构造方法。 参构造方法 系统默认会调用父类的无参构造方法 this(),super()不能用于同一个构造 不能用于同一个构造因为他们都要位于构造 不能用于同一个构造 的第一条语句.
this和static的区别 和 的区别
• static修饰 修饰的属性和方法称为类属性 类变 类属性(类变 修饰 类属性 类方法.不用static修饰的属性和方法 量)和类方法 类方法 称为实例属性 实例变量 实例方法 实例属性(实例变量 实例方法。 实例属性 实例变量),实例方法 • this指的是当前实例【不能使用类方法中】。 当前实例【 当前实例 不能使用类方法中】 • 由于静态成员函数存在于类一级 静态成员函数存在于类一级,并且不 静态成员函数存在于类一级 是对象的一部分,因此没有 this 指针。在 没有 指针 静态方法中引用 this 是错误的。

java中super和this的用法

java中super和this的用法

java中super和this的用法在Java中,super和this关键字都是用来引用对象的。

它们可以用于访问类的属性、方法和构造函数。

下面将分别介绍它们的用法。

一、super关键字super关键字是用来引用父类或超类的属性、方法和构造函数。

它可以在子类中使用,以便访问父类中被隐藏或覆盖的成员。

1. 访问父类属性当子类中有与父类同名的属性时,使用super关键字可以访问父类中被隐藏的属性。

例如:```class Parent {int num = 10;}class Child extends Parent {int num = 20;void display() {System.out.println("Child num: " + num);System.out.println("Parent num: " + super.num); }}public class Test {public static void main(String[] args) {Child c = new Child();c.display();}}```输出结果为:```Child num: 20Parent num: 10```2. 调用父类方法使用super关键字可以调用父类中被覆盖或隐藏的方法。

例如:```class Parent {void display() {System.out.println("Parent display");}}class Child extends Parent {void display() {super.display();System.out.println("Child display");}}public class Test {public static void main(String[] args) {Child c = new Child();c.display();}}输出结果为:```Parent displayChild display```3. 调用父类构造函数使用super关键字可以调用父类的构造函数。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
}
}
public class B {
A a;
public B(A a) {
this.a = a;
}
public void print() {
a.print();
System.out.println("Hello from B!");
2 -> this.s = HelloWorld!
在这个例子中,构造函数Hello中,参数s与类Hello的变量s同名,这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果; 第二行是对成员变量s的打印;第三行是先对成员变量s赋传过来的参数s值后再打印,所以结果是HelloWorld!
}
}
运行结果:
Hello from A!
Hello from B!
在这个例子中,对象A的构造函数中,用new B(this)把对象A自己作为参数传递给了对象B的构造函数。
3. 注意匿名类和内部类中的中的this。
有时候,我们会用到一些内部类和匿名类,如事件处理。当在匿名类中用this时,这个this则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话,则应该加上外部类的类名。如下面这个例子:
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);
值得注意的是:
1:在构造调用另一个构造函数,调用动作必须置于最起始的位置。
2:不能在构造函数以外的任何函数内调用构造函数。
3:在一个构造函数内只能调用一个构造函数。
java中的this随处可见,用法也多,现在整理有几点:
this
1、当全局变量跟局部变量重名时,表示使用全局变量(此时this指代本类对象)
例有一类class A{
String name;
void setName(String name){
= name;

public class A {
int i = 1;
public A() {
Thread thread = new Thread() {
public void run() {
for(;;) {
//petals++;调用另一个构造函数的语句必须在最起始的位置
this(petals);
//this(ss);会产生错误,因为在一个构造函数中只能调用一个构造函数
}
}
}
}
2、构造方法相互调用,此时this指代本类类名
注意this只能放在构造方法第一句
如class B{
String name;
B(){
this("name");//会自动调用带String参数的构造方法
}
B(String name){
= name;
}
}
1. this是指当前对象自己。
当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。如下面这个例子中:
public class Hello {
String s = "Hello";
A.this.run();
try {
sleep(1000);
} catch(InterruptedException ie) { }
i++;
}
public static void main(String[] args) throws Exception {
new A();
}
}
在上面这个例子中, thread 是一个匿名类对象,在它的定义中,它的 run 函数里用到了外部类的 run 函数。这时由于函数同名,直接调用就不行了。这时有两种办法,一种就是把外部的 run 函数换一个名字,但这种办法对于一个开发到中途的应用来说是不可取的。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。
}
public static void main(String[] args) {
Hello x=new Hello("HelloWorld!");
}
}
运行结果:
s = HelloWorld!
1 -> this.s = Hello
2. 把this作为参数传递
当你要把自己作为参数传递给别的对象时,也可以用this。如:
public class A {
public A() {
new B(this).print();
}
public void print() {
System.out.println("Hello from A!");
4。在构造函数中,通过this可以调用同一class中别的构造函数,如
public class Flower{
Flower (int petals){}
Flower(String ss){}
Flower(int petals, Sting ss){
}
}
}; //注意这里有;
thread.start();
}
public void run() {
System.out.println("i = " + i);
相关文档
最新文档