java中this的用法
java中this()的用法
java中this()的用法this()是Java中的特殊语法,用于在一个类的构造函数中调用另一个构造函数。
在一个类中可以定义多个构造函数,每个构造函数可以接受不同数量或不同类型的参数。
如果我们希望在构造函数中使用另一个构造函数中的代码,则可以使用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;}}```这里我们定义了一个Person类,有4个构造函数,分别接受0个、1个或2个参数。
我们希望在任何情况下,最终都能调用一个拥有两个参数的构造函数来完成对象初始化。
这时就可以使用this(),比如在Person()构造函数中调用this("unknown", 0)来完成对象初始化。
这意味着,如果使用不带参数的构造函数创建Person对象时,实际上会在该构造函数中调用this("unknown", 0),从而调用两个参数的构造函数来完成对象初始化。
使用this()注意要点:1. this()必须在构造函数的第一行调用,因为初始化必须先完成。
2. 只能在构造函数中使用this(),其他方法不能使用。
3. this()只能调用同一个类的其他构造函数,不能调用父类或子类的构造函数。
java切点表达式语法
java切点表达式语法Java切点表达式是在使用Spring AOP(面向切面编程)时非常重要的一部分。
切点表达式用于指定在哪些方法或类上应用切面。
本文将介绍Java切点表达式的语法和用法。
切点表达式由两部分组成:切点指示器和切点设计ator。
切点指示器用于指定切点的类型,而切点设计ator用于指定切点的具体位置。
切点指示器包括以下几种类型:1. execution:用于匹配方法执行的切点。
例如,execution(* com.example.service.*.*(..))将匹配com.example.service包中所有类的所有方法。
2. within:用于匹配指定类型内的方法执行的切点。
例如,within(com.example.service.*)将匹配com.example.service包中所有类的所有方法。
3. this:用于匹配当前AOP代理对象类型的切点。
例如,this(com.example.service.SomeService)将匹配SomeService类型的所有方法。
4. target:用于匹配当前目标对象类型的切点。
例如,target(com.example.service.SomeService)将匹配SomeService类型的所有方法。
5. args:用于匹配当前方法参数类型的切点。
例如,args(ng.String)将匹配所有参数类型为String的方法。
6. @target:用于匹配当前目标对象类型具有指定注解的切点。
例如,@target(org.springframework.stereotype.Service)将匹配所有被@Service注解标记的类的方法。
7. @args:用于匹配当前方法参数类型具有指定注解的切点。
例如,@args(org.springframework.web.bind.annotation.RequestMapping)将匹配所有带有@RequestMapping注解的方法。
Java中的关键字有哪些?
Java中的关键字有哪些?1)48个关键字:abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
1.访问修饰符的关键字(3个)public(公有的):可跨包protected (受保护的):当前包内可⽤private (私有的):当前类可⽤2.定义类、接⼝、抽象类和实现接⼝、继承类的关键字、实例化对象(6个)class (类):public class A(){}花括号⾥是已实现的⽅法体,类名需要与⽂件名相同interface (接⼝):public interface B(){}花括号⾥有⽅法体,但没有实现,⽅法体句⼦后⾯是英⽂分号“;”结尾 abstract (声明抽象):public abstract class C(){}介于类与接⼝中间,可以有,也可以没有已经实现的⽅法体implements (实现):⽤于类或接⼝,实现接⼝public class A interface B(){} extends (继承):⽤于类继承类public class A extends D(){}new (创建新对象):A a=new A();A表⽰⼀个类3.包的关键字(2个)import (引⼊包的关键字):当使⽤某个包的⼀些类时,仅需要类名,即可⾃动插⼊类所在的包package (定义包的关键字):将所有相关的类放在⼀个包类以便查找修改等4.数据类型的关键字(9个)byte (字节型):8bitchar (字节型):16bitboolean (布尔型):--short (短整型):16bitint (整型):32bitfloat (浮点型):32bitlong (长整型):64bitdouble (双精度):64bitvoid (⽆返回):public void A(){}其他需要反回的经常与return连⽤5.条件循环(流程控制)(12个)if (如果) :if(条件语句{执⾏代码}如果条件语句成⽴,就开始执⾏{}⾥⾯的内容else (否则,或者) :常与if连⽤,⽤法相同:if(...){...}else{...}while (当什么时候):while(条件语句){执⾏代码}for(满⾜三个条件时):for(初始化循环变量;判断条件;循环变量值{}switch (选择结构):switch(表达式){case常量表达式1:语句1;...case常量表达式2;语句2;default:语句;}default就是如果没有匹配的case就执⾏它,default并不是必须的。
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关键字
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、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型参数的构造⽅法。
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++中调⽤⽗类的构造函数这⼏天看到类在继承时会⽤到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程序设计精编教程5-8章知识点
b) 如果变量名由多个单词组成,从第 2 个单词开始的每个单词的首字母要大写。
方法
方法的定义包括两部分:方法声明和方法体。一般格式为:
方法声明部分 {
方法体的内容
}
方法声明
方法声明包括返回值类型、方法名和参数。
double getArea() { //返回值类型为 double,无参数。
…
}
方法的返回值类型可以是 Java 中的任意数据类型。如果一个方法不返回数据,返回值类型必须是 void。
2. 有一个类 Singleton,为该类设计单例模式(该类只能有一个实例,且不能在类的外部 new 对象),只能通过该类 的静态方法 getInstance()获取该类的唯一对象。在主类 Homework2 中测试单例模式的有效性。
b) 在实例方法中,不仅可以调用实例方法,也可以调用类方法。 2) 类名调用类方法
a) 在类方法中,只能调用类方法、操作类变量。 b) 也可以通过对象调用类方法。 c) 如果一个方法不需要操作实例变量就可以实现某种功能,可以考虑将其声明为类方法。(例 5-8) 5.7 方法重载与多态 Java 中有两种多态:重载(overload)和重写(override)。 方法重载(overload):一个类中可以有多个名字相同的方法,但这些方法的参数必须不同,或者参数的个数不同, 或者参数的类型不同。方法的返回值类型与重载无关。
5.8 this 关键字 this 只能出现在实例方法和构造方法(也属于实例方法)中,表示调用该方法的当前对象。 一般情况下,方法中 this.实例变量的 this 可省略、类名.类变量的类名可省略,但当局部变量与成员变量同名时,
this 或类名不能省略。 5.9 包
包是 Java 语言管理类的一种机制,类似于操作系统中的目录,使用包名可以有效区分名字相同的类。 包语句
java中this的理解
java中this的理解
在Java中,关键字this代表当前对象的引用。
它可以用来引用当前对象的实例变量、方法和构造函数。
this关键字通常用于消除实例变量和局部变量之间的歧义,或者在构造函数中调用其他构造函数。
当一个对象被创建时,它会在内存中分配一块空间,并且在这块空间中包含了它的实例变量。
当我们在对象的方法中使用this关键字时,实际上是在引用这块内存空间。
这样就可以明确地指出我们要访问或者操作的是当前对象的实例变量,而不是方法中的局部变量。
另外,this关键字还可以用来在一个构造函数中调用另一个构造函数。
这种情况下,使用this()来调用其他构造函数,可以避免重复的初始化代码,并且可以确保所有的构造函数都会被调用到。
总之,this关键字在Java中扮演着非常重要的角色,它可以帮助我们清晰地表达出当前对象的引用,避免歧义,并且在构造函数中起到了很好的辅助作用。
对于Java程序员来说,理解和正确使用this关键字是非常重要的。
java中的this用法
java中的this用法
在Java中,this关键字有以下用法:
1. 指代当前对象:this可以用来指代当前对象,即当前方法被调用的对象。
可以使用this来调用当前对象的属性或方法。
2. 区分局部变量和成员变量:当方法的参数名或局部变量与成员变量重名时,可以通过使用this关键字来引用成员变量。
3. 作为构造器:在一个构造器内部,可以使用this关键字来调用同一类的另一个构造器。
这样可以避免重复的初始化代码。
4. 作为方法参数传递:this关键字可以作为参数传递给其他方法,以便在其他方法中使用当前对象。
5. 作为返回值:this关键字也可以作为返回值返回给调用者。
这样可以实现方法链式调用。
总的来说,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. }运⾏该程序,输出的结果如下所⽰。
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完全没有关系,当然设置不了。
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关键字的用法详解_王丽丽
容赋给中
的,跟类中的属性完全不沾边。
另外,这个程序代码中,有一个成员变量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⽤法详解⼀、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 和
• 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 ppt
栈内存
1 1 2000 7 7 1970
12
堆内存
main
d2 354752 d1 587934 i 9 ex 110925
处内存状态
值 传 递 演 示 (3)
public class Example{ public static void main(String args[]){ Example ex = new Example(); int date = 9; BirthDate d1= new BirthDate(7,7,1970); BirthDate d2= new BirthDate(1,1,2000); ex.change1(date); ex.change2(d1); ex.change3(d2); System.out.println("date=" + date); d1.display(); d2.display(); } public void change1(int i){ i = 1234;} public void change2(BirthDate b){b = new BirthDate(22,2,2004);} public void change3(BirthDate b){b.setDay(22);} }
3
方法2 方法2
形式参数: 形式参数: 在方法被调用时用于接收外界输入的数据; 实参: 实参: 调用方法时实际传给方法的数据 返回值: 返回值: 方法在执行完毕后返还给调用它的环境的数据。 返回值类型: 返回值类型: 事先约定的返回值的数据类型,如无返回值,在 Java中也必须给出返回值数据类型为void。 Java类中构造方法不能有返回值类型。
10
值 传 递 演 示 (1)
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.初始化块:不管使用哪个构造器创建对象,它都会被首先运行,在成员运行之后,然后才是构造器的主体部分被执行。
如下面的初始化块:作用是给属性赋值。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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作为参数传递
当你要把自己作为参数传递给别的对象时,也可以用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:在一个构造函数内只能调用一个构造函数。