this关键字的作用
【C#】关键字this和base比较
int num;
public BaseClane("in BaseClass()");
}
public BaseClass(int i)
{
num = i;
Console.WriteLine("in BaseClass(int {0})", num);
for (int i = 0; i < 5; i++)
{
Console.WriteLine("Friends Name: {0}", E[i]);
}
Console.ReadLine();
get { return this._age; }
}
// 打印雇员资料
public void PrintEmployee()
{
// 将Employee对象作为参数传递到DoPrint方法
Print.DoPrint(this);
Console.ReadLine();
}
}
/**//*
控制台输出:
in BaseClass()
in BaseClass(1)
*/
注意:
从静态方法中使用 base 关键字是错误的。
base 主要用于面向对象开发的对态这方面,在示例2中有体现。
+++++++++++++++++++++++++++++ 文章二 +++++++++++++++++++++++++++++
vue中的this用法
vue中的this用法Vue是一种流行的JavaScript框架,用于构建用户界面。
在Vue中,this关键字是非常常见的使用方法之一。
它用于引用当前组件实例,并提供了访问和操作组件属性和方法的能力。
本文将探讨在Vue中使用this关键字的各种用法。
1. 在Vue组件中使用this在Vue组件中,this关键字用于引用当前组件实例。
Vue组件是Vue应用程序中的基本构建块,可以将其看作是自定义HTML元素。
当我们在组件中使用this关键字时,它指的是当前的组件实例。
可以在Vue组件的生命周期钩子函数中使用this关键字。
生命周期钩子函数是在组件创建、更新和销毁的不同阶段被调用的函数。
以下是几个常用的生命周期钩子函数和它们与this的使用方法:- created: 在组件实例被创建后立即调用。
在这个钩子函数中,可以访问组件的属性和方法。
```javascriptexport default {created() {console.log(this.message); // 访问组件属性this.sayHello(); // 调用组件方法},data() {return {message: 'Hello Vue!',};},methods: {sayHello() {console.log('Hello!');},},};```- mounted: 在组件挂载到DOM后调用。
可以在这个钩子函数中执行DOM操作。
```javascriptexport default {mounted() {this.$refs.myButton.addEventListener('click', this.handleClick); },methods: {handleClick() {console.log('Button clicked!');},},};```- destroyed: 在组件实例被销毁前调用。
this关键字的作用
this关键字的作⽤java中this关键字有两个作⽤:
1.访问成员变量:在构造器或者⽅法中可以使⽤this关键字访问成员变量
2.访问构造器:可以在⽆参构造器中访问有参构造器,⽅法中不能访问构造器
public class Car {
//this关键字
String name;
String color;
//1.⽅法或者构造器中访问成员变量 2.访问构造器
public Car(){
//访问有参构造器,⽅法中不能访问构造器,this作为构造器时只能放在第⼀⾏
this("bwm","blue");
}
public Car(String name,String color){
//构造器中访问成员变量
= name;
this.color = color;
}
public void run(){
//⽅法中访问成员变量
System.out.println(+"跑起来了");
}
public static void main(String[] args) {
//访问有参构造器
Car car = new Car();//这⾥没有传⼊参数
System.out.println(+car.color);
//⽅法以及构造器中访问成员变量
Car car2 = new Car("benchi","red");
car2.run();
}
}
结果如下:
bwmblue
benchi跑起来了。
this关键字有什么作用?
this关键字有什么作用?
问题:this关键字有什么作用?回答:
this关键字表示的是“当前对象”,当出现在类的实例方法中,代表的是调用该方法的对象;当出现在类的构造方法中时,代表的是调用该构造方法创建的对象。
在下列两种情况下,必须使用this:方法的形式参数与类的成员变量同名:
例如:
class Person{
String name;
int age;
public Person(String name, int age){
=name;
this.age=age;
}
}
一个类中的构造器调用同一个类中的另一个构造器:
调用的方法:
this([参数列表]) //处于构造器的第一行位置上
例如:
class Person{
String name;
int age;
public Person(String name){
=name;
}
public Person(String name, int age){
this(name); //调用另一构造器,必须放在第一条语句位置上this.age=age;
}
}。
this的用法归纳总结
this的用法归纳总结一、this关键字的基本概念与用法在许多编程语言中都有一个关键字叫做this,它代表当前对象或者当前执行上下文。
在JavaScript中,this是一个非常重要的概念,在不同的情况下具有不同的含义和作用。
本文将对this的用法进行归纳总结,帮助读者更好地理解和使用this关键字。
1.1 this的含义和作用简单来说,this关键字用于指向当前正在执行代码的对象。
它可以在方法内部引用对象自身,并提供了一种灵活的方式来访问对象属性和调用方法。
通过使用this,我们可以避免使用硬编码来引用对象,从而使得代码更加通用和可重复使用。
1.2 this的指向问题在JavaScript中,this的指向是动态确定的,取决于函数被调用时所处的上下文。
以下列举几种常见情况:1.2.1 方法调用时:当一个函数作为某个对象的方法调用时,this指向该对象。
1.2.2 函数调用时:当一个独立函数被直接调用时(不作为对象的方法),this指向全局对象(浏览器环境下是window)。
1.2.3 构造函数创建实例时:当通过new关键字调用构造函数创建一个新的实例时,this指向新创建的对象。
1.2.4 apply和call方法调用时:当使用apply或call方法来调用函数时,通过传递上下文参数,可以手动控制this的指向。
1.3 this的常见使用场景1.3.1 在对象内部访问属性和方法:通过使用this关键字,可以直接在对象内部访问自身的属性和方法。
例如:```javascriptconst person = {name: 'Alice',sayHello() {console.log(`Hello, ${}!`);}};person.sayHello(); // 输出 "Hello, Alice!"```1.3.2 DOM事件处理函数中:当给DOM元素添加事件处理函数时,该函数中的this指向触发事件的DOM元素。
this关键字的作用
this 关键字的作用this 关键字的作用this 关键字的用法1.this 是指当前对象自己。
当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this 引用。
如下面这个例子中: 矚慫润厲钐瘗睞枥庑赖賃軔朧。
public class Hello {String s =public Hello(String s){System.out.println(System.out.println(this.s = s;System.out.println(}public static void main(String[] args) {Hello x=}}运行结果: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 作为参数传递当你要把自己作为参数传递给别的对象时,也可以用this 。
如: public class A {public A() {new B(this).print();}public void print() {System.out.println(}}public class B {A a;public B(A a) {this.a = a;}public void print() {a.print();System.out.println(}}运行结果:Hello from A!Hello from B!在这个例子中,对象 A 的构造函数中, 用new B(this) 把对象 A 自己作为参数传递给了对象 B 的构造函数。
this关键字的三种用法
this关键字的三种用法
this 关键字在编程中有以下三种用法:
1. 访问类的成员变量:在类的方法内部,通过 this 关键字可以明确地访问类的成员变量,解决与局部变量冲突的问题。
在上述代码中,有两个 age 变量,一个是类的成员变量,一个是构造方法的局部变量,this.age 使用的就是成员变量,而单单一个 age 则是指局部变量。
2. 在构造方法中调用其他构造方法:因为构造方法是在实例化对象时,被 Java 虚拟机自动调用的,所以构造方法无法像其他方法一样自由地调用,这时可以使用 this 关键字在一个构造方法中调用其他构造方法。
3. 调用成员方法:this 关键字可以表示对当前对象的引用,因此可以调用当前类的普通方法。
在实际使用中,this 关键字的用法可能会根据编程语言和具体的上下文而有所不同。
在使用时,需要根据具体情况来确定正确的用法。
this关键字的用法
this关键字的用法This关键字是Java语言中的一个重要的概念。
它的出现使得Java的开发更加容易、维护更加简单,使得我们在开发时更有效率。
本文将详细介绍This关键字的用法,以及它能实现的一些功能。
This关键字是Java语言中常见的一个关键字,主要用于引用所在类的实例和成员变量。
This关键字代表正在执行的这个方法的对象。
它在发送消息时,可以调用对象本身的方法和属性,它也可以将对象作为参数传递给其他方法,而不用写出完全限定的类名。
This关键字的第一个用途是引用当前对象本身的实例变量。
在定义类的成员变量时,有时可能会出现声明变量的变量名和形参变量名相同的情况,因此为了区分二者,可以使用This来引用成员变量,以此来避免歧义。
This关键字的第二个用途是引用当前类的实例。
它可以在构造函数中调用另外一个构造函数,也可以在方法中调用另外一个方法,以此来抽象出公共的代码,消除冗余,提高代码的可维护性。
This关键字的第三个用途是用于封装数据。
这种方法可以有效地将类的数据封装起来,并可以对外提供对类的访问接口,同时避免直接对类的实例变量进行访问,减少程序运行时可能出现的错误和缺陷。
以上是This关键字的用法,总结起来有以下几点:1. This关键字代表正在执行的这个方法的对象;2. This可以用来引用当前对象本身的实例变量;3. This可以用来引用当前类的实例;4. This可以用于封装数据,减少程序运行时可能出现的错误和缺陷。
This关键字在Java语言中具有重要的地位,它可以提高代码的可维护性,让开发工作更加有效率,同时也可以减少程序运行时可能出现的错误和缺陷。
因此,This关键字在Java语言中占有重要地位,应该得到更多的关注和重视。
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可以作为一个类中构造器相互调用的特殊格式。
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. }运⾏该程序,输出的结果如下所⽰。
vue中的this用法
vue中的this用法Vue是一种流行的JavaScript框架,用于构建用户界面。
在Vue中,this是一个非常重要的关键字,用于引用当前组件实例。
本文将介绍Vue中this的不同用法和示例。
1. 访问数据在Vue组件中,数据通常存储在data对象中。
使用this关键字,我们可以访问和操作data中的属性。
下面是一个例子:```javascript<template><div><p>{{ message }}</p><button @click="changeMessage">Change Message</button></div></template><script>export default {data() {return {message: 'Hello Vue!'}},methods: {changeMessage() {this.message = 'Hello World!'}}}</script>```在上面的例子中,this.message引用了data中的message属性。
当点击按钮时,changeMessage方法被调用,修改message的值为'Hello World!'。
2. 调用方法在Vue组件中,我们可以在methods对象中定义各种方法。
通过this关键字,我们可以在组件中调用这些方法。
下面是一个例子:```javascript<template><div><p>{{ message }}</p><button @click="changeMessage">Change Message</button> </div></template><script>export default {data() {return {message: 'Hello Vue!'}},methods: {changeMessage() {this.updateMessage('Hello World!')},updateMessage(newMessage) {this.message = newMessage}}}</script>```在上面的例子中,changeMessage方法通过调用updateMessage方法来更新message的值。
this关键字
this关键字this代表它所在函数所属对象的引⽤。
简单说:哪个对象在调⽤this所在的函数,this就代表哪个对象。
this关键字主要有以下三个作⽤:this调⽤本类中的属性,也就是类中的成员变量;this调⽤本类中的其他⽅法;this调⽤本类中的其他构造⽅法,调⽤时要放在构造⽅法的⾸⾏。
(this语句只能定义在构造函数的第⼀⾏,因为在初始化时须先执⾏)this关键字的基本⽤法引⽤成员变量public class Person{String name; //定义成员变量nameprivate void SetName(String name) { //定义⼀个参数(局部变量)name=name; //将局部变量的值传递给成员变量}}如上⾯这段代码中,Person类中有⼀个成员变量name,同时在SetName⽅法中有⼀个形式参数,名字也是name,然后在⽅法中将形式参数name的值传递给成员变量nam。
虽然我们可以看明⽩这个代码的含义,但是作为Java编译器它是怎么判断的呢?到底是将形式参数name的值传递给成员变量name,还是反过来将成员变量name的值传递给形式参数name呢?也就是说,两个变量名字如果相同的话,那么Java如何判断使⽤哪个变量?此时this这个关键字就起到作⽤了。
this这个关键字其代表的就是对象中的成员变量或者⽅法。
也就是说,如果在某个变量前⾯加上⼀个this 关键字,其指的就是这个对象的成员变量或者⽅法,⽽不是指成员⽅法的形式参数或者局部变量。
因此在上述代码中,代表的就是对象中的成员变量,⼜叫做对象的属性,⽽后⾯的name则是⽅法的形式参数,代码=name就是将形式参数的值传递给this指向对象的成员变量。
⼀看到这个this关键字就知道现在引⽤的变量是成员变量或者成员⽅法,⽽不是局部变量。
这⽆形中就提⾼了代码的阅读性。
调⽤类的构造器⽅法public class Person {public Person(){ //⽆参构造器⽅法this(“Hello!”);}public Person(String name){ //定义⼀个带形式参数的构造⽅法}}在上述代码中,定义了两个构造⽅法,⼀个带参数,另⼀个没有带参数。
this指向的理解
this指向的理解在JavaScript中,`this`关键字是一个特殊关键字,用于引用当前正在作用的对象。
它是JavaScript中操作DOM对象和函数时的一个重要概念。
`this`关键字在作用域中的位置非常重要。
只有在函数定义中使用`this`,它才会指向当前函数所在的作用域。
如果在函数体中使用`this`,则`this`会指向函数体本身。
下面是一个简单的示例,说明`this`关键字在作用域中的用法: ```javascriptfunction myFunction() {console.log("this is within myFunction");}myFunction(); // this is within myFunction```在上面的示例中,`.myFunction()`本身是一个函数调用,`this`会指向函数调用本身。
当函数调用`myFunction()`时,`this`也会指向函数调用本身。
另一个示例是:```javascriptfunction myFunction() {console.log("this is within myFunction");}myFunction.call(this); // this is within myFunction```在这个示例中,`myFunction.call(this)`将函数call到`myFunction`对象上,并将`this`指向调用的函数本身。
除了使用`call()`和`apply()`方法之外,`this`关键字还可以通过属性引用来访问对象的属性。
例如:```javascriptfunction myFunction() {console.log("this is within myFunction"); = "John";} = "Jane"; // this is within myFunction ```在这个示例中,我们将``更改为`"Jane"`。
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 是错误的。
第五章:this关键字的用法
this关键字this可以强调用的是本类中的方法,还可以表示类中的属性、可以使用this调用本类中的方法、this表示当前的对象。
一.使用this调用本类中的属性在程序中可以使用this调用本类属性class Preason{private String name;private int age;public void Preason(String n,int a){name=n;age=a;}public String getInfo(){return "姓名:"+name+",年龄:"+age;}}在此构造方法中目的很明确,就是为类中的属性赋值,但是从构造方法的传递参数很难看出参数n和a的意义,所以为了可以清楚的表示参数的意义,可以进行如下修改:class Preason{private String name;private int age;public void Preason(String name,int age){name=name;age=age;}public String getInfo(){return "姓名:"+name+",年龄:"+age;}}此时可以从参数的名称中看出其真实意义,要传递的第一个参数是姓名,第二个参数是年龄,但是构造方法内部会出现错误,运行结果为:姓名:null,年龄:0从程序运行结果中可以发现,姓名为null,年龄为0,并没有把构造方法传递进去的参数值赋给属性,那么就证明现在的构造方法并不能成功的把传递进去的值赋值给类中的属性。
由于在赋值时属性并不是明确地被指出,所以造成此错误,而之中错误就可以用this关键字来解决。
代码修改如下:class Person{private String name;private int age;public Person(){}public Person(String name,int age){=name;this.age=age;}public String getInfo(){return "姓名:"++",年龄:"+this.age;}}public class ThisDemo01{public static void main(String[] args){Person per1=new Person("张三",30);System.out.println(per1.getInfo());}}运行结果:姓名:张三,年龄:30从结果来看,程序的目的达到了。
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关键字可以调用父类的构造函数。
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关键字的使用
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;}}。
this关键字的使用
this关键字的使⽤this关键字介绍:this关键字的使⽤:1.this可以⽤来修饰或者调⽤:属性、⽅法、构造器2.this修饰属性和⽅法:理解为:当前对象。
当修饰构造器的时候:理解为当前正在创造的对象在类的⽅法中,我们可以使⽤“this.属性”或者“this.⽅法”的⽅式,调⽤当前对象属性或⽅法。
但是通常情况下我们都选择省略“this.”。
特殊的:如果⽅法的形参和类的属性同名时,必须使⽤this关键字(this.变量),表明此变量是属性,⽽⾮形参。
在类的构造器中,我们可以使⽤“this.属性”或者“this.⽅法”的⽅式,调⽤当前对象属性或⽅法。
但是通常情况下我们都选择省略“this.”。
特殊的:如果构造器的形参和类的属性同名时,必须使⽤this关键字(this.变量),表明此变量是属性,⽽⾮形参。
this可以在⽅法⾥⾯调⽅法,构造器⾥⾯调构造器this()我们在类的构造器中,可以显⽰的使⽤“this(形参列表)”⽅式,调⽤本类中指定的其他构造器构造器中不能通过“this(形参列表)”⽅式调⽤⾃⼰如果⼀个类中有n个构造器,则最多有n-1构造器中使⽤了“this(形参列表)”规定:“this(形参列表)”必须声明在当前构造器的⾸⾏构造器内部,最多只能声明⼀个“this(形参列表)”,⽤来调⽤其他构造器package com.myobjectoriented01.nonworking;public class Person10 {private String name;private int age;public Person10() {}public Person10(int age) {this.age=age;}public Person10(String name,int age) {this(age);=name;}public String getName() {return name;}public int getAge() {return age;}}package com.myobjectoriented01.nonworking;public class Person10Text {public static void main(String[] args) {Person10 p1=new Person10("lily",20);System.out.println(p1.getAge()+p1.getName());}}题⽬⼀:Boy类的代码:package com.myobjectoriented.nonworking;/**** @Desciption* @author Abraham* @email 1290807550@* @version JDK1.8* @date 2021年3⽉24⽇下午4:48:33*/public class Boy {private String name;private int age;public Boy(String name,int age) {=name;this.age=age;}public void setName(String name) {=name;}public String getName() {return ;}public void setAge(int age) {this.age=age;}public int getAge() {return this.age;}public void marry(Girl girl) {System.out.println("我想娶"+girl.getName());}public void shout(int age) {if(this.age>22) {System.out.println("我想结婚!");}else {System.out.println("年纪不够,再去打打酱油");} }}Girl类的代码:package com.myobjectoriented.nonworking;/**** @Desciption* @author Abraham* @email 1290807550@* @version JDK1.8* @date 2021年3⽉24⽇下午4:48:39*/public class Girl {private String name;private int age;public Girl(String name,int age) {=name;this.age=age;}public void setName(String name) {=name;}public String getName() {return ;}public void marry(Boy boy) {System.out.println("我想嫁给"+boy.getName());boy.marry(this);}public void compare(Girl girl) {if(this.age>girl.age) {System.out.println("我⼤");}else if(this.age<girl.age){ System.out.println("她⼤");}else System.out.println("⼀样⼤");}}测试类的代码:package com.myobjectoriented.nonworking;/**** @Desciption* @author Abraham* @email 1290807550@* @version JDK1.8* @date 2021年3⽉24⽇下午5:20:04*/public class BoyGirlText {public static void main(String[] args) {Boy boy=new Boy("梁⼭伯",25);boy.shout(25);System.out.println(boy.getAge());Girl girl=new Girl("祝英台",23);//boy.marry(girl);girl.marry(boy);Girl girl01=new Girl("苍⽼师",23);pare(girl01);}}银⾏账户练习题⽬:先造⼀个银⾏账户的类package com.myobjectoriented.nonworking;/**** @Desciption* @author Abraham* @email 1290807550@* @version JDK1.8* @date 2021年3⽉24⽇下午5:48:36*/public class BankAccount {private int ID;//账户名private double balance;//余额private double annualInterestRate;//年利率public BankAccount(int ID,double balance,double annualInterestRate) {//构造器:直接传递客户信息 this.ID=ID;this.balance=balance;this.annualInterestRate=annualInterestRate;}public int getID() {return this.ID;}public double getbalance() {return this.balance;}public double getannualInterestRate() {return this.annualInterestRate;}public void setID(int ID) {this.ID=ID;}public void setbalance(double balance) {this.balance=balance;}public void setannualInterestRate(double annualInterestRate) {this.annualInterestRate=annualInterestRate;}public void withdraw(double amount) {//取钱if(amount>balance) {System.out.println("余额不⾜,取款失败!");return;}this.balance-=amount;System.out.println("成功取出"+amount+"元");}public void deposit(double amount) {//存钱this.balance+=amount;System.out.println("成功存⼊"+amount+"元");}public void printBankAccountMoney(){System.out.println("当前账户余额为:"+balance);}}然后造⼀个客户的类package com.myobjectoriented.nonworking;/**** @Desciption* @author Abraham* @email 1290807550@* @version JDK1.8* @date 2021年3⽉24⽇下午7:37:29*/public class Customer {private String firstName;private String lastName;private BankAccount account;public Customer(String f,String l) {firstName=f;lastName=l;}public String getFirstname() {return this.firstName;}public String getLastname() {return stName;}public BankAccount getBankAccount() {return account;}public void setBankAccount(BankAccount account) {this.account=account;}public void customerinfomation() {System.out.println("客户名:"+firstName+" "+lastName+" "+"账户名:"+account.getID()+" "+"账户余额:"+account.getbalance()+" "+"当前利率:"+account.getannualInterestRate()); }}最后造⼀个案例类:package com.myobjectoriented.nonworking;public class Customertext {public static void main(String[] args) {Customer customer=new Customer("Jane","Smith");BankAccount accountJane=new BankAccount(1000,2000,0.0123);//下⾯三⾏是错误写法,不需要这么⿇烦//customer.getBankAccount().setID(1000);//customer.getBankAccount().setbalance(2000);//customer.getBankAccount().setannualInterestRate(0.0123);customer.setBankAccount(accountJane);customer.getBankAccount().deposit(100);customer.getBankAccount().withdraw(960);customer.getBankAccount().withdraw(2000);customer.customerinfomation();}}package com.myobjectoriented11.nonworking;public class Account {private double balance;//余额public Account(double init_balance) {//初始化余额this.balance=init_balance;}public double getBalance() {return this.balance;}public void deposit(double money) {if(money>0) {this.balance+=money;System.out.println("成功存⼊款项"+money+"元,"+"当前账户余额为:"+this.balance+"元。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
this关键字的作用
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作为参数传递
当你要把自己作为参数传递给别的对象时,也可以用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。
有时候,我们会用到一些内部类和匿名类,如事件处理。
当在匿?嘀杏胻his时,这个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。
4.在构造函数中,通过this可以调用同一class中别的构造函数,如
public class Flower{
Flower (int petals){}
Flower(String ss){}
Flower(int petals, Sting ss){
//petals++;调用另一个构造函数的语句必须在最起始的位置
this(petals);
//this(ss);会产生错误,因为在一个构造函数中只能调用一个构造函数
}
}
值得注意的是:
1:在构造调用另一个构造函数,调用动作必须置于最起始的位置。
2:不能在构造函数以外的任何函数内调用构造函数。
3:在一个构造函数内只能调用一个构造函数。