JAVA中this用法(1)

我知道很多朋友都和我一样：在JA V A程序中似乎经常见到“this”，自己也偶尔用到它，但是到底“this”该怎么用，却心中无数！很多人一提起它，就说“当前对象”，可到底什么是当前对象，是什么当前对象，他自己也不清楚。现在让大家看一个小例子，给你分享一下JA V A中“this”的用法！

/**

* @author fengzhi-neusoft

* * 本示例为了说明this的三种用法！

*/

package test;

public class ThisTest {

private int i=0;

//第一个构造器：有一个int型形参

ThisTest(int i){

this.i=i+1;//此时this表示引用成员变量ｉ，而非函数参数ｉ

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基础上ｉ++的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主要要三种用法：

１、表示对当前对象的引用！

２、表示用类的成员变量，而非函数参数，注意在函数参数和成员变量同名是进行区分！其实这是第一种用法的特例，比较常用，所以那出来强调一下。

３、用于在构造方法中引用满足指定参数类型的构造器（其实也就是构造方法）。但是这里必须非常注意：只能引用一个构造方法且必须位于开始！

还有就是注意：this不能用在static方法中！所以甚至有人给static方法的定义就是：没有this 的方法！虽然夸张，但是却充分说明this不能在static方法中使用！

使用this调用本类中的属性

现在观察以下代码，看会有那些问题：

public void setName(String name){

name = name ;

}

这里面的两个name都是setName方法中的name参数。

此时，特别希望可以通过一个指定的标识明确的表示要把传入的name参数的值给类中的属性，所以此时就需要使用this关键字，使用https://www.wendangku.net/doc/f510997025.html,就表示类中的属性。

class Person{

private String name ;

private int age ;

public Person(String name,int age){

this.setName(name) ;

this.setAge(age) ;

}

public void setName(String name){

https://www.wendangku.net/doc/f510997025.html, = name ;

}

public void setAge(int age){

this.age = age ;

}

public String getName(){

return https://www.wendangku.net/doc/f510997025.html, ;

}

public int getAge(){

return this.age ;

}

public void print(){

System.out.println("姓名："+https://www.wendangku.net/doc/f510997025.html,+"，年龄："+this.age) ; }

};

public class Demo35{

public static void main(String args[]){

Person p1 = new Person("张三",30) ;

p1.print() ;

}

};

使用this还可以从一个构造方法中调用其他构造方法。

例如：有以下一个要求，一个类中存在了三个构造方法，但是要求，不管怎么调用，最终都要求可以在对象实例化的时候打印一个“新的对象产生了”的提示。

class Person{

private String name ;

private int age ;

public Person(){

System.out.println("新的对象产生了。。。") ;

}

public Person(String name){

System.out.println("新的对象产生了。。。") ;

this.setName(name) ;

}

public Person(String name,int age){

System.out.println("新的对象产生了。。。") ;

this.setName(name) ;

this.setAge(age) ;

}

public void setName(String name){

https://www.wendangku.net/doc/f510997025.html, = name ;

}

public void setAge(int age){

this.age = age ;

}

public String getName(){

return https://www.wendangku.net/doc/f510997025.html, ;

}

public int getAge(){

return this.age ;

}

public void print(){

System.out.println("姓名："+https://www.wendangku.net/doc/f510997025.html,+"，年龄："+this.age) ;

}

};

以上代码虽然可以实现功能，但是同样的代码出现了三次，而且后面的两次出现纯属多余吧。用this()的形式可以调用类中的无参构造方法。

class Person{

private String name ;

private int age ;

public Person(){

System.out.println("新的对象产生了。。。") ;

}

public Person(String name){

// 最终都是调用无参构造方法

this() ;

this.setName(name) ;

public Person(String name,int age){

this(name) ;

this.setAge(age) ;

}

public void setName(String name){

https://www.wendangku.net/doc/f510997025.html, = name ;

}

public void setAge(int age){

this.age = age ;

}

public String getName(){

return https://www.wendangku.net/doc/f510997025.html, ;

}

public int getAge(){

return this.age ;

}

public void print(){

System.out.println("姓名："+https://www.wendangku.net/doc/f510997025.html,+"，年龄："+this.age) ; }

};

public class Demo36{

public static void main(String args[]){

Person p1 = new Person("张三",30) ;

p1.print() ;

}

};

注意点1：

如果使用了this调用其他构造方法，则此语句，必须写在构造方法的首行。

public void fun(){

// 发现在调用fun方法的时候，必须先设置name的值

this("zhangsan") ;

}

public Person(String name,int age){

this.setAge(age) ;

this(name) ; //--> 必须放在首行

}

注意点2：

使用this可以调用本类中的其他构造方法，但是至少留一个构造方法，作为程序的出口。public Person(){

this("a",10) ;

System.out.println("新的对象产生了。。。") ;

}

public Person(String name){

// 最终都是调用无参构造方法

this() ;

this.setName(name) ;

}

public Person(String name,int age){

this(name) ; //--> 必须放在首行

this.setAge(age) ;

}

this最重要的特性——表示当前对象

当前对象在程序中用以下形式体现：

·当前操作此方法的对象，就称为当前对象。class Demo{

public void print(){

System.out.println(this) ;

}

};

public class Demo38{

public static void main(String args[]){

Demo d1 = new Demo() ;

System.out.println(d1) ;

d1.print() ;

System.out.println("---------------------") ;

Demo d2 = new Demo() ;

System.out.println(d2) ;

d2.print() ;

}

};

回顾：

之前讲解的两个对象比较的程序。

// 在类的内部增加一个比较的方法

public boolean compare(Person p){

Person p1 = this ;

Person p2 = p ;

if(https://www.wendangku.net/doc/f510997025.html,.equals(https://www.wendangku.net/doc/f510997025.html,)&&p1.age==p2.age){ return true ;

}else{

return false ;

}

}

分析程序的运行过程：

class A{

private B b = null ;

public A(){

this.b = new B(this) ;

this.b.fun() ;

}

public void hello(){

System.out.println("Hello World!!!") ; }

};

class B{

private A a = null ;

public B(A a){

this.a = a ;

}

public void fun(){

this.a.hello() ;

}

};

public class OODemo40{

public static void main(String args[]){ A aa = new A() ;

}

};

this关键字的作用

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() {

Java中this、super用法

通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。 好了，现在开始讨论this&super这两个关键字的意义和用法。 在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。 在一般方法中 最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法： public class DemoThis{ private String name; private int age; DemoThis(String name,int age){ setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的 setAge(age); this.print(); br> } public void setName(String name){ https://www.wendangku.net/doc/f510997025.html,=name;//此处必须指明你要引用成员变量 } public void etAge(int age){ this.age=age; } public void print(){ System.out.println("Name="+name+" ge="+age); //在此行中并不需要用this，因为没有会导致混淆的东西 } public static void main(String[] args){ DemoThis dt=new DemoThis("Kevin","22"); 这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(), 你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super 的用法。 class Person{ public int c; private String name; private int age;

Java基础阶段复习题2

复习题2 如有雷同，纯属巧合！ 1.下列哪一种叙述是正确的(D) A. abstract修饰符可修饰字段、方法和类 B.抽象方法的body部分必须用一对大括号{ }包住 C.声明抽象方法，大括号可有可无 D.声明抽象方法不可写出大括号 2.下列说法正确的有(C) A. class中的constructor不可省略 B. constructor必须与class同名，但方法不能与class同名 C. constructor在一个对象被new时执行 D.一个class只能定义一个constructor 3.以下哪个表达式是不合法的（ A ） A、String x=”Hello”; int y=9; x+=y; B、String x=”Hello”; int y=9; if(x= =y) { } C、String x=”Hello”; int y=9; x=x+y; D、String x=null; int y=(x!=null)&&(x.length()>0) ? x.length() : 0 4.下列关于修饰符混用的说法，错误的是（C ） A．abstract不能与final并列修饰同一个类 B．abstract类中不可以有private的成员 C．abstract方法必须在abstract类中 D．static方法中能处理非static的属性 5.（B）修饰符允许对类成员的访问不依赖于该类的任何对象 A、abstract B、static C、return D、public 6.关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ C ） A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类 B．可以被两种类访问和引用：该类本身、该类的所有子类 C．只能被该类自身所访问和修改 D．只能被同一个包中的类访问

C# this关键字详解

在向大家详细介绍C# this关键字之前，首先让大家了解下类与对象的区分，然后全面介绍C# this 关键字。 类与对象的区分对我们把握OO编程至关重要。我们说类是对其成员的一种封装，但类的封装设计仅仅是我们编程的第一步，对类进行对象实例化，并在其数据成员上实施操作才是我们完成现实任务的根本。实例化对象采用MyClass myObject=new MyClass()语法，这里的new语义将调用相应的构建器。C#所有的对象都将创建在托管堆上。实例化后的类型我们称之为对象，其核心特征便是拥有了一份自己特有的数据成员拷贝。这些为特有的对象所持有的数据成员我们称之为实例成员。相反那些不为特有的对象所持有的数据成员我们称之为静态成员，在类中用static修饰符声明。仅对静态数据成员实施操作的称为静态函数成员。C#中静态数据成员和函数成员只能通过类名引用获取，看下面的代码： https://www.wendangku.net/doc/f510997025.html,ing System; 2.class A 3.{ 4.public int count; 5.public void F() 6.{ 7.Console.WriteLine(this.count); 8.} 9. 10.public static string name; 11.public static void G() 12.{ 13.Console.WriteLine(name); 14.} 15.} 16.class Test 17.{ 18.public static void Main() 19.{ 20.A a1=new A(); 21.A a2=new A(); 22.a1.F(); 23.a1.count=1; 24.a2.F(); 25.a2.count=2; 26. https://www.wendangku.net/doc/f510997025.html,="CCW"; 28.A.G(); 29.} 30.}

java里面synchronized用法

java里面synchronized用法 在java编程思想中对synchronized的一点解释: 1、synchronized关键字的作用域有二种： 1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的 synchronized 方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。 2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法 中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法； --------------------------------------------------------------------- ------- java里面synchronized用法 synchronized的一个简单例子 public class TextThread { /** * @param args */ public static void main(String[] args) { // TODO 自动生成方法存根 TxtThread tt = new TxtThread(); new Thread(tt).start(); new Thread(tt).start(); new Thread(tt).start(); new Thread(tt).start();

Java中super的几种用法并与this的区别

4．super和this的异同： 1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句） 2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句） 3)super:它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名super.成员函数据名（实参） 4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名） 5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。 6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。 7）super()和this()均需放在构造方法内第一行。 8）尽管可以用this调用一个构造器，但却不能调用两个。 9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。 10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static 变量,static方法，static语句块。 11）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。1.静态方法 通常，在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法声明为static的方法有以下几条限制： 1）它们仅能调用其他的static 方法。 2）它们只能访问static数据。 3）它们不能以任何方式引用this 或super。 class Simple { static void Go() { System.out.println("Welcome"); } } public class Cal { public static void main(String[] args) { Simple.go(); } } 调用一个静态方法就是“类名.方法名”,静态方法的使用很简单如上所示。一般来说，静态方法常常为应用程序中的其它类提供一些实用工具所用，在Java的类库中大量的静态方法正是出于此目的而定义的。 2. 静态变量 声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。静态变量与静态方法类似。所有此类实例

java中常用关键字总结

Java中的关键字总结 final 关键字 1、用final修饰的类不能被继承，没有子类； 2、用final修饰的方法，方法不能被重写； 3、用final修饰变量，变量的值不能被修改，表示常量，(书写规范：全部字母都要大写；多个单词，可以使用下划线（_）分开；) 注意：如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错；如果被final修饰的变量是一个引用类型的数据，那么通过这个引用改变堆空间中的数据，不会报错； 4、final用于成员变量表示该成员变量为常量，不能被修改，必须在变量定义时赋值。 5、final用于局部变量表示该局部变量为常量，不能被修改，可以在变量定义时赋值，也可以先定义变量后赋值。 什么时候用final关键字? 有的时候不想别人重写我的方法就使用final关键字修饰该方法； static关键字 1、static用于成员变量表示该变量只有一份，也就是说静态成员变量属于类而不属于某个具体的类实例对象，所有的类实例对象共享这个静态成员变量；静态函数是不需要对象的，直接可以使用类名来调用； 2、非静态函数可以调用静态函数；静态函数不能调用非静态函数（非静态函数都是通过对象调用的）；静态函数不能使用非静态成员变量，但可以使用静态成员变量； 3、静态函数调用时不需要对象的，所以不能使用和对象有关的关键字；(this；super；) 4、构造函数不能使用static修饰(构造函数是创建对象，开辟空间，给所有成员变量赋默认值之后，有JVM调用进栈，用来给对象的成员变量赋初始值的) static用于类，这里指的是内部类，那么在别的地方就可以通过外部类名来引用这个静态的内部类。 5、static还可以用于类的代码块，叫做静态代码块，静态代码块在类加载的时候就执行完毕，而类只加载一次；是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先

this关键字的含义

this关键字的含义 问题：this关键字的含义回答： this是一个保留字，仅限于构造函数和方法成员中使用 在类的构造函数中出现表示对正在构造的对象本身的引用，在类的方法中出现表示对调用该方法的对象的引用，在结构的构造上函数中出现表示对正在构造的结构的引用，在结构的方法中出现表示对调用该方法的结果的引用 this保留字不能用于静态成员的实现里，因为这时对象或结构并未实例化 在C# 系统中，this 实际上是一个常量，所以不能使用this++ 这样的运算 this保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身 示例： using System; using System.Collections.Generic; using System.Text; namespace Example10 { class Class1

private double c; private string value; public double C { get { return c; } } public Class1(double c) { //限定同名的隐藏成员 this.c = c; } public Class1(Class1 value) { //用对象本身实例化自己没有意义if (this != value) { c = value.C; }

public override string ToString() { //将对象本身做为参数 return string.Format(“{0} Celsius = {1} Fahrenheit”, c, UnitTransClass.C2F(this)); } //由于好奇，在这做了一个效率测试，想看看到底哪种方式访问成员变量更快，结论：区别不大。。。 public string Test1() { long vTickCount = Environment.TickCount; for (int i = 0; i this.value = i.ToString(); return string.Format(“Have this.: {0} MSEL”, Environment.TickCount –vTickCount); } public string Test2() { long vTickCount = Environment.TickCount; for (int i = 0; i value = i.ToString();

java中的关键字的含义及介绍

Java中的键字？ 才发现Java中的好多关键字都不知道什么意思，特转一遍过来。 Java保留关键字 Java语言有51个关键字，其中const和goto虽然被保留但未使用。你不能使用保留关键字来命名类、方法或变量。 一、保留关键字 1、数据类型： Boolean int long short byte float double char class interface 2、流程控制： if else do while for switch case default break continue return try catch finally 3、修饰符： public protected private final void static strictfp abstract transient synchronized volatile native 4、动作： package import throw throws extends implements this Super instanceof new 5、保留字： true false null goto const 二、访问修饰符： 访问修饰符：public , protected , private * 只能应用于类的成员变量。（局部变量只能在函数的范围内可见，不能使用访问修饰符） * 能够用来修饰类本身。（protected , private 不能用于顶级类，只能用于内部类） * 能够应用于成员方法和构造函数。 下面是一个例子： package Examples; public class HelloWorld02{ //以下定义了三个了类成员变量 public String str1="Hello"; //可被你程序中的任何其他代码访问 protected String str2="World!"; //程序中同一包的成员和不同包中的该类子类可以访问 private String str3=" "; //仅该类中的成员可以访问 String str=str1+str3+str2; //不使用修饰符的话，变量的访问控制在所在包内为public， // 不能被所在包外的代码存取 //以下定义了三个使用不同修饰符和不同参数的构造方法。

static和this的理解和用法总结

static和this的理解和用法小结 关键字static和this是初学者比较头疼的知识点，自己也一直比较模糊．现在整理一下，既可以加深自己的印象也可以便于以后查询． 其实在think in java里关于为什么要使用static写的比较详细，不明白的多读几遍会有很大的收获．一般在两钟情形下需要使用static关键字：一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。另一种情形是我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。一旦将什么东西设为static，数据或方法就不会同那个类的任何对象实例联系到一起.所以尽管从未创建那个类的一个对象，仍能调用一个static方法，或访问一些static数据。而在这之前，对于非static数据和方法，我们必须创建一个对象，并用那个对象访问数据或方法。这是由于非static数据和方法必须知道它们操作的具体对象.有这样的一个类，其中定义一个静态数据： class Test { Static int i = 47; } Test st1 = new StaticTest();Test st2 = new StaticTest();即使们new了两个Test对象,但它们仍然只占据Test.i的一个存储空间。这两个对象都共享同样的i。对方法来说，static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法. 静态变量）一个静态对象属于一个类，但它不属于实例对象，也不是实例对象状态的一部分．每一个静态变量只存在一份．静态变量通常称为类变量（class variable)．在实际中，经常需要这样的一个变量，它被一个类的所有实例对象所共享，如果它同时又是公有的，那么它就可以被这个类的任意访问者所使用．静态变量存在于类的作用域之内．通常声明为private.java中许多时候会用到public static final 这样的变量。静态变量可以被位于同一个作用域内的任意方或静态方法访问，访问时使用变量名称即可。如果在类作用域以外访问类，则要使用一个含有类名的表达式访问静态变量，例如： Integer.MAX_VALUE, 其中MAX_VALUE是在类库中声明过的。 静态方法）静态方法或类方法属于一个而不是属于某个实例对象实现的一部分。可以直接通过类来调用这种方法，而并不是只能由某个特定的实例对象调用。静态的方法不能用abstract声明，而且无论是否明确地指定实际上都是final型的。静态方法的声明格式： modifiers static typeName methodName (parameterList){ statementSequence } modifiers(可以从public,protect,private中选择一个），后面可以加上 final,nativc,synchronized中的一个或几个的组合。 static main是静态方法的一个特殊用法，用static main 方法来建立程序的初始状态，创建一组初始对象，并进行合理的方法调用，使得程序能够继续执行下去，static main方法使用String数组型参数包含了用户在运行时给出的任意命令行参数。

深入浅出关键字---base和this

本文将介绍以下内容： ?面向对象基本概念 ?base关键字深入浅出 ?this关键字深入浅出 1. 引言 new关键字引起了大家的不少关注，尤其感谢Anders Liu的补充，让我感觉博客园赋予的交流平台真的无所不在。所以，我们就有必要继续这个话题，把我认为最值得关注的关键字开展下去，本文的重点是访问关键字（Access Keywords）：base和this。虽然访问关键字不是很难理解的话题，我们还是有可以深入讨论的地方来理清思路。还是老办法，我的问题先列出来，您是否做好了准备。 1.是否可以在静态方法中使用base和this，为什么？ 2.base常用于哪些方面？this常用于哪些方面？ 3.可以base访问基类的一切成员吗？ 4.如果有三层或者更多继承，那么最下级派生类的base指向那一层呢？例 如.NET体系中，如果以base访问，则应该是直接父类实例呢，还是最高 层类实例呢？ 5.以base和this应用于构造函数时，继承类对象实例化的执行顺序如何？ 2. 基本概念 base和this在C#中被归于访问关键字，顾名思义，就是用于实现继承机制的访问操作，来满足对对象成员的访问，从而为多态机制提供更加灵活的处理方式。 2.1 base关键字 其用于在派生类中实现对基类公有或者受保护成员的访问，但是只局限在构造函数、实例方法和实例属性访问器中，MSDN中小结的具体功能包括：?调用基类上已被其他方法重写的方法。 ?指定创建派生类实例时应调用的基类构造函数。 2.2 this关键字 其用于引用类的当前实例，也包括继承而来的方法，通常可以隐藏this，MSDN 中的小结功能主要包括： ?限定被相似的名称隐藏的成员 ?将对象作为参数传递到其他方法 ?声明索引器

Java中的两个特殊变量this和super

Java中的两个特殊变量this和super 在Java中有两个非常特殊的变量：this和super，这两个变量在使用前都是不需要声明的。this变量使用在一个成员函数的内部，指向当前对象，当前对象指的是调用当前正在执行方法的那个对象。super变量是直接指向超类的构造函数，用来引用超类中的变量和方法。因此它们都是非常有用的变量，下面我想介绍一下this和super的使用方法。 1、this 让我们先看一段代码吧： class PersonInformation { String name,gender,nationality,address; int age; void PersonInformation(String p_name,String p_gender,String p_nationality,String p_address,int p_age) { name=p_name; gender=p_gender; nationality=p_nationality; address=p_address; age=p_age; } } 你会发现，在PersonInformation()函数中这个对象的方法提示可以直接访问对象的成员变量的，而且在同一个范围中，定义两个相同的名字的局部变量是不允许的，如果确实想使类的成员变量和方法的参数或方法自己定义的局部变量同名的话就需要想一种方法使成员变量与更它同名的方法参数或局部变量区分开来，这就要使用到this变量。下面我想改写一

下上面的代码，使PersonInformation类的构造函数的每个参数都有与对象成员变量相同的名字，而成员变量的初值由参数给出。 class PersonInformation { String name,gender,nationality,address; int age; void PersonInformation(String name,String gender,String nationality,String address,int age) { https://www.wendangku.net/doc/f510997025.html,=name; this.gender=gender; this.nationality=nationality; this.address=address; this.age=age; } } 由上一例中，我们可以看出，该构造函数中必须使用this，this在方法体重用来指向引用当前正在执行方法的那个对象实例，this变量的类型总是为包含前执行方法的类，上例中，我们要区别参数name和成员变量name,写成name=name显然是不允许的，在参数或局部变量名与类成员变量同名的时候，由于参数或局部变量的优先级高，这样在方法体中参数名或局部变量名将隐藏同名的成员变量，因此，为了值名成员变量，你必须使用this显示地指明当前对象。 有时候会遇到这种情况，我们全面的访问当前对象，而不是访问某一个个别的实例对象，我们也可以使用this，并利用Java中的toString()方法（它能够返回一个描述这个对象的字符串）如果把任何一个对象传递到System.out.println方法中，这个方法调用这个对象的toString方法，并打印出结果字符串，所以，我们可以用如下方法System.out.println(this)，来打印出任何对方法固有参数的当前状态。 this还有一个用法，就是构造函数的第一个语句，它的形式是this(参数表），这个构造

笔试题——01

标签：Java面试题 一．选择题(共50题，每题2分，共100分。多选题选不全或选错都不得分。) 1．以下属于面向对象的特征的是（C,D）。（两项） A) 重载 B) 重写 C) 封装 D) 继承 2．以下代码运行输出是（C） publicclass Person{ private String name=”Person”; int age=0; } publicclass Child extends Person{ public String grade; publicstaticvoid main(String[] args){ Person p = new Child(); System.out.println(https://www.wendangku.net/doc/f510997025.html,); } } A) 输出：Person B) 没有输出 C) 编译出错 D) 运行出错 3．在使用super 和this关键字时，以下描述正确的是（A） A) 在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过 B) super（）和this（）不一定要放在构造方法内第一行 C) this（）和super（）可以同时出现在一个构造函数中 D) this（）和super（）可以在static环境中使用，包括static方法和static语句块 4．以下对封装的描述正确的是（D） A) 只能对一个类中的方法进行封装，不能对属性进行封装 B) 如果子类继承了父类，对于父类中进行封装的方法，子类仍然可以直接调用 C) 封装的意义不大，因此在编码时尽量不要使用 D) 封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

java 中getxxx的用法大全

java 中getxxx的用法大全 2006-09-28 11:11 Version 1: How to read each JDBC type This section lists the ResultSet.getXXX methods recommended and allowed for retrieving data of each JDBC type. TINYINT: getByte (recommended) Can also be read using getShort, getInt, getLong, getFloat, getDouble, getBigDecimal, getBoolean, getString, getObject SMALLINT: getShort (recommended) Can also be read using getByte, getInt, getLong, getFloat, getDouble, getBigDecimal, getBoolean, getString, getObject INTEGER: getInt (recommended) Can also be read using getByte, getShort, getLong, getFloat, getDouble, getBigDecimal, getBoolean, getString, getObject BIGINT: getLong (recommended) Can also be read using getByte, getShort, getInt, getFloat, getDouble, getBigDecimal, getBoolean, getString, getObject REAL: getFloat (recommended) Can also be read using getByte, getShort, getInt, getLong, getDouble, getBigDecimal, getBoolean, getString, getObject FLOAT: getDouble (recommended) Can also be read using getByte, getShort, getInt, getLong, getFloat, getBigDecimal, getBoolean, getString, getObject DOUBLE: getDouble (recommended) Can also be read using getByte, getShort, getInt, getLong,

Java关键字大全

abstract - 1 - boolean - 2 - break - 2 - byte - 2 - case - 3 - catch - 3 - char - 4 - class - 4 - continue - 5 - default - 5 - do - 6 - double - 6 - else - 6 - extends - 6 - false - 7 - final - 7 - finally - 7 - float - 8 - for - 8 - if - 8 - implements - 9 - import - 9 - instanceof - 9 - int - 9 - interface - 10 - long - 10 - native - 10 - new - 11 - null - 11 - package - 11 - private - 11 - protected - 12 - public - 12 - return - 13 - short - 13 - static - 13 - super - 14 - switch - 14 - synchronized - 15 - this - 16 - throw - 16 - throws - 16 - transient - 17 - try - 17 - true - 18 - void - 18 - volatile - 18 - while - 18 - 1.abstract abstract 关键字可以修改类或方法。 abstract 类可以扩展（增加子类），但不能直接实例化。 abstract 方法不在声明它的类中实现，但必须在某个子类中重写。 -示例- public abstract class MyClass{ } public abstract String myMethod(); -注释- 采用abstract 方法的类本来就是抽象类，并且必须声明为abstract。 abstract 类不能实例化。 仅当abstract 类的子类实现其超类的所有abstract 方法时，才能实例化abstract 类的子类。这种类称为具体类，以区别于abstract 类。 如果abstract 类的子类没有实现其超类的所有abstract 方法，该子类也是abstract 类。 abstract 关键字不能应用于static、private 或final 方法，因为这些方法不能被重写，因此，不能在子类中实现。 final 类的方法都不能是abstract，因为final 类不能有子类。

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 = 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( } } 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 的构造函数。残骛楼諍锩瀨濟溆塹籟婭骒東。 3.注意匿名类和内部类中的中的this 。有时候,我们会用到一些内部类和匿名类,如事件处理。当在匿? 嘀杏胻his 时,这个this 则指的是匿名类或内部类本身。这时如果我们要使用外部类的方法和变量的话, 则应该加上外部类的类名。如下面这个例子:酽锕极額閉镇桧猪訣锥顧荭钯。public class A { int i = 1; public A() { Thread thread = new Thread() { public void run() { for(;;) { A.this.run(); try {

Java中注释使用原则

Java中注释的使用是有原则的 Java提供了3种类型的注释 例如： // this is a single-line comment x = 1; // a single-line comment after code 多行注释(C风格) Java同样提供跨越多行的注释类型。这种类型的注释以紧跟着一个星号的正斜杠开始，并以紧跟着一个正斜杠的星号结束。这种类型注释的开始和结束分界符可以在同一行里也可以在不同的行上。例如：/* This is a c-style comment *//* This is also a c-style comment, spanni ng multiple lines */ 注意：C风格的注释不可以嵌套使用。比如下面的用法： /* A comment looks like /* This is a comment */ blah blah blah */ 上面的用法会造成语法错误，因为Java编译器只把第一个*/ 当做注释来处理。(编译器认为注释在第一个“*/”就结束了)。

你可以在多行注释里嵌入单行注释： /* This is a single-line comment: // a single-line comment */ 以及在单行注释里使用多行注释： // /* this is // a multi-line // comment */ 文档注释 文档注释是一种与多行注释很类似的特殊注释，它可以用来为你的源代码产生外部文档。这种注释以紧跟着两个星号的正斜杠开始，并以紧跟着一个正斜杠的星号结束。例如： /** This is a documentation comment *//** This is also a documentatio n comment */ 这里有一些关于文档注释的重要事情要注意： javadoc文档生成器会把文档注释里的所有文本都添加到一个HTML 段落里。这意味着，在文档注释里的任意文本都会被格式化为一个段落;空格和换行符会被忽略。如果你想要特殊的格式，你必须要在文档注释里使用HTML标签。 如果文档注释以超过两个的星号开始，那么javadoc就认为这些星号是用来在源码里创建一个“框”框住注释的，并忽略多余的星号。例如： 该注释仅保留“This is the start of a method”文本。 javadoc会忽略文档注释里处于行首的星号。例如： 该注释仅保留“This is a doc comment on multiple lines that I want to stand out in source code, looking “neat””文本。

Java复习要点-2018

Java复习提纲 题型： 填空题 判断题 选择题（单选） 简答题与程序分析题 编程题 第1章 (1) javac、java、jar、javadoc作用是什么（编译、运行、打包、生成文档） (2) JDK、JRE、JVM的全称 (3) Java程序分为两大类：独立应用程序与Applet小程序，Applet小程序在浏览器中运行，因此不需要main()方法也可运行 (4) 什么是.java文件，什么是.class文件 (5) path环境变量的设置 (6) Integer与int的区别 第2章 (1) 一维数组定义及初始化的正确格式，特别注意int[] a= new int []{1,2,3}; 这种格式容易出错的地方 (2) 二维数组定义的正确格式，二维数组每行元素的个数可以不相等,特别注意int[][] a= new int[3][]; 这种格式容易出错的地方 (3) 数组长度的计算，例如：二维数组int[ ][ ] arr={{1,2},{3,4,5},{7,8,9,10}} arr.length=3 (4) 不同类型的数组元素的默认值是多少 (5) System.out.print( ) 与System.out.println( ) 一个不换行，一个换行 int a=1; int b=2; System.out.println(a+b) 3 int a=1; int b=2; String c=“3”; System.out.println(a+c) 13 (6) 注释的三种类型：单行注释、多行注释、文档注释（表示方法/** */），三种注释是否能相互嵌套 (7) 短路与&& 、短路或|| 及普通逻辑与&、逻辑或| (8) if（条件语句）{ 执行语句} 中的条件语句只能是布尔表达式或布尔值，不能是普通的!0或0表达式或值（切记与C语言的区别）例如if(5>3) if(a = 5>3)正确if(5) if(a=5) 错误 (9) java语言区分大小写 (10) java标识符的命名规则 第3章 (1) 面向对象三个特性：封装性、继承性、多态性，如果说四个特性，则加上抽象 (2) 对封装性和继承性的理解，什么是类的封装(private)，什么是类的继承（父类/基类-子类）成员变量不给值，自动给默认值，不同类型分别是多少 (3) 构造方法和普通方法的区别，满足三个条件：方法名与类名相同，无返回值，无return (4) 什么叫构造方法的重载（overloading）？多个构造方法的参数类型或参数个数不同 (5) 定义了有参的构造方法后，系统自动生成的无参的构造方法将不可用，除非自己写出来 (6) 每个对象都有一个this关键字，它代表每个对象自身，掌握this关键字的使用规则，用