注释是对所写代码的解释和说明，以提高程序的可读性，因此在程序中添加注释文字十分有必要。
以//开头，没有结束标签，单行注释只能注解以//开头这一行的文字信息。
public class HelloWorld {
//main方法是一个程序的入口方法
public static void main(String[] args){
System.out.println("Hello World!");
}
}
以/* 开头, 以*/结尾，多行注释可以注解多行文字。
public class HelloWorld {
//main方法是一个程序的入口方法
public static void main(String[] args) {
print("Hello, World!");
}
/*
* 这是一个打印方法
* 可以打印以字符串传输过来的参数
* */
public static void print(String str) {
System.out.println(str);
}
}
以/** 开头，以 */结尾，文档注释包含关于类、变量和方法的主要描述。
也可以包含一个或多个各种各样的 @ 标签。每一个 @ 标签必须在一个新行的开始。
public class HelloWorld {
//main方法是一个程序的入口方法
public static void main(String[] args) {
print("Hello, World!");
}
/**
* 这是一个打印方法
* @param str str参数是在方法中将要打印是字符串
* */
public static void print(String str) {
System.out.println(str);
}
}
关键字是指Java中预留的，赋予了特殊含义的单词。
关键字的特点：关键字的字母全部小写。
倘若一个词在编译器中被高亮显示，则这个词一般是关键字。
public class HelloWorld {
//main方法是一个程序的入口方法
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
如这段代码中的public、class、static、void、String等都是关键字。
? 我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母”b”表示。而计算机中最基本的存储单元叫“字节（byte）”，通常用大写字母”B”表示，字节是由连续的8个位组成。
? 除了字节外还有一些常用的存储单位，其换算单位如下：
? 1B（字节） = 8bit（位）
? 1KB = 1024B
? 1MB = 1024KB
? 1GB = 1024MB
? 1TB = 1024GB
? Java是一个强类型语言，Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。
| 数据类型 | 关键字 | 占用内存 | 取值范围 | 默认值 |
|---|---|---|---|---|
| 整形 | byte | 1B(8bit) | -2^7 ~ 2^7-1(-128 ~ 127) | 0 |
| short | 2B(16bit) | -2^15 ~ 2^15-1(-32768 ~ 32767) | 0 | |
| int | 4B(32bit) | -2^31 ~ 2^31-1(-2147483648 ~ 2147483647) | 0 | |
| long | 8B(64bit) | -2^63 ~ 2^63-1 | 0L | |
| 浮点类型 | float | 4B(32bit) | 负数:-3.402823E+38 ~ -1.401298E-45 正数:1.401298E-45 ~ 3.402823E+38 | 0.0f |
| double | 8B(64bit) | 负数:-1.797693E+308 ~ -4.9000000E-324 正数:4.9000000E-324 ~ 1.797693E+308 | 0.0d | |
| 字符型 | char | 2B(16bit) | 0 ~ 2*16-1(0 ~ 65536) | |
| 布尔型 | boolean | 1B(8bit) | true 和 false | false |
说明：
? e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
? 在Java中整数默认是int类型，浮点数默认是double类型。
常量一般指在程序运行中值不可变的量，一般全部用大写表示。
变量的定义格式
//final 关键字 final常量一旦被初始化赋值之后，就不能再被赋值了。
//因此在定义变量时需要给常量赋初值
//final 数据类型 变量名 = 初始化值
final int A = 10;
final int INTEGER_NUMBER = 20;
System.out.println(a);
System.out.println(INTEGER_NUMBER);
//这两个赋值操作是不允许的，因为final 修饰的常量的值不允许被改变
A = 20;
INTEGER_NUMBER = 30;
public class HelloWorld {
//定义byte类型常量BYTE
public static final byte BYTE = 10;
//定义short类型常量SHORT
public static final short SHORT = 20;
//定义int类型常量INT
public static final int INT = 30;
//定义long类型常量LONG
public static final long LONG = 40;
//定义float类型常量FLOAT
public static final float FLOAT = 1.1f;
//定义double类型常量DOUBLE
public static final double DOUBLE = 2.2d;
//定义char类型常量CHAR
public static final char CHAR = ‘A‘;
//定义boolean类型常量BOOLEAN
public static final boolean BOOLEAN = false;
//定义String类型常量STRING
public static final String STRING = "Hello, World!";
//main方法是一个程序的入口方法
public static void main(String[] args) {
System.out.println(BYTE);
System.out.println(SHORT);
System.out.println(INT);
System.out.println(LONG);
System.out.println(FLOAT);
System.out.println(DOUBLE);
System.out.println(CHAR);
System.out.println(BOOLEAN);
System.out.println(STRING);
}
}
变量一般是在程序运行过程中，其值会随着程序运行而改变的量。
从本质上讲，变量是内存上一小块区域，其值可以在一定范围内变化。
变量的定义格式
//声明变量并赋值
//数据类型 变量名 = 初始化值
int a = 10;
System.out.println(a);
//先声明变量
//数据类型 变量名
int a;
//再赋值
//变量名 = 初始化值
a = 10;
System.out.println(a);
还可以在同一行上定义多个同一数据类型的变量，中间用逗号隔开。但是不建议使用这种方法，这将会影响程序的可读性。
public class HelloWorld {
//定义byte类型变量b
public static byte b = 10;
//定义short类型变量s
public static short s = 20;
//定义int类型变量i
public static int i = 30;
//定义long类型变量l
public static long l = 40;
//定义float类型变量f
public static float f = 1.1f;
//定义double类型变量d
public static double d = 2.2d;
//定义char类型变量c
public static char c = ‘A‘;
//定义boolean类型变量bb
public static boolean bb = false;
//定义String类型变量str
public static String str = "Hello, World!";
//main方法是一个程序的入口方法
public static void main(String[] args) {
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println(c);
System.out.println(bb);
System.out.println(str);
}
}
变量和常量的访问：通过变量名直接访问
在同一对花括号中，变量名不能重复。
变量在使用之前，必须初始化（赋值）。
定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。
因为整数默认是int类型，整数太大可能超出int范围。
定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。
因为浮点数的默认类型是double， double的取值范围是大于float的，类型不兼容。
标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。
小驼峰式命名：变量名、方法名
首字母小写，从第二个单词开始每个单词的首字母大写。
大驼峰式命名：类名
每个单词的首字母都大写。
标识符的命名应做到见名知意
//大驼峰式命名：每个单词首字母大写
public class HelloWorld {
public static void main(String[] args) {
//小驼峰式命名:首字母小写，从第二个单词开始首字母大写
//定义int变量myAge 我的年龄
int myAge = 20;
printString("Hello, World!");
printInteger(myAge);
}
//小驼峰式命名:首字母小写，从第二个单词开始首字母大写
//打印String类型值
public static void printString(String strParams) {
System.out.println(strParams);
}
//小驼峰式命名:首字母小写，从第二个单词开始首字母大写
//打印int类型变量值
public static void printInteger(int intParams) {
System.out.println("int : " + intParams);
}
}
在Java中，一些数据类型之间是可以相互转换的。分为两种情况：隐式转换（自动类型转换）和显式转换（强制类型转换）。
把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，因从也被称为自动类型转换。
double num = 10; // 将int类型的10直接赋值给double类型
System.out.println(num); // 输出10.0
把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。这种转换需要人为强制转换，因从也被称为强制类型转换。
在转换过程中，有可能发生数据的丢失，如将double类型数据转换为int类型数据，会使得小数部分数据丢失。
//格式：目标数据类型 变量名 = (目标数据类型)值或者变量;
double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5（小数位直接舍弃）
char类型的数据转换为int类型是按照码表中对应的int值进行计算的。比如在ASCII码表中，‘a‘对应97。
int a = ‘a‘;
System.out.println(a); // 将输出97
整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。
byte b1 = 10;
byte b2 = 20;
byte b3 = b1 + b2;
// 第三行代码会报错，b1和b2会自动转换为int类型，计算结果为int，int赋值给byte需要强制类型转换。
// 修改为:
int num = b1 + b2;
// 或者：
byte b3 = (byte) (b1 + b2);
boolean类型不能与其他基本数据类型相互转换。
原文：https://www.cnblogs.com/eliassblog/p/14261582.html