第一篇：总结Java中return语句的用法（范文模版）
总结Java中return语句的用法
Java中的return语句总是和方法有密切关系，return语句总是用在方法中，有两个作用，一个是返回方法指定类型的值(这个值总是确定的)，一个是结束方法的执行(仅仅一个return语句)。
在return语句的各类文章中，大多仅仅介绍了return语句用于有返回值(非void返回值)的方法中。而很少或没有介绍return语句在vodi返回值方法中的运用。
return语句用在非void返回值类型的方法中，不但能返回基本类型，还可以返回(包括用户自定义类的)对象。
下面通过一个简单例子说明一下：
/**
* Created by IntelliJ IDEA.* User: leizhimin
* Date: 2007-12-3
* Time: 8:54:28
* Java中的return语句使用总结
*/
public class TestReturn {
public static void main(String args[]){
TestReturn t = new TestReturn();
t.test1();
t.test2();
}
/**
* 无返回值类型的return语句测试
*/
public void test1(){
System.out.println(“---------无返回值类型的return语句测试--------”);
for(int i = 1;;i++){
if(i == 4)return;
System.out.println(“i = ” + i);
}
}
/**
* 有返回值类型的return语句测试
* @return String
*/
public String test2(){
System.out.println(“---------有返回值类型的return语句测试--------”);
return “返回一个字符串”;
}
}
运行结果：
---------无返回值类型的return语句测试--------
i = 1
i = 2
i = 3
---------有返回值类型的return语句测试--------
Process finished with exit code 0
第二篇：SQL中forXML语句用法总结
-------raw模式：raw模式将查询结果集中的每一行转换为带有通用标识符row或可能提供元素名称的xml元素。(将查询结果集中的每一行转换为row元素的属性或row元素的子无素)-------------行集中非Null的每列值都将映射为row元素的一个属性--------------------------
select top 10 *
from mixtureMeasureMonitor
for xml raw
---将elements指令添加到for xml子句，则行集中非null的每列值都将映射为row元素的一个子元素
-----------
select top 10 *
from mixtureMeasureMonitor
for xml raw,elements
----在指定elements指令的同时指定xsinil选项，则将行集中为null的每例值映射为具有属性xsi:nil=“true”的一个元素
---------------------------
select top 10 *
from mixtureMeasureMonitor
for xml raw,elements XSINIL
-Auto模式根据查询确定返回的xml的形式--------------
select pmm.id,pmm.ppId,pp.MixPropNo,pmm.criterion
from mixtureMeasureMonitor as pmm inner join
produceProportion as pp on pp.id=pmm.ppid and pp.cOrgID=pmm.cOrgID tOption as tp on tp.cValue=pmm.Criterion inner join
where tp.ckey='Criterion '
for xml auto
select
pmm.id,pp.MixPropNo,pmm.ppId,pmm.criterion,pmm.temperatureMark,pmm.remark
from mixtureMeasureMonitor as pmm inner join
produceProportion as pp on pp.id=pmm.ppid and pp.cOrgID=pmm.cOrgID tOption as tp on tp.cValue=pmm.Criterion inner join
where tp.ckey='Criterion '
for xml auto,elements xsinil
-----------------explicit模式:使用RAW和AUTO模式不能很好地控制从查询结果生成的XML的形状。但是，对于要从查询结果生成的XML，EXPLICIT模式会提供非常好的灵活性-----------------------
select
pp.MixPropNo,pmm.id,pmm.ppId,pmm.criterion,pmm.temperatureMark,pmm.remark
from mixtureMeasureMonitor as pmm inner join
produceProportion as pp on pp.id=pmm.ppid and pp.cOrgID=pmm.cOrgID tOption as tp on tp.cValue=pmm.Criterion inner join
where tp.ckey='Criterion '
for xml explicit
-------------------------OPENXML语句，对XML文件进行查询，然后返回指定的XML中的结果集数据---------------------------
/*openxml(idoc int [in],rowpattern nvarchar[in],[flags byte [in]])
[WITH(SchemaDeclaration|TableName)]
Idoc:XML文档的内部表示形式的文档句柄
RowPattern:XPath模式，用来标识要作为行处理的节点
Flags:指示应在XML数据和关系行集间使用映射，以及应如何填充溢出列
SchemaDeclaration:窗体的架构定义
TableName：如果具有所需架构的表已经存在且不要求列模式，则为给定的表名*/ DECLARE @idoc int
declare @doc varchar(2000)
set @doc='
'
EXEC sp_xml_preparedocument @idoc output,@doc
select *
from openxml(@idoc,'/ROOT/Customer',1)
with(CustomerID varchar(10),ContactName varchar(20))/*path()括号内的参数是控制节点名称的，不指定括号时控制节点默认是row。rooot选项来添加单个顶级元素*/
------------------path选项不带()时，默认控制节点是row，其他字段元素都是row元素的子元素----------
select ID ,name
from MtrlBaseName
for xml path
--------------------------ID,name是product标签的子标签---------------select ID ,name
from MtrlBaseName
for xml path('Product'),root('ProductExport')
------------------ID是Product标签的属性，name是Product标签的内容-----------------------------
select ID [@ID],name as [*]
from MtrlBaseName
for xml path('Product'),root('ProductExport')
------------------ID,name是Product标签的属性
----
select ID [@ID],name as [@name]
from MtrlBaseName
for xml path('Product'),root('ProductExport')
第三篇：JAVA的输入语句总结
java的输入语句小结）
1.使用Scanner
使用时需要引入包import java.util.Scanner;首先定义Scanner对象 Scanner sc = new Scanner(System.in);如果要输入整数，则 int n = sc.nextInt();String类型的，则String temp = sc.next();比如：
import java.util.Scanner;
public class Test {
public static void main(String[] args){ Scanner scanner = new Scanner(System.in);
int[] days = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int month =-1;
while(true){
try {
System.out.print(“请输入月份：”);month = scanner.nextInt();if(month >= 1 && month <= 12){ break;}
System.out.println(“** 请输入正确的月份 **”);} catch(Exception e){
System.out.println(“** 格式错误！请输入数字 **”);scanner.next();} }
System.out.println(month + “ 月份有：” + days[month-1] + “ 天”);} }
2.使用BufferedReader
用前需要引入 import java.io.Reader;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String input = br.readLine();比如：
import java.io.*;
public class importtext {
public static void main(String[] args){
String st;
int num;
float fnum;
try{
System.out.print(“输入：”);
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
st = br.readLine();
System.out.print(“输入一个数：”);
num = Integer.parseInt(br.readLine());
System.out.print(“输入一个浮点数：”);
fnum = Float.parseFloat(br.readLine());
System.out.print(“输出：”+st+'n');
System.out.print(“输出：”+num+'n');
System.out.print(“输出：”+fnum+'n');
}catch(IOException e){}
}
}
package com.s2;import java.io.*;public class Input { public static void main(String[] args)throws IOException { while(true){ BufferedReader buf;String str;buf =new BufferedReader(new InputStreamReader(System.in));System.out.println(“Input a string:”);str=buf.readLine();System.out.println(“String=”+str);} } } ======
应该注意的是:Java把从键盘输入的数据一律看作是字符串，因此若要从键盘输入并让系统认可是数值型数据，必须经过转换。比如：
package com.s2;import java.io.*;public class Input { public static void main(String[] args)throws IOException { while(true){ int num;BufferedReader buf;String str;buf =new BufferedReader(new InputStreamReader(System.in));System.out.println(“Input an integer:”);str=buf.readLine();num=Integer.parseInt(str);System.out.println(“String=”+str);System.out.println(“Integer=”+str);} } }
第四篇：java中this&super的用法小结
This : this关键字必须放在非静态方法里面
this关键字代表自身，在程序中主要的使用用途有以下几个方面： 1.使用this关键字引用成员变量
在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，有些时候可以省略，有些时候不能省略。
eg1.public class ReferenceVariable {
} private int a;
public ReferenceVariable(int a){ this.a = a;}
public int getA(){ return a;}
public void setA(int a){ this.a = a;}
按照Java语言的变量作用范围规定，参数a的作用范围为构造方法或方法内部，成员变量a的作用范围是类的内部，这样在构造方法和setA方法内部就存在了变量a的冲突，Java语言规定当变量作用范围重叠时，作用域小的变量覆盖作用域大的变量。所以在构造方法和setA方法内部，参数a起作用。
这样需要访问成员变量a则必须使用this进行引用。当然，如果变量名不发生重叠，则this可以省略。
但是为了增强代码的可读性，一般将参数的名称和成员变量的名称保持一致，所以this的使用频率在规范的代码内部应该很多。2.使用this关键字在自身构造方法内部引用其它构造方法, this语句是是构造函数的第一个语句，它的形式是this(参数表）
在一个类的构造方法内部，也可以使用this关键字引用其它的构造方法，这样可以降低代码的重复，也可以使所有的构造方法保持统一，这样方便以后的代码修改和维护，也方便代码的阅读。
public class ReferenceConstructor { int a;public ReferenceConstructor(){ this(0);//调用了另一个构造方法
} public ReferenceConstructor(int a){
this.a = a;} }
这里在不带参数的构造方法内部，使用this调用了另外一个构造方法，其中0是根据需要传递的参数的值，当一个类内部的构造方法比较多时，可以只书写一个构造方法的内部功能代码，然后其它的构造方法都通过调用该构造方法实现，这样既保证了所有的构造是统一的，也降低了代码的重复。
在实际使用时，需要注意的是，在构造方法内部使用this关键字调用其它的构造方法时，调用的代码只能出现在构造方法内部的第一行可执行代码。这样，在构造方法内部使用this关键字调用构造方法最多会出现一次。
3.使用this关键字代表自身类的对象
在一个类的内部，也可以使用this代表自身类的对象，或者换句话说，每个类内部都有一个隐含的成员变量，该成员变量的类型是该类的类型，该成员变量的名称是this。eg1.public class ReferenceObject { ReferenceObject instance;public ReferenceObject(){
instance = this;} public void test(){
System.out.println(this);} }
在构造方法内部，将对象this的值赋值给instance，在test方法内部，输出对象this的内容，这里的this都代表自身类型的对象。
4.使用this关键字引用成员方法
在一个类的内部，成员方法之间的互相调用时也可以使用“this.方法名(参数)”来进行引用，只是所有这样的引用中this都可以省略。
Super
1.在子类构造方法中要调用父类的构造方法，用“super(参数列表)”的方式调用，参数不是必须的。同时还要注意的一点是：“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。
2.当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时，也就是子类局部变量覆盖父类成员变量时，用“super.成员变量名”来引用父类成员变量。当然，如果父类的成员变量没有被覆盖，也可以用“super.成员变量名”来引用父类成员变量，不过这是不必要的。
3.当子类的成员方法覆盖（重写）了父类的成员方法时，也就是子类和父类有完全相同的方法定义（但方法体可以不同），此时，用“super.方法名(参数列表)”的方式访问父类的方法。eg1.class Country{
String name;
void value()
{ name=“China”;}
} class City extends Country{
String name;
void value()
{
name=“Beijing”;
super.value();
System.out.print(name);//父类的成员变量被覆盖
System.out.print(super.name);//输出父类成员变量
} //输出的结果为 Beijing China Static 1.在一个类中定义一个方法为static，那就是说，无需本类的对象即可调用此方法。
class Simple { static void go(){ System.out.println(“Go...”);} } public class Cal { public static void main(String[] args){ Simple.go();} } //输出为Go...，调用一个静态方法就是“类名.方法名”
2.静态变量与静态方法类似。所有此类实例共享此静态变量，也就是说在类装载时，只分配一块存储空间，所有此类的对象都可以操控此块存储空间。eg1.class Value { static int c=0;static void inc(){ c++;} }
class Count { public static void prt(String s){ System.out.println(s);} public static void main(String[] args){ Value v1,v2;v1 = new Value();v2=new Value();prt(“v1.c=”+v1.c+“ v2.c=”+v2.c);v1.inc();prt(“v1.c=”+v1.c+“ v2.c=”+v2.c);} } //结果：v1.c=0 v2.c=0 v1.c=1 v2.c=1 //都显示为1，但是只调用了v1.inc()，可以证明它们共享一块存储区
eg2.class Value { static int c=0;Value(){ c=15;} Value(int i){ c=i;} static void inc(){ c++;} } class Count { public static void prt(String s){ System.out.println(s);}
//static定义的变量会优先于任何其它非static变量,虽然v出现在v1和v2的前面，但是结果却是v1和v2的初始化在v的前面
Value v=new Value(10);static Value v1,v2;
//在static{后面跟着一段代码，这是用来进行显式的静态变量初始化，这段代码只会初始化一//次，且在类被第一次装载时。Static { prt(“v1.c=”+v1.c+“ v2.c=”+v2.c);v1=new Value(27);prt(“v1.c=”+v1.c+“ v2.c=”+v2.c);v2=new Value(15);prt(“v1.c=”+v1.c+“ v2.c=”+v2.c);} public static void main(String[] args){ Count ct=new Count();prt(“ct.c=”+ct.v.c);//这句？ prt(“v1.c=”+v1.c+“ v2.c=”+v2.c);v1.inc();prt(“v1.c=”+v1.c+“ v2.c=”+v2.c);prt(“ct.c=”+ct.v.c);} }
//运行结果 v1.c=0 v2.c=0 v1.c=27 v2.c=27 v1.c=15 v2.c=15 ct.c=10 v1.c=10 v2.c=10 v1.c=11 v2.c=11 ct.c=11
3.通常一个普通类不允许声明为静态的，只有一个内部类才可以。这时这个声明为静态的内部类可以直接作为一个普通类来使用，而不需实例一个外部类.eg1.public class StaticCls{ public static void main(String[] args){ //注意此处用法，创建一个类的内部类对象
OuterCls.InnerCls oi=new OuterCls.InnerCls();} } class OuterCls{ public static class InnerCls{ InnerCls(){ System.out.println(“InnerCls”);} } //结果：InnerCls
Final Final成员： 1.在类中定义变量加上final关键字，那便是说，这个变量一旦被初始化便不可改变（对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变）。其初始化可以在两个地方，一是其定义处，二是在构造函数中。这两个地方只能选其一。
2.方法中的内部类在用到方法中的参变量时，此参变也必须声明为final才可使用
eg.public class INClass{ void innerClass(final String str){ class IClass{ IClass(){ System.out.println(str);} } IClass ic=new IClass();} public static void main(String[] args){ INClass inc=new INClass();inc.innerClass(“Hello”);} } Final方法：
1.final方法不需要进行扩展，并且也不允许任何从此类继承的类来覆写这个方法，但是继承仍然可以继承这个方法（即可以直接使用）。
2.inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用
Final类：
一个final类是无法被任何人继承。对于final类中的成员，你可以定义其为final，也可以不是final。而对于方法，由于所属类为final的关系，自然也就成了final型的。
常量的定义：final 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将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。什么时候用static关键字? 不想建立对象时；对于公用的成员变量必须使用static关键字修饰才能保证共享；
private关键字
1、java中的访问权限修饰符（作用是控制被修饰的成员的访问权限）；被private修饰的成员，只能在本类中使用；所以被私有的成员需要在外界访问，还需要提供一个公共的方法；
设值：set + 变量名（变量名的首字母大写）； 取值：get + 变量名（变量名的首字母大写）；
2、构造函数私有化，就只能在被类中使用，别的地方调用不了；单例设计模式时会用到；
在开发中，一般类的成员变量都要私有化，然后提供get和set方法；
interface关键字
1、interface接口不是一个类，使用interface声明；接口没有构造函数；接口是用来描述不属于继承体系的扩展功能的；还可以定义规则；接口和类之间是实现关系，一个实现类可以实现多个接口；接口和接口之间是继承关系，可以多继承和多重继承；
2、接口中可以书写的内容：
成员变量：只能使用一下修饰符：public static final;也就是说，接口中的成员变量，都是常量；
成员函数： 只能使用修饰符：public abstract;也就是说，接口中的方法，都是公共和抽象的；一般函数前面的修饰符，推荐public不要省略；
什么时候用interface关键字? 对于继承体系之外的扩展功能需要使用接口来描述；
implements关键字
implements用于实现接口，需要实现接口中的所有方法，可以同时实现多个接口。extends关键字
extends用于继承父类或父接口，继承父类时只能是单继承。
class关键字
class用于声明类，访问权限可以是public或者默认权限，还可以指定为abstract、final，访问权限对于顶层类和内部类的限制是不同的。
instanceof关键字
1、比较运算符，运算符左边是一个指向一个对象的引用（左边就是一个变量名），右边是一个类名，运算符表示的意思就是：判断左边的对象的类型是不是右边的类；
2、使用instanceof关键字，可以实时判断一个对象的类型，就可以避免强制类型转换中容易出现的类型转换异常。
abstract关键字
1、abstract用于类表示这个类为抽象类，不能实例化。
2、抽象类，必须由子类去继承，继承的子类必须实现父类中所有的抽象方法，否则子类也是抽象的；
3、抽象函数必须放在抽象类中；抽象类中除了抽象函数，还可以定义所有一般类中可以定义的成员；
4、抽象类中可以不书写抽象方法；抽象类中必须有构造方法；抽象类一定是父类；
5、抽象类是父类，用来描述所有子类的共性信息的，只是描述的有些功能是不具体的；
6、abstract用于方法表示这个方法为抽象方法，只需声明，不用实现，由子类实现，抽象方法不能用private和static关键字。什么时候用abstract关键字? 当事物的功能描述不清，只能表示有这个功能时，就应该使用抽象修饰该功能，这个功能就是抽象的功能；如果一个类中有抽象的功能，那么这个类也是抽象的类；不想实例化这个类（包括自己也不行），但是允许别人继承，也可以使用抽象类。
this关键字
1、表示自身所属对象的引用；哪个对象调用this，this就指向哪个对象；
2、Java关键字this只能用于方法方法体内。当一个对象创建后，Java虚拟机（JVM）就会给这个对象分配一个引用自身的指针，这个指针的名字就是this。因此，this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this.什么时候用this关键字?
1、通过this调用另一个构造方法，用法：this(参数列表)，这个仅仅在类的构造方法中，别的地方不能这么用。如果一个构造函数中有this()语句，就没有隐式三步，隐式三步在this语句调用的那个构造函数中,且this语句必须在第一行的位置；
2、函数参数或者函数中的局部变量和成员变量同名的情况下，成员变量被私有化，此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。（用来区分成员变量和局部变量）
3、在函数中，需要引用该函所属类的当前对象时候，直接用this。
super关键字
1、表示父类；可以在子类中调用父类的非私有成员和构造函数；
2、调用方法：
调用父类构造函数：super(参数);(父类中没有无参构造函数在父类中添
加一个无参构造；在子类中手动调用有参构造函数)调用父类成员变量：super.变量名； 调用父类成员函数：super.函数名(参数);
3、super关键和this作用类似，是被私有的成员变量或者成员方法变为可见，或者说用来引用被私有的成员变量和成员方法,不过super是用在子类中，目的是访问直接父类中被屏蔽的成员.什么时候用super关键字?
如果父类中没有无参构造函数是，需要在子类中用super调用有参构造函数；
点击咨询 