精华内容
下载资源
问答
  • Java注释变量

    千次阅读 2017-08-03 10:43:15
    注释注释的说明作用,所有的注释都是给开发人员...编译器会主动忽略掉注释内容单行注释: // 只能注释一行代码快注释:/* */ 能注释一块代码(多行)段落注释:/* / 主要是用做程序的类说明变量:申请内存空间的名称

    注释:注释的说明作用,所有的注释都是给开发人员阅读的,主要是帮助开发人员理解程序的含义。编译器会主动忽略掉注释内容

    单行注释: // 只能注释一行代码

    快注释:/* */ 能注释一块代码(多行)

    段落注释:/* / 主要是用做程序的类说明

    变量:申请内存空间的名称
    1.声明一个32个长度的内存空间
    变量的类型 int moeny=100; 2.将上面分配空间取一个名字
    数据 3.将100存入内存空间(赋值)

               变量名(标识符)的命名规则:
                    首字母以英文字母,下划线,美元符号$
                    不能以数字开头,不能存在特殊字符。 
    

    数据类型
    注释和变量

     基本数据类型
    
                        布尔: booleam            1bit                                                                                              1PB = 1024 TB
                              字节:   byte                    8bit                                                                                             1TB = 1024 GB
                              字符: char                     16bit                                                                                             1GB= 1024 MB
                              字符串:string                                                                                                                    1MB=1024KB
                              整形: int                        32bit                                                                                             1KB= 1byte
                              短整形:short               16bit
                              长整形: long                  64bit
                              单精度: flaot                  32bit
                              双精度:duoble                 64bit
         引用类型 :String ....... 等引用类型
    
    展开全文
  • Java中,我们需要标识代码的很多元素,包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符,一个正确的标识符需要遵循以下规则: 1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,...

    1 JAVA语法基础

    1.1 标识符

    标识符可以简单的理解成一个名字。
    在Java中,我们需要给代码中的很多元素起名,包括类名、方法名、字段名、变量名等等。我们给对应元素起的名称就被称为标识符,一个正确的标识符需要遵循以下规则:

    1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,但不能包含 @、%、空格等其它特殊字符
    2. 不能以数字开头。如:123name 就是不合法
    3. 标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
    4. 标识符的命名最好能反映出其作用,做到见名知意。
    5. 标识符不能是Java的关键字

    1.2 关键字

    在Java中,有一些单词被赋予了特定的意义,一共有50个关键字。
    这50个单词都是全小写,其中有两个保留字:const和goto。
    注意,关键字不能被用作标识符!
    在这里插入图片描述
    需要注意的是,除了上述的50个关键字以外,true,false,null也不可以被用作标识符~

    1.3.1 注释

    几乎所有编程语言都允许程序员在代码中输入注释
    因为编译器会忽略注释,所以注释并不会影响程序的运行结果。
    注释的真正作用是: 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息, 提高代码的可读性,方便后期的维护与复用。
    Java的注释有3种:

    1. 单行注释: 注释单行内容.

    格式: 每行都以”//”开头.
    快捷方式: Ctrl+/ 添加注释,同样的快捷键,再按一次取消注释

    2. 多行注释:注释多行内容,虽然叫多行注释,也可注释单行内容.

    格式: 以” /* ”开头, 以” * / ”结束.
    快捷方式: 可以输入” /* ”之后按回车添加注释

    3. 文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.

    格式: 以” /** ”开头。 以” * / ”结尾
    快捷方式: 输入 “ /** ” 之后按回车添加注释

    1.3.2 练习:

    创建包: cn.tedu.basic
    创建类: CommentDemo.java

    package cn.tedu.basic;
    /**本类用于练习注释*/
    public class CommentDemo {
    	//我是一个单行注释
    	
    	/*
    	 * 我
    	 * 是
    	 * 一
    	 * 个
    	 * 多行注释
    	 */
    	
    	/**
    	 * 我是一个文档注释/DOC注释
    	 * 我也可以注释多行内容
    	 * 除此之外,我还可以添加一些作者/时间/版本...的信息
    	 */
    	public static void main(String[] args) {
    		System.out.println("我就是想测试下注释会不会执行~");
    	}
    }
    

    1.4 变量

    在JAVA中,我们需要记录一些数据
    但这些数据的值是不固定的,总在变,我们可以把这些数据理解为变量。
    我们通过三个元素来描述变量:变量类型 变量名以及变量值。
    定义变量的两种格式:
    格式一:声明变量时并且赋值:int age = 18;
    格式二:先声明变量:String tel ; 然后给变量赋值:tel = 119;

    注意:

    1. 变量名必须是一个有效的标识符
    2. 变量名不可以使用java关键字
    3. 变量名不能重复

    1.5 常量

    在程序运行过程中,值一直不会改变的量成为常量。(后续会进一步学习,略…)

    2 数据类型

    2.1 基本类型介绍(八种)

    变量要保存值,这个值是存在内存中的,所以就需要向内存申请存储空间
    java是一个强类型的语言
    为了方便内存管理系统根据变量类型更加合理的分配内存空间
    会把我们常见的数据,分成不同类型
    不同类型分配的内存大小是不同的,这个大小的单位就是字节Byte
    八大基本类型速查表
    拓展:常用的转换关系:
    位 bit,来自英文bit,音译为“比特”,表示二进制位。
    1 Byte = 8 Bits (1字节 = 8位)
    1 KB = 1024 Bytes 1 MB = 1024 KB 1 GB = 1024 MB

    2.2 练习: 输入个人信息

    创建包: cn.tedu.basic
    创建类: TestInfo.java
    需求: 在控制台打印: java架构师今年20岁,月薪100000.99,感慨java是世界上最好的语言

    package cn.tedu.basic;
    /**本类用于完成个人信息输出案例*/
    public class TestInfo {
    	//1.添加程序的入口函数main()
    	public static void main(String[] args) {
    		/**1.定义变量的规则:变量的类型  变量名  变量的值*/
    		/**2.String是字符串类型,用来保存多个字符*/
    		//2.定义变量
    		String name = "泡泡";//定义一个String变量用来保存姓名"江江"
    		int age = 16;//定义一个age变量用来保存年龄16
    		double salary = 100000.66;//定义一个变量salary用来保存工资
    		//3.我们可以通过打印语句查看变量的值
    		System.out.println(name);
    		System.out.println("java架构师"+name+",今年"+age+"岁,月薪"+salary+",感慨Java是世界上最好的语言!");
    	}
    }
    

    2.3 练习:查看基本类型的最大值与最小值

    创建包: cn.tedu.basic
    创建类: TestTypeScope.java

    package cn.tedu.basic;
    /**本类用于测试基本类型*/
    public class TestTypeScope {
    	//1.创建程序的入口函数
    	public static void main(String[] args) {
    		/**1.整形类型:byte short int long*/
    		/**2.Java给8大基本类型都提供了类型对应的“工具箱”*/
    		/**3.int类型的工具箱比较特殊,叫做:Integer*/
    		//2.定义对应类型的变量:格式:类型 名字 = 值 ;
    		byte byteMin = Byte.MIN_VALUE;
    		byte byteMax = Byte.MAX_VALUE;
    		System.out.println("byte类型的最小值为:" + byteMin);
    		System.out.println("byte类型的最大值为:" + byteMax);
    		
    		short shortMin = Short.MIN_VALUE;
    		short shortMax = Short.MAX_VALUE;
    		System.out.println("short类型的最小值为:" + shortMin);
    		System.out.println("short类型的最大值为:" + shortMax);
    		
    		int intMin = Integer.MIN_VALUE;
    		int intMax = Integer.MAX_VALUE;
    		System.out.println("int类型的最小值为:" + intMin);
    		System.out.println("int类型的最大值为:" + intMax);
    		
    		long longMin = Long.MIN_VALUE;
    		long longMax = Long.MAX_VALUE;
    		System.out.println("long类型的最小值为:" + longMin);
    		System.out.println("long类型的最大值为:" + longMax);
    		
    		/**4.浮点类型 :float double*/
    		float floatMin = Float.MIN_VALUE;
    		float floatMax = Float.MAX_VALUE;
    		System.out.println("float类型的最小值为:" + floatMin);
    		System.out.println("float类型的最大值为:" + floatMax);
    		
    		double doubleMin = Double.MIN_VALUE;
    		double doubleMax = Double.MAX_VALUE;
    		System.out.println("double类型的最小值为:"+ doubleMin);
    		System.out.println("double类型的最大值为:"+ doubleMax);
    		
    		/**5.boolean布尔类型只有两个值true与false
    		 * 虽然true和false不是关键字,但是也不可以用作标识符*/
    		boolean b1 = true;
    		boolean b2 = false;
    		
    		/**6.测试char 字符类型
    		 * 字符型的数据需要使用单引号 ' ' 来包裹
    		 * char类型可以存数字,但是会从ASCII码表查出这个数字对应的字符来打印
    		 * 128~65535这些数字,也可以保存,但是eclispe一般显示为?*/
    		char c1 = 'a';//字符型可以保存一个字母
    		char c2 = '中';//字符型还可以保存一个汉字
    		char c3 = '7';//字符型可以保存一个字符7
    		char c4 = 97;//字符型可以保存数字,但是会查ASCII,打印的是字符a
    		char c5 = 55;//字符型可以保存数字,但是会查ASCII,打印的是字符7
    		char c6 = 199;
    		System.out.println(c1);
    		System.out.println(c2);
    		System.out.println(c3);
    		System.out.println(c4);
    		System.out.println(c5);
    		System.out.println(c6);
    		
    	}
    
    
    
    }
    

    2.4 练习:求圆形的面积

    需求:求出指定半径圆的面积
    公式:圆的面积:π * r * r
    创建包: cn.tedu.basic
    创建类: TestCircleArea.java

    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**本类用于求圆形的面积*/
    public class TestCircleArea {
    	//1.创建程序的入口函数main()
    	public static void main(String[] args) {
    		/**等号右边的值赋值给等号左边的变量来保存*/
    		//1.提示用户输入圆的半径:
    		System.out.println("请您输入要求的半径值:");
    		
    		/**变量的第二种定义方式:先定义,再赋值*/
    		//2.1定义一个变量用来保存圆的半径
    		//double r = 5.5;
    		double r ;
    		//2.2接收用户在键盘上输入的数据,并把这个数据交给r保存
    		//开启扫描(发出一个系统指令,准备接收控制台输入的数据)
    		//nextDouble()控制用户只能输入double类型的数据,否则报错
    		r = new Scanner(System.in).nextDouble();
    		
    		//根据半径值求出圆的面积
    		double circleArea = 3.14 * r * r;
    		//打印计算的结果
    		System.out.println("圆的面积是:"+circleArea);
    	}
    
    }
    

    2.5 练习:变量交换

    在这里插入图片描述
    需求: 接收用户输入的两个值:假设a=1,b=2,并将这两个变量的值进行互换
    创建包: cn.tedu.basic
    创建类: TestValueExchage.java

    package cn.tedu.basic;
    
    import java.util.Scanner;
    
    /**本类用于练习值交换案例*/
    public class TestValueExchange {
    	//1.创建程序的入口函数main
    	public static void main(String[] args) {
    		//2.提示并接受用户在控制台输入的两个整数
    		System.out.println("请输入要交换的第一个整数:");
    		int a = new Scanner(System.in).nextInt();
    		System.out.println("请输入要交换的第二个整数:");
    		int b = new Scanner(System.in).nextInt();
    		System.out.println("a的值:"+a);
    		System.out.println("b的值:"+b);
    		
    		//3.交换 a b 这两个变量保存的值
    		int t;//定义一个变量用来辅助值交换
    		t = a;//把a的值交给t来保存
    		a = b;//把b的值交给a来保存
    		b = t;//把t的值交给b来保存
    		
    		System.out.println("交换后,a的值:"+a);
    		System.out.println("交换后,b的值:"+b);
    		
    	}
    
    }
    

    2.6 引用类型

    除了基本类型以外的所有类型都是引用类型
    目前我们只遇到了String字符串类型,需要用双引号包裹
    引用类型是一个对象类型,值是什么呢?
    它的值是指向内存空间的引用,就是地址,所指向的内存中保存着变量所表示的一个值或一组值。如:类,接口,数组,后面讲。。。
    (后续会进一步学习,略…)

    3 基本类型的字面值(5条)

    3.1 整数类型的字面值类型是int类型

    也就是说,我们只要写一个整数,就被认为是int类型

    int x = 99999;
    //byte y = 300;//错,300是int类型,byte存不下
    //int z = 999999999999;//错,虽然是int类型,但是超出范围
    long h = 999999999999L;//如果要定义long类型需要加后缀L
    

    3.2 浮点数类型的字面值类型是double类型

    也就是说,我们只要写一个小数,就被认为是double类型

    	double d = 3.14;
    	//float f = 3.14;//错,3.14认为自己是double类型
    	float f = 3.14F;//如果要定义float类型需要加后缀F
    	double d2 = 3D;//如果要定义的小数是整数,最好加D方便阅读
    

    3.3 byte,short,char三种比int小的整数可以用范围内的值直接赋值

    byte b1=127;//对,
    byte b2=128;//错,超出byte的范围
    char c1=97;//对,对应的是码表中的'a'
    char c2 =69999;//错,超出char的范围
    

    3.4 字面值后缀L D F

    long x =99999999999L;//字面值是int类型,需转成long类型的数据,加字面值后缀L即可
    float b = 3.0F;//3.0字面值是double类型,加后缀F会变成float类型
    double d = 3D;//3字面值是int类型,加后缀D,会变成double类型
    

    3.5 进制前缀

    0b - 标识这是2进制 ,如:0b0101
    0 - 标识这是8进制, 8进制是三位,如: 023
    0x - 标识这是16进制,如: 0x0001
    		//10进制,底数为10:10^2 10^1 10^0 =100+0+0=100
    		System.out.println(100);//默认10进制,打印100
    		//2进制,底数为2:2^2 2^1 2^0 =4+0+0=4
    		System.out.println(0b100);//2进制,打印4
    		//8进制,底数为8:8^2 8^1 8^0 =64+0+0=64
    		System.out.println(0100);//8进制,打印64
    		//16进制,底数为16:16^2 16^1 16^0 =256+0+0=256
    		System.out.println(0x100);//16进制,打印256
    

    4 基本类型的类型转换

    箭头开始的地方是小类型,箭头指向的地方是大类型
    我们此处所指的"大"和"小",指的是对应类型的取值范围,不是字节数哦
    基本类型的类型转换

    4.1 小到大(隐式转换)

    byte m = 120;
    int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用
    float f = 3.2f; double d = f; -->可以执行

    4.2 大到小(显式转换)

    容量大的类型转换为容量小的类型时必须使用强制类型转换。

    int x = 999;
    byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换
    1. 转换过程中可能导致溢出或损失精度
      例如:int i =128; byte b = (byte)i; //打印的结果是-128
      因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
    2. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入
      例如:float f = 32.7f; int a2 =(int) f; //打印的结果是32
    3. 不能对boolean类型进行类型转换。

    4.3 口诀:

    小到大,直接转 大到小,强制转 浮变整,小数没

    低 ------------------------------------> 高

    byte,short,char→ int→ long→float→double

    5 运算规则(5条)

    5.1 计算结果的数据类型,与最大数据类型一致

    System.out.println(3/2);//1,int/int,得到的结果类型还是int
    System.out.println(3/2d);//1.5,int/double。得到的结果是double

    5.2 byte,short,char三种比int小的整数,运算时会先自动转换成int

    byte a = 1;
    byte b = 2;
    byte c = (byte)(a+b);
    //a+b会自动提升成int类型,右面得运算结果就是int大类型
    //给左面的byte小类型赋值,不可以,需要强转。

    5.3 整数运算溢出

    整数运算溢出

    整数运算,类似于一个钟表,转到最大时,再转会回到最小。
    计算:光速运行一年的长度是多少米?3亿m/s

    //溢出的现象:
    //因为做了大的整型数据的运算,会超出int取值范围。解决方法:把整数提升成long类型。
    System.out.println(300000000L * 60 * 60 * 24 * 365);

    5.4 浮点数运算不精确

    1-0.8 (这是一个现象,后续会学习解决方案)

    5.5 浮点数的特殊值

    Infinity 无穷大 3.14/0
    NaN not a number 0/0.0 或 0.0/0

    6 拓展 标识符命名风格

    1.【强制】标识符命名均不能以数字开头,而且下划线或美元符号开始,也不能以下划线或美元符号结束
    错误案例:1name / _ name / name_ / $ name / name $
    2.【强制】代码中的命名严禁使用拼音与英文混合的方式,更不允许直接使用中文的方式。
    说明:正确的英文拼写和语法可以让阅读者易于理解,避免歧义。
    注意,即使纯拼音命名方式也要避免采用。
    正确案例:alibaba / taobao / youku / hangzhou 等国际通用的名称,可视同英文。
    错误案例:DaZheModule [打折模块] / getPingfenByName() [评分]
    3.【强制】类名使用 UpperCamelCase 风格,即第一个单词的首字母就要大写

    展开全文
  • 主要介绍了JAVA学习笔记:注释、变量的声明和定义操作,结合实例形式分析了Java注释变量的声明和定义相关原理、实现方法及操作注意事项,需要的朋友可以参考下
  • Java注释

    千次阅读 2016-05-03 17:06:06
    Java注释 Java的注释不会出现在可执行程序。 Java中为我们提供了3种注释: // 单行注释:其注释内容从//开始到本行结尾。 /**/多行注释:/*注释内容在此处写*/ 多行注释。 /***/文档注释:注释以/**开始...

    Java注释

    Java中的注释不会出现在可执行程序中。

    Java中为我们提供了3种注释:

    // 单行注释其注释内容从//开始到本行结尾。

    /**/多行注释:/*注释内容在此处写*/  多行注释

    /***/文档注释:注释以/**开始,以*/结束。可以用来自动生成文档。

    下面注重来讲文档注释

     

    文档注释

    注释以/**开始,以*/结束。可以用来自动生成文档。

    JDK包含一个很有用的工具,叫做javadoc,它可以生成一个HTML文档。

    比如联机的API文档就是通过对标准Java类库的源代码运行javadoc生成的。

    可以直接将类、方法和变量的注释放置在java源文件中,只要用/**...*/文档注释就可以。


              如果编写Java源代码时添加了合适的文档注释,然后通过JDK提供的javadoc工具可以直接将源代码里的文档注释提取成一份系统的API文档。

     

    API文档

     

    1,API文档是什么?

        开发一个大型软件时,需要定义上千万个类,并且可能由多个程序员来开发这个软件,每个人都会定义一些类,并在这个类里定义方法、属性提供给他人使用,但其他人怎么知道如何使用呢?这时候急需要提供一份说明文档,用于说明每个类、每个方法的用途。当其他人使用一个类或方法时,他无须关心这个类或这个方法的具体实现,只要知道这个类或这个方法的功能即可,然后使用这个类或方法来实现具体的目的,也就是通过调用应用程序接口(API)来编程。API文档就是以说明这些应用程序接口的文档。对于Java语言而言,API文档通常详细说明了每个类、每个方法的功能,用法等。

     

    2,下载JDK的API文档

    (1)登录:http://java.sun.com/javase/downloads/index.jsp站点,下载”Java SE 8

     Documentation“项,通过该下载项下载Java SE 6文档,这份文档里包含了JDK的

    API文档。下载成功后得到一个jdk-6-doc.zip文件。

    (2)将jdk-6-doc.zip文件加压到任意路径,将得到一个docs文件夹。这个文件夹内

    就是JDK文档,JDK文档不仅包含API文档,还包含了JDK的其他说明文档,如果直接打开

    docs文件夹下的index.xml文件

             API文档页面被分成3个部分,左上角部分是API文档“包列表区”,在该区域内可以查看Java基类的所有包;左下角是API稳定啊的“类列表区”,用于查看Java基类的所有类;右边页面是“详细说明区”,默认显示的是各包空间的说明信息。

             我们在开发中定义类、方法时也可以先添加文档注释,然后使用javadoc工具来生成自己的API文档。

     

    3,我们要掌握查看API文档的方法的原因?

             API是Java提供的基库编程接口,当使用Java语言进行编程时,不可能把所有的Java类、所有的方法全部记录下来,那么当我们遇到不确定的地方时,必须通过API文档来查看某个类、某个方法的功能和用法。掌握查看API文档是学习Java的一个最基本的技能。


        由于文档注释是用于生成API文档,而API文档主要用于说明类、方法、属性的功能。

    javadoc工具默认只处理以public或protected修饰的类、接口、方法、属性、构造器

    之前的文档注释,忽略其他地方的文档注释。

        如果开发者希望javadoc工具可以提取private的内容,则可以在使用javadoc工具时

    增加-private选项。

     

    4,javadoc的常用选项:

     

    -d<directory>:

    该选项指定一个路径,用于将生成的API文档放到指定目录下。

     

    -windowtitle<text>:

    该选项指定一个字符串,用于设置API文档的浏览器窗口标题。

     

    doctitle<html-code>:

    该选项制定一个HTML格式文本,用于指定概述页面的标题。

    注意:一定要对处于多个包下的源文件来生成API文档,才有概述页面。

     

    -header<html-code>:该选项指定一个HTML格式的文本,包含每个页面的页眉。

    读者可以使用javadoc-help来查看javadoc命令的所有选项。

     

    6,常用的javadoc标记:


    @author:指定Java程序的作者



    @version:指定源文件的版本



    @deprecated:不推荐使用的方法



    @param:方法的参数的说明信息



    @return:方法的返回值的说明信息



    @see:“参见”,用于指定交叉参考的内容



    @exception:抛出异常的类型



    @throws:抛出异常,和exception同义。





    标记的使用是有位置限制的



    可以出现在类或借口文档注释中的有:


    @see、@deprecated、@author、@version等。



    可以出现在方法或构造器中的:


    @see、@deprecated、@param、@return、@throws和@exception等。


    可以出现在属性文档注释的有:

    @see、@deprecated等。

    文档注释注重点

    1,注释的插入:

    公有类与接口

    公有的的和受保护的方法

    公有的和受保护的域

    注意:

    每个/**...*/文档注释在标记之后紧跟着自由格式(free-form-text)。

    标记由@开始,如@author或@param

    自由格式文本的第一句应该是一个概要性的句子。javadoc实用程序自动地将这些句子抽取出来形成概要页。

    在自由格式文本中可以使用HTML修饰符。

    如果文档中有到其他文件的链接,例如图片,就应该将这些文件放到子目录doc-files中。javadoc实用程序将从源目录拷贝这些目录以及其中的文件到文档目录中。如:<img src="doc-files/uml.png" alt="UML diagram">


    2,类注释:

    类注释必须放在import语句之后,类定义之前。

    注释没有必要在每一行的开始用星号*,


    3,方法注释:

    每一个方法注释必须放在所描述的方法之前。除了通用标记之外,还可以使用以下标记:

    @param variable description

    这个标记将对当前方法的“param”(参数)部分添加一个条目。这个描述可以占据多行,并使用HTML标记。一个方法的所有@param标记必须放在一起。

     

    @return description

    这个标记将对当前方法添加“return”(返回)部分。这个描述可以跨越多行,并可以使用HTML标记。

     

    @throws class description

    这个标记将添加一个注释,用于表示这个方法有可能抛出异常。


    4,域注释

    只需要对公有域(通常指的是静态常量)建立文档


    5,通用注释:

    @author name

    这个标记将产生一个“author”(作者)条目。可以使用多个@author标记,

    每个@author标记对应一名作者

     

    @version text

    这个标记将产生一个“version”(版本)条目。

    text:可以是对当前版本的任何描述

     

    @since text

    这个标记将产生一个“since”(始于)条目

    text:可以是对引入特性的版本描述。

    例如:@since version 1.7.1

     

    @deprecated test

    这个标记将对类、方法或变量添加一个不再使用的注释。

    text:给出了取代的建议

    例如:@deprecated Use <code>SetVisible(true)</code> instead

     

    @see reference

    这个标记将在“see also”部分增加一个超级链接。它可以用于类中,也可以用于方法中。

    (1)只要提供类、方法或变量的名字,javadoc就会在文档中插入一个超链接,例如:@see com.gaiwu.javanote.MyNoteUseing#raiseSalary(double),

    建立一个链接到com.gaiwu.javanote.MyNoteUseing类的raiseSalary(double)

    方法的超链接。

    注意:当在当前包或当前类时,可以省略包名或包名和类名都省略掉。

    (2)指定一个可选的标签作为锚链接,例如:@see <a href="www.horstan.com/corejava.html">The Core Java home page</a>

    注意:也可以省略标签,用户看到的锚的名称就是目标代码名或URL

    (3)如果@see 标记后面有一个双引号字符,文本就会显示在“see also”部分,

    例如:@see “Core java 2volume 2”,可以为这特性添加多个@see标记,

    但必须将他们放在一起。

    (4)可以在注释中的任何位置放置指向其他类或方法的超级链接,

    以及插入一个专用的标记,例如:@link package.class#feature label

     

    6,包注释:

    若需要产生包注释,就需要在每一个包目录中添加一个单独的文件。有两个选择:

    (1)提供一个以package.html命名的HTML文件,在标记<body>...</body>

    之间的所有文本都会被抽取出来。

    (2)提供一个以package-info.java命名的Java文件。这个文件必须包含一个

    初始的以/**和*/界定的javadoc注释,跟随在一个包语句之后。它不应该包含更多的代码或注释。

             为所有的源文件提供一个概述性的注释。这个注释将被放置在一个名为overview.html的文件中,这个文件位于包含所有源文件的父目录中。标记<body></body>之间的所有文本将被抽取出来。当用户从导航栏中选择“Overview”时,就会显示出这些注释内容。


    7,注释抽取:

    假设将HTML文件将被存放在目录docDirectory下,执行如下命令:

    (1)切换到包含想要生成文档的源文件目录。如果有嵌套的包要生成文档,例如com.horsetmann.core.java,就必须切换到包含子目录com的目录。

    (2)如果是一个包,

    运行命令:javadoc -d docDirectory nameOfPackage

    或对于多个包生成文档,

    运行:javadoc -d docDirectory nameOfPackage1 nameOfPackage2...

    若文件在默认包中,

    运行:javadoc -d docDirectory *.java

    若省略了-d docDirectory 选项,那么HTML文件就会被提取到当前目录下。

    这样有可能产生混乱,不提倡这样做,

    http://java.sun.com/j2se/javadoc 联机文档


    代码示例:

    package com.gaiwu.javanote;

    //类文档注释

    /**

     * 

     * 

     * 

     * */

    public class MyNoteUseing {

        //域文档注释

        /**

         * The "Hearts" card suit

         * */

        public static final int HEARTS = 1;



        //方法文档注释

        /**

         * Raises the salary of an employee

         * @param byPercent the percentage by with to raise the salary(e.g. 10=10%)

         * @retuen the amount of the raise

         * */

        public double raiseSalary(double byPercent)

        {

            double salary = 0;

            salary++;

            double raise=salary*byPercent/100;

            salary+=raise;

            return raise;

        }


        /*

         * 多行文本注释

         * */

        public static void main(String[] args) {


        }

    }

     

    Annotation(注释)

             Annotation必须使用工具来处理,工具负责提取Annotation里包含的元素,还可以根据这些元素增加额外的功能。

     

    Java提供的三个基本Annotation的用法:

    1,限定重写父类方法:@Override

    @Override就是用来指定方法覆载的,它可以强制一个子类必须覆盖父类的方法。

    @Override只能作用于方法,不能作用于其他程序元素。

    代码示例:

    public class Fruit

    {

        public void foo()

        {

            System.out.println("水果的info方法...");

        }

    }

    class Apple extends Fruit

    {

        //使用@override指定下面方法必须重写父类方法

        @Override

        public void foo()

        {

            System.out.println("苹果重写水果的foo方法...");

        }

    }

    从以上中可能丝毫看不出程序中的@Override有何作用,因为@Override Annotation的

    作用是告诉编译器检查这个方法,并从弗雷查找是否包含一个被该方法重写的方法,否

    则就编译出错。它主要是帮助我们避免一些低级错误,例如,我们把Apple类中的foo方

    法不小心写成fio,这样的“低级错误”可能导致后期排错时的巨大障碍。


    2,标记已过时:@Deprecated

    @Deprecated用于表示某个程序元素(类、方法等)已过时,当其他程序使用已过时的类

    、方法时,编译器将会出现警告。

    代码示例:

    public class Fruit

    {

        //定义info方法已过时

        @Deprecated

        public void foo()

        {

            System.out.println("水果的info方法...");

        }

        public static void main(String[] args)

        {

            //下面使用info方法时将会被编译器警告

            new Apple().info();

        }

    }

    @Deprecatted Annotation与文档注释中的@deprecated标记的作用基本相同,但它们的

    用法不同,前者是JDK1.5才支持的注释,无须放在文档注释语法(/**...*/部分)中,

    而是直接用于修饰程序中的程序单元,如类、方法、接口等。

    3,抑制编译器警告:@SuppressWarnings

    @SuppressWarnings指示被Annotation表示的程序元素取消显示指定的编译器警告。

    代码示例:

    //关闭整个类里的编译器警告

    @SuppressWarnings(value="unchecked")

    public class SuppressWarningsTest

    {

        public static void main(String[] args)

        {

            List<String> myList=new ArrayList();

        }

    }

     

    自定义注释

    代码示例:

    //定义一个简单的Annotation类型

    public @interface Test

    {

    }

    使用Annotation时的语法非常类似于public、final这样的修饰符。通常可用于修饰程

    序中的类、方法、变量、接口等定义,通常我们会把Annotation放在所有修饰符之前,

    而且由于使用Annotation时可能还需要为其成员变量指定值,因而Annotation的长度可

    能较长,所以通常把Annotation另放一行,如下程序所示:

    //使用@Test修饰类dingyi

    @Test

    public class MyClass

    {

        ...

    }

    默认情况下,Annotation可用于修饰任何程序元素,包括类、接口、方法等,如下程序

    使用@TestAnnotation来修饰方法。

    public class MyClass

    {

        //使用@testAnnotation修饰方法

        @Test

        public void info()

        {

            ...

        }

        ...

    }

    Annotation可以带成员变量,Annotation定义中以无参数方法的形式来声明。其方法名和返回值定义了该成员的名字和类型。如下代码所示:

    public @interface MyTag

    {

        //定义了两个成员变量的Annotation

        //Annotation中的成员变量以方法的形式来定义

      //以defauly为两个成员变量指定初始值。

        String name() default "lili";

        int age() default 32;

    }

    public class Test

    {

        //使用带成员变量的Annotation时,需要为成员变量赋值

        @MyTag(name="xx",age=6)

        public void info()

        {

        }

    }


    根据Annotation是否可以包含成员变量,我们可以把Annotation分为两类:

    1,标记Annotation:

    一个没有成员定义的Annotation类型被称为标记。这种Annotation仅使用自身的存在与否来为我们提供信息。

    2,元数据Annotation:

    那些包含成员变量的Annotation,因为它们可接受更多元数据,所以被称为元数据Annotation。

    提取Annotation的信息

             java在java.lang.reflect包下新增了AnnotatedElement接口,该接口代表程序中可以接受注释的程序元素,该接口主要有如下几个实现类:

    1,Class:类定义

    2,Constructor:构造器定义

    3,Field:类的成员变量定义。

    4,Method:类的方法定义。

    5,Package:类的包定义。

    AnnotationElement接口是所有程序元素(如Class、Method、Constructor)的父接口程序通过反射获取了某个类的AnnotationElement对象(如Class、Method、Constructor)之后,程序就可以调用该对象的如下三个方法来访问Annotation信息:

    getAnnotation(Class<T> annotationClass):

    返回改程序元素上存在的、指定类型的注释,如果该类型的注释不存在,则返回null。

     

    Annotation[] getAnnotations():

    返回该程序元素上存在的所有注释

    boolean isAnnotationPresent(Class<? extends Annotation>annotationClass):

    判断改程序元素上是否包含指定类型的注释,存在则返回true,否则返回false。


    获取Test类的info方法里的所有注释,并将这些注释打印出来。

    //获取Test类的info方法的所有注释

    Annotation[] aArray=Class.forName("Test").getMethod("info").getAnnotations();

    //遍历所有注释

    for(Anotation an:aArray)

    {

        System.out.println(an);

    }

    如果我们需要获取某个注释里的元数据,则可以将注释强制类型转换成所需的注释类型,然后通过注释对象的抽象方法来访问这些元数据,代码如下所示:

    //获取tt对象的info方法所包含的所有注释

    Annotation[] annotation=tt.getClass().getMethod("info").getAnnotations();

    //遍历每个注释对象

    for(Annotation tag:annotation)

    {

        //如果注释类型是MyTagl类型

        if(tag instanceof MyTag1)

        {

            System.out.println("Tag is:"+tag);

            //将tag强制类型转换为MyTag1

            //并调用tag对象的method1和method2两个方法

            System.out.println("tag.name():"+(MyTag1)tag.method1);

            System.out.println("tag.name():"+(MyTag1)tag.method2);

        }

        //如果注释类型是MyTag2

        if(tag instanceof MyTag2)

        {

            System.out.println("Tag is:"+tag);

            //将tag强制类型转换为MyTag2

            //并调用tag对象的method1和method2两个方法

            System.out.println("tag.name():"+(MyTag2)tag.method1);

            System.out.println("tag.name():"+(MyTag2)tag.method2);

        }

    }

     

    使用Annotation例子

     

    JDK元Annotation

    JDK在java.lang.annotation包下提供了四个Meta Annotation(元 Annotation),这四个Annotation都是用于修饰其他Annotation定义。

    1,使用@Retention

    @Retention只能用于修饰一个Annotation定义,用于指定该Annotation可以保罗多长时间。@Retention包含一个RetentionPolicy类型的value成员变量,所以使用@Retention必须为该value成员变量指定值,值只有如下三个:

    RetentionPolicy.CLASS:编译器将把注释记录在class文件中。当运行Java程序时,JVM不再保留注释。这是默认值。

    RetentionPolicy.RUNTIME:编译器将把注释记录在class文件中。当运行Java程序时,JVM也会保留注释,程序可以通过反射获取该注释。

    Ret.SOUREC:编译器直接丢弃这种策略的注释。

    代码示例:

    //定义下面的Testable Annotation的保留到运行时

    @Retention(value=RetentionPolicy.RUNTIME)

    public @interface Testable{}

    //定义下面的Testable Annotation将被编译器直接丢弃

    @Retention(RetentionPolicy.SOURCE)

    public @interface Testable{}

    注意:若我们定义的Annotation类型里只有一个value成员变量,使用该Annotation时可以直接在Annotation后的括号里指定value成员变量的值,无须使用name=value的形式。

     

    2,使用@Target

    @Target用于指定被修饰的Annotation能用于修饰哪些程序元素。@Target Annotation包含一个名为value的成员变量,成员变量的值只能是下面的几个:

    ElementType.ANNOTATION_TYPE:

    指定该策略的Annotation只能修饰Annotation。

     

    ElementType.CONSTRUCTOR:

    指定该策略的Annotation能修饰构造器。

     

    ElementType.FIELD:

    指定该策略的Annotation只能修饰成员变量。

     

    ElementType.LOCAL_VARIABLE:

    指定该策略的Annotation只能修饰局部变量。

     

    ElementType.METHOD:

    指定该策略的Annotation只能修饰方法定义。

     

    ElementType.PACKAGE:

    指定该策略的Annotation只能修饰包定义。

     

    ElementType.PARAMETER:

    指定该策略的Annotation可以修饰参数。

     

    ElementType.TYPE:

    指定该策略的Annotation可以修饰类、接口(包括注释类型)或枚举定义。

    代码示例:

    @Target(ElementType.FIELD)

    public @interface ActionListenerFor{}

    @Target(ElementType.METHOD)

    public @interface Testable{}

     

    3,使用@Documented

    @Documented用于指定被该元Annotation修饰的Annotation类将被javadoc工具提取成文档,如果定义Annotation类时使用了@Documented修饰,则所有使用该Annotation修饰的程序元素的API文档中将会包含该Annotation说明。

    代码定义:

    @Retention(RetentionPolicy.RUNTIME)

    @Target(ElementType.METHOD)

    //定义Testable Annotation将被javadoc工具提取

    @Documented

    public @interface Testable{}

    public class MyTest

    {

        //使用@Test修饰info方法

        @Test

        public void info()

        {

            System.out.println("info方法...");

        }

    }

    4,使用@Inherited

    @Inherited元Annotation指定被它修饰的Annotation将具有继承性:如果某个类使用了Annotation(定义该Annotation时使用了@Inherited修饰)修饰,则其子类将自动具有A注释。

    代码示例:

    @Target(ElementType.TYPE)

    @Retention(RetentionPolicy.RUNTIME)

    @Inherited

    public @interface Inheritable{}


    //使用@Inheritable修饰的Base类

    @Inheritable

    class Base

    {


    }

    //TestInheritable类只是继承了Base类。

    //并未直接使用@Inheritable Annotation修饰

    public class TestInheritable extends Base

    {

        public static void main(String[] args)

        {

            //打印TestInheritable类是否具有Inheritable Annotation

            System.out.println(TestInHeritable.class.isAnnotationPresent(Inheritable.class));

        }

    }

    输出结果为:true

     

     

    展开全文
  • 01_Java基础(Java概述、环境变量注释、关键字、标识符、常量)_讲义
  • java注释方法

    千次阅读 2019-05-19 18:41:15
    Java注释的好处:java注释可以帮助我们去理解代码,Javac不会去编译注释,Java运行也不会管我们的注释内容,合理运用注释可以让我们的代码更容易让编程人员理解。 Java的注释有以下几种: 1.单行注释:// 单行注释...

    Java注释的好处:java注释可以帮助我们去理解代码,Javac不会去编译注释,Java运行也不会管我们的注释内容,合理运用注释可以让我们的代码更容易让编程人员理解。
    Java的注释有以下几种:

    1.单行注释://

    单行注释即只能注释一行的内容,用在注释信息内容少的地方

    2.多行注释:/* */

    多行注释即可以注释很多行的内容,为了增加可读性,一般首行和尾行不写注释信息。此外,需要注意的是,多行注释能嵌套单行注释,但不能嵌套多行注释和文档注释

    3.文档注释:/** */

    文档注释也能注释多行内容,一般用在类、方法和变量上,用来描述其作用(鼠标放在类和变量上会自动显示出我们在文档注释里的内容),文档注释也能嵌套单行注释,但不能嵌套多行注释和文档注释,一般首行和尾行也不写注释信息

    展开全文
  • 包含了Java的命名规范。包括文件,变量注释,函数名等等的规范. 包含了4个文件(变量注释,空格等等分类列示)
  • eclipse/myeclipse自带了几种注释变量名称。这些名称能够帮助我们在注释添加一些有用的、重复的东西。但是其提供的名称有限,往往我们需要在其上添加一些其它的名称,那么应该如何添加呢,在网络上搜索一段时间...
  • java注释模版

    千次阅读 2014-12-11 15:23:59
    每个类,接口,函数都写上注释是良好的编程习惯。 这样以后自己查看代码时也能很快的理解其中的意思。 注释模版 下面给出注释的模版,直接复制粘贴到函数前面即可。 文件头注释 /* * Created on 2005-7-2 * /...
  • eclipse/myeclipse自带了几种注释变量名称。这些名称能够帮助我们在注释添加一些有用的、重复的东西。但是其提供的名称有限,往往我们需要在其上添加一些其它的名称,那么应该如何添加呢,在网络上搜索一段时间...
  • Java注释规范整理

    千次阅读 2014-07-19 15:20:56
    在软件开发的过程总是强调注释的规范,但是没有一个具体的标准进行说明,通常都是在... JAVA注释规范 版本/状态 作者 版本日期 1.0 ghc 2008-07-02 一、背景 1、当我们第一次接触某段代码,但又被要求在极短的时
  • Java注释Annotation

    千次阅读 2014-10-27 10:16:52
    Java注释Annotation 从JDK 5开始,Java增加了对元数据(MetaData)的支持,也就是Annotation(注释)。Annotation提供了一种为程序元素设置元数据的方法,程序元素包括修饰包、类、构造器、方法、成员变量、参数...
  • JAVA注释

    千次阅读 2018-11-28 20:47:33
    一、可以用注释来调试程序。   二、单行注释&lt;//注释内容&gt;,不能跨行。   三、多行注释&lt;/*注释内容*/&gt;,可以跨行   四、文档注释确保了注释与源码的连接,便于维护,格式&...
  • Java 注释技巧

    千次阅读 2014-07-09 21:09:42
    在最初学习Android时候使用了Eclips IDE工具,编写java程序时,总是要添加一些注释,用以说明某段代码的作用,由于是从C过度来的,也没有太在意java注释有何不同,将鼠标移动到Android sdk 提供的类、方法、属性上...
  • intellij自动生成java代码注释,包括java文件头部的注释java方法的注释
  • Java注释总结

    千次阅读 2014-11-01 23:44:36
    注释风格设置方法: javadoc注释 注释快捷键 模板
  • java中的全局变量

    万次阅读 2009-06-10 11:26:00
     在网上查了不少的资料,得到一点点体会: 首先,java中是没有全局变量这个概念的,java程序不能像C++那样在类外定义全局变量,因为JAVA当初出现的初衷就是为了安全性和跨平台性,所以去掉了类似C、C++的全局...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 276,190
精华内容 110,476
关键字:

java注释中可用的变量

java 订阅