java基础
第一个JAVA程序的总结和提升... 1
JAVA注释... 2
标识符Identifier：... 2
关键字/保留字: 3
JAVA基本数据类型... 4
整型变量... 4
浮点型... 5
字符型... 6
boolean类型... 6
JAVA变量... 7
Final 常量... 8
命名规则... 8
运算符... 8
二元运算符... 9
一元运算符... 9
布尔逻辑表达符... 9
位运算符... 10
扩展运算符... 10
字符串连接符... 10
三目条件运算符... 10
运算符优先级的问题... 11
自动类型转换... 11
基本类型转化时常见错误和问题... 12
方法... 13
内存分析-变量... 14
垃圾回收机制... 14
字符串... 14
读取键盘录入数据... 17
格式化输出... 17
第一个JAVA程序的总结和提升
n Java对大小写敏感，如果出现了大小写拼写错误，程序无法运行。
n 关键字public被称作访问修饰符（accessmodifier）,用于控制程序的其它部分对这段代码的访问级别。
n 关键字class 表明Java 程序中的全部内容都包含在类中，Java是一种纯面向对象的语言。
n 一个源文件中至多只能有一个public的类声明，其它类的个数不限，如果源文件中包含一个public 类，源文件名必须和它中定义的public的类名相同，且以“java”为扩展名。
n 一个源文件可以有多个class
n 正确编译后的源文件，会得到相应的字节码文件，编译器为每个类生成独立的字节码文件，且将字节码文件自动命名为类的名字且以“class”为扩展名。
n main方法是Java应用程序的入口方法，它有固定的书写格式：
n public static void main(String[] args[雨林木风1] ) {…}
n 在Java中，用花括号划分程序的各个部分，任何方法的代码都必须以“{”开始，以“}”结束， 由于编译器忽略空格，所以花括号风格不受限制。
n Java中每个语句必须以分号结束，回车不是语句的结束标志，所以一个语句可以跨多行。
编程风格:
1. 注意缩进!
2. 成对编程!
JAVA注释
n 注释就是程序员为读者作的说明，是提高程序可读性的一种手段
n 在Java中，有2种表示注释的方法
q // 单行注释----注释内容从//到本行结尾
q /*
单行或多行注释
*/
n /* */注释不能嵌套
n Java中的注释不会出现在字节码文件中。即JAVA编译器编译时会跳过注释语句。
Doc 注释???
标识符Identifier(见名知意！！！)
用作给变量、类和方法命名。注意：
表示类名的标识符用大写字母开始。如：Man,GoodMan
表示方法和变量的标识符用小写字母开始，后面的描述性词以大写开始。eat(),eatFood[雨林木风2] ()
Java标识符有如下命名规则：
n 标识符必须以字母、下划线_ 、美元符$开头。
n 标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。
n Java 标识符大小写敏感，且长度无限制。
n 不可以是Java的关键字。
JAVA不采用通常语言使用的ASCII字符集，而是采用unicode这样的标准的国际字符集。因此，这里的字母的含义：英文、汉字等等。(不建议大家使用汉字来定义标识符！)
各种字符集的关系？
合法的标识符：
int a = 3;
int _123 = 3;
int $12aa = 3;
int 变量1 = 55;
不合法的标识符：
int 1a= 3; //不能用数字开头
int a# = 3; //不能包含#这样的特殊字符
int int = 3; //不能使用关键字
关键字/保留字
Java关键字是Java语言保留供内部使用的,如class用于定义类。 关键字也可以称为保留字,它们的意思是一样的。
| abstract |
assert |
boolean |
break |
byte |
case |
| catch |
char(character) |
class |
const |
continue |
default |
| do |
double |
else |
extends |
final |
finally |
| float |
for |
goto |
if |
implements |
import |
| instanceof |
int |
interface |
long |
native |
new |
| null |
package |
private |
protected |
public |
return |
| short |
static |
strictfp |
super |
switch |
synchronized |
| this |
throw |
throws |
transient |
try |
void |
| volatile |
while |
不能使用关键字作为变量名或方法名。
JAVA基本数据类型
n Java是一种强类型语言，每个变量都必须声明其类型。
n Java的数据类型分为两大类：基本类型（primitive type）和引用类型（referencetype）
n Java中定义了3类8种基本数据类型
q 逻辑型－boolean
q 文本型－ char
q 数值型－ byte, short, int, long, float, double
整型变量：
整型用于表示没有小数部分的数值，它允许是负数。
整型的范围与运行Java代码的机器无关，这正是Java程序具有很强移植能力的原因之一。于此相反，C和C++程序需要针对不同的处理器选择最有效的整形。
| 类 型 |
占用存储间 |
表数范围 |
| byte |
1字节 |
-128 ~ 127 |
| short |
2字节 |
-215 ~ 215-1 （-32768~32767） |
| int （integer） |
4字节 |
-231 ~ 231-1 (-2147483648~2147483647) 约21亿 |
| long |
8字节 |
-263 ~ 263-1 |
n Java 语言整型常数的三种表示形式：
q 十进制整数，如：99, -500, 0。
q 八进制整数，要求以 0 开头，如：015。
q 十六进制数，要求 0x 或 0X 开头，如：0x15 。
n Java语言的整型常数默认为int型，声明long型常量可以后加‘ l ’或‘ L ’[雨林木风3] ，如：
long a = 55555555; //不出错，在Int表示的范围内(21亿内)。
long b = 55555555555;//不加l出错，已经超过int表示的范围。报错：
The literal 55555555555 of type int is out of range
n Java中没有无符号类型
浮点型：
| 类 型 |
占用存储空间 |
表数范围 |
| float |
4字节 |
-3.403E38~3.403E38 |
| double |
8字节 |
-1.798E308~1.798E308 |
n float类型又被称作单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。
n double表示这种类型的数值精度是float类型的两倍，又被称作双精度，绝大部分应用程序都采用double类型。
n Java 浮点类型常量有两种表示形式
n 十进制数形式，例如:
n 3.14 314.0 0.314
n 科学记数法形式，如
n 314e2 314E2 314E-2
double f = 314e2; //314*10^2-->31400.0
double f2 = 314e-2; //314*10^(-2)-->3.14
n Float类型的数值有一个后缀F/f ，没有后缀F/f的浮点数值默认为double类型。也可以在浮点数值后添加后缀D/d, 以明确其为double类型：
| 3.浮点类型float, double的数据不适合在不容许舍入误差的金融计算领域。 注： 主要理由：由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。浮点数一般都存在舍入误差，很多数字无法精确表示(例如0.1)，其结果只能是接近， 但不等于。
二进制浮点数不能精确的表示0.1,0.01,0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。
最好完全避免使用浮点数比较： float f = 0.1f; double d = 1.0/10; System.out.println(f==d); //false
大数值： Java.math下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。
浮点数使用总结： 1. 默认是double 2. 浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。 3. 最好避免比较中使用浮点数 |
字符型（2个字节）：
n 单引号用来表示字符常量。例如‘A’是一个字符，它与“A”是不同的，“A”表示含有一个字符的字符串。
n char 类型用来表示在Unicode编码表中的字符。
n Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符；ASCII码占1个字节，可允许有128个字符，是Unicode编码表中前128个字符。
char eChar = 'a';
char cChar ='中';
n Unicode具有从0到65535之间的编码，他们通常用从’\u0000’到’\uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）
char c = ‘\u0061;
n Java 语言中还允许使用转义字符‘\’来将其后的字符转变为其它的含义，
char c2 = '\n'; //代表换行符
| 转义符 |
含义 |
Unicode值 |
| \b |
退格（backspace） |
\u0008 |
| \n |
换行 |
\u000a |
| \r |
回车 |
\u000d |
| \t |
制表符（tab） |
\u0009 |
| \“ |
双引号 |
\u0022 |
| \‘ |
单引号 |
\u0027 |
| \\ |
反斜杠 |
\u005c |
注：以后我们学的String类，其实是字符序列(char sequence)[雨林木风4] 。
boolean类型（一位，不是一个字节）：
n boolean类型有两个值，true和false,不可以 0 或非 0 的整数替代 true 和 false ，这点和C语言不同。
n boolean 类型用来判断逻辑条件，一般用于程序流程控制 。
booleanflag ;
flag= ………;
if(flag) {
// true分支
} else {
// false分支
}
| 实践：简洁是美德，请不要这样写：if ( is == true && done == false ) ，只有新手才那么写。 |
固定的存储空间正是Java可移植性、跨平台的原因之一！
JAVA变量
Java是一种强类型语言，每个变量都必须声明其类型。
n Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
n 变量在使用前必须对其声明,只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：
q type varName [=value] [{,varName[=value]}] ；
n 注意事项：
q 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
q 变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号结束
n 变量声明举例：
double salary ； boolean done；
long earthPopulation ； int age ；
n 可以在一行中声明多个变量：
int i ,j; // both are integers
q 不提倡这种风格，逐一声明每一个变量可以提高程序可读性。
n 可以将变量的声明和初始化放在同一行中，例如：
intage = 18; float e = 2.718281828f;
n 变量按被声明的位置可划分为：
q 局部变量：方法或语句块内部定义的变量
在使用前必须先声明和初始化(赋初值)。
| public void incorrectLocalV() { int i; i=10; int j = i+5 ; // 编译出错，变量i还未被初始化 }
|
q 实例变量（成员变量）：方法外部、类的内部定义的变量
如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0[雨林木风5] ，布尔型默认是false）
课堂练习1：
public class LocalVariableTest {
public static voidmain(String[ ] arg) {
boolean flag = true; // 声明boolean型变量并赋值
char c1, c2; // 声明char型变量
c1 = '\u0041'; // 为char型变量赋值
c2 = 'B'; // 为char型变量赋值
int x; // 声明int型变量
x = 9; //为int型变量赋值
int y = x; // 声明并初始化int型变量
float f = 3.15f; // 声明float型变量并赋值
double d = 3.1415926; //声明double型变量并赋值
}
}
Final 常量：
publicclass Constants {
public static void main(String[] args){
final double PI = 3.14;
// PI = 3.15; //error
double r = 4;
double area = PI * r * r;
doublecircle = 2 * PI * r;
System.out.println("area= " + area);
System.out.println("circle= " + circle);
}
}
命名规则(规范)：
1. 所有变量、方法、类名：见名知意
2. 类成员变量：首字母小写和驼峰原则 : monthSalary
3. 局部变量：首字母小写和驼峰原则
4. 常量：大写字母和下划线：MAX_VALUE
5. 类名：首字母大写和驼峰原则: Man, GoodMan
6. 方法名：首字母小写和驼峰原则: run(), runRun()
运算符：
n Java 语言支持如下运算符：
q 算术运算符: +，-，*，/，%，++，--
q 赋值运算符 =
q 关系运算符: >，<，>=，<=，==，!= instanceof
q 逻辑运算符: &&，||，!
q 位运算符: &，|，^，~ ， >>，<<，>>>(了解！！！)
q 条件运算符 ？：
q 扩展赋值运算符:+=，-=，*=，/=
二元运算符：
整数运算：
如果两个操作数有一个为Long, 则结果也为long
没有long时，结果为int。即使操作数全为shot,byte，结果也是int.
浮点运算：
如果两个操作数有一个为double, 则结果为double.
只有两个操作数都是float, 则结果才为float.
[雨林木风6]
取模运算：
其操作数可以为浮点数,一般使用整数。如：5.9%3.9=2.000000004
要点：
负数%负数＝负数；
负数%正数＝负数；
正数%负数＝正数；
一元运算符(++, --)：
int a = 3;
int b = a++; //执行完后,b=3。先给b赋值，再自增。
int c= ++a; //执行完后,c=5。先自增,再给b赋值
注意：java中的乘幂处理：
int a = 3^2; //java中不能这么处理， ^是异或符号。
double b = Math.pow(3,2);
Math类提供了很多科学和工程计算需要的方法和常数。
布尔逻辑表达符：
逻辑与：&&，逻辑或：||，逻辑非：！。
逻辑与和逻辑或采用短路的方式。从左到右计算，如果确定值则不会再计算下去。
逻辑与只要有一个为false, 则直接返回false.
逻辑或只要有一个为true, 则直接返回true;
boolean c = 1>2&&[d7] 2>(3/0);
位运算符：（了解）
~-- 取反 & -- 按位与
| -- 按位或 ^ -- 按位异或
<<：左移运算符， >>：右移运算符 >>>：无符号移位运算符
右移一位相当于除2取商。
左移一位相当于乘2。
int a = 3*2*2;
int b =3<<2; //相当于：3*2*2;
int a = 12/2/2;
int b = 12>>2;
扩展运算符：
| 运算符 |
用法举例 |
等效的表达式 |
| += |
a += b |
a = a+b |
| -= |
a -= b |
a = a-b |
| *= |
a *= b |
a = a*b |
| /= |
a /= b |
a = a/b |
| %= |
a %= b |
a = a%b |
字符串连接符：
³ “+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。
int c = 12;
System.out.println("c="+ c);
三目条件运算符
l 三目条件运算符，语法格式：
x ? y : z[雨林木风8]
l 其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个三目运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。
l 举例：
intscore = 80; int x = -100;
Stringtype = score< 60 ? "不及格" : "及格";
int flag = x > 0 ? 1 : (x == 0 ? 0 :-1);
System.out.println("type=" + type);
System.out.println("flag="+ flag);
运算符优先级的问题
|
|
. ( ) { } ; , |
| L to R |
* / % |
| L to R |
+ - |
| L to R |
<< >> >>> |
| L to R |
< > <= >= instanceof |
| L to R |
== != |
| L to R |
& |
| L to R |
^ |
| L to R |
| |
| L to R |
&& |
| L to R |
|| |
| R to L |
? : |
| R to L |
= *= /= %= |
大家不需要去刻意的记住他，表达式里面优先使用小括号来组织！！
自动类型转换：
n 自动类型转换：容量小的数据类型可以自动转换为容量大的数据类型。在图中，黑色的实线表示无数据丢失的自动类型转换，而红色的虚线表示在转换时可能会精度的损失。
n 特例: 可以将整型常量直接赋值给byte, short, char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围
q Short b = 12; //合法
q short b = 1234567; //非法
n 强制类型转换（Cast）： 强制类型转换，又被称为造型，用于显式的转换一个数值的类型. 在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。
n 强制类型转换的语法格式：“(type)var”，运算符“()”中的type表示将值var想要转换成的目标数据类型。
例如：doublex = 3.14；
int nx = (int)x; //值为3
charc = 'a';
intd = c+1;
System.out.println(d);
System.out.println((char)d);
n 当将一种类型强制转换成另一种类型，而又超出了目标类型的表示范围，就会被截断成为一个完全不同的值。
例如： int x =300;
byte bx = (byte)x; //值为44
n 不能在布尔类型和任何数值类型之间做强制类型转换。
q 如果需要把布尔类型转换成一个数字该怎么办呢?[d9]
基本类型转化时常见错误和问题：
1. 操作比较大的数时，要留意是否溢出，尤其是整数操作时。
| int money = 1000000000; //10亿 int years = 20; int total = money*years; //返回的是负数 long total1 = money*years; //返回的仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失 long total2 = money*((long)years); //先将一个因子变成long，整个表达式发生提升。全部用long来计算。 |
2. L和l 的问题：
1. 不要命名名字为l的变量
2. long类型使用大写L不要用小写。
| int l = 2; long a = 23451l; System.out.println(l+1); |
方法：
l Java的方法类似于其它语言的函数，是一段用来完成特定功能的代码片段，声明格式：
[修饰符1 修饰符2 …] 返回值类型 方法名(形式参数列表){
Java语句；… … …
}
l 形式参数：在方法被调用时用于接收外界输入的数据。
l 实参：调用方法时实际传给方法的数据。
l 返回值：方法在执行完毕后返还给调用它的环境的数据。
l 返回值类型：事先约定的返回值的数据类型，如无返回值，必须给出返回值类型void。
l Java语言中使用下述形式调用方法：对象名.方法名(实参列表)
l 实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配，
l return 语句终止方法的运行并指定要返回的数据。
l Java中进行方法调用中传递参数时，遵循值传递的原则：
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身。
引用传递or值传递？（暂不讲，只了解。讲完对象后回头再看。）
JAVA中，只有值传递！
从编译原理的角度讲，所有那些无法通过形参来修改实参本身的传递机制都是“值传递”，在JAVA中，你只能通过在形参上调用方法来修改实参所引用的那个对象，却修改不了实参本身（不能使它引用到另个对象）
| public class TestMethod{
void change(Man m){ Man ren = new Man(); ren.name="li"; ren.age=20; m=ren; }
public static void main(String[] args){ TestMethod d = new TestMethod(); Man man = new Man(); man.name="gao"; man.age=18; d.change(man);
System.out.println(man.name); //仍然为gao } }
class Man { String name; int age; } |
内存分析-变量
（暂不讲，只了解。讲完对象后回头再看。）
方法区：
1. 被所有线程共享！
2. 用来存放程序中永远是不变或唯一的内容。（类代码信息、静态变量、常量、字符串常量）
栈：
1. 每个线程私有，不能实现线程间的共享！
2. 局部变量放置于栈中。
3. 栈是由系统自动分配，速度快！栈是一个连续的内存空间！
堆：
1. 放置new出来的对象！
2. 堆是一个不连续的内存空间，分配灵活，速度慢！
垃圾回收机制(Gabbage Collection)
（暂不讲，只了解。讲完对象后回头再看。）
1. 是由系统自动调用。
2. 程序员并不能控制何时进行垃圾回收，System.gc()只是向系统提个回收建议.
字符串（java.lang.String类）
n Java字符串就是Unicode字符序列，例如串“Java”就是4个Unicode字符J,a,v,a组成的。
n Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。
String e = “” ; // anempty string
String greeting = “Hello World”;
n Java允许使用符号"+"把两个字符串连接起来
Strings1 = “Hello”;String s2 = “World!”;
Strings = s1 + s2; //HelloWorld!
n 符号“+”把两个字符串按给定的顺序连接在一起，并且是完全按照给定的形式。
n 当“+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接
int age = 18;
String s = "age is" + age; //s赋值为age is 18
这种特性通常被用在输出语句中：
System.out.println(“age is” + age）;
开始学习阅读API文档：
字符串类常用的方法：
n char charAt(int index)
返回字符串中第index个字符。
n boolean equals(String other)
如果字符串与other相等，返回true
n boolean equalsIgnoreCase(String other)
如果字符串与other相等（忽略大小写），则返回true
n int indexOf(String str) lastIndexOf()
n int indexOf(String str,int fromIndex)
返回与str匹配的第一个字串的开始位置，该位置从0或fromIndex开始计算，如果原始串中不存在str，返回-1.
n int length()
返回字符串的长度。
n String replace(char oldChar,char newChar)
返回一个新串，它是通过用 newChar 替换此字符串中出现的所有oldChar而生成的
| public class StringTest1 { public static void main(String[] args) { String s1 = "core java"; String s2 = "Core Java"; System.out.println(s1.charAt(4)); System.out.println(s2.length()); System.out.println(s1.equals(s2)); System.out.println(s1.equalsIgnoreCase(s2)); System.out.println(s1.indexOf("java")); System.out.println(s1.indexOf("apple")); String s = s1.replace(' ', '&'); System.out.println("result is :" + s); } } |
n boolean startsWith(String prefix)
如果字符串以prefix开始，则返回true
n boolean endsWith(String prefix)
如果字符串以prefix结尾，则返回true
n String substring(int beginIndex)
n String substring(int beginIndex,int endIndex)
n 返回一个新字符串，该串包含从原始字符串beginIndex到串尾或endIndex-1的所以字符
n String toLowerCase()
返回一个新字符串，该串将原始字符串中的所有大写字母改成小写字母
n String toUpperCase()
返回一个新字符串，该串将原始字符串中的所有小写字母改成大写字母
n String trim()
返回一个新字符串，该串删除了原始字符串头部和尾部的空格
| public class StringTest2 { public static void main(String[] args) { String s = ""; String s1 = "How are you?"; System.out.println(s1.startsWith("How")); System.out.println(s1.endsWith("you")); s = s1.substring(4); System.out.println(s); s = s1.substring(4,7); System.out.println(s); s = s1.toLowerCase(); System.out.println(s); s= s1.toUpperCase(); System.out.println(s); String s2 = " How old are you!! " ; s = s2.trim(); System.out.println(s); System.out.println(s2); //??? } } |
字符串相等的判断
n equals方法用来检测两个字符串内容是否相等。如果字符串s和t内容相等，则s.equals(t)返回true,否则返回false.
n s和t既可以是字符串变量，也可以是字符串常数，例如： “Hello”.equals(t);
n 要测试两个字符串除了大小写区别外是否是相等的，需要使用equalsIgnoreCase方法，例如：
“Hello”.equalsIgnoreCase(“hellO”);//true
n 判断字符串是否相等不要使用“==”
| String g1="Hello World!"; String g2="Hello World!"; boolean b1=g1.equals(g2); System.out.println("\tg1.equals(g2) 是否相等：" + (b1 ? "相等" : "不相等") ); boolean b2=(g1==g2); System.out.println("\tg1==g2 是否相等：" + (b2 ? "相等" : "不相等") ); System.out.println("========================================="); String s1=new String("Hello World!"); String s2=new String("Hello World!"); boolean b3=s1.equals(s2); System.out.println("\ts1.equals(s2) 是否相等：" + (b3 ? "相等" : "不相等") ); boolean b4=(s1==s2); System.out.println("\ts1==s2 是否相等：" + (b4 ? "相等" : "不相等")); } } /** * g1.equals(g2) 是否相等：相等 * g1==g2 是否相等：相等 *====================================== * s1.equals(s2) 是否相等：相等 * s1==s2 是否相等：不相等 [雨林木风10] * * 问: 为什么会产生以上不同的结果，你能说明其原因吗？ * (或者 画内存变化图来说明) */ |
读取键盘录入数据：
简单的读取键盘输入的字符串示例：
Scanner scanner = new Scanner(System.in);
// String string = scanner.nextLine(); //将输入的一行付给string
// String string = scanner.next(); //将输入单词到第一个空白符[微软用户11] 为止的字符串付给string
int string = scanner.nextInt(); //将输入的数字付给变量
System.out.println(string);
格式化输出
参数索引从1开始计算。
宽度：如果宽度超出浮点数会发生截断小数部分。整数和字符串不会发生截断。
常见的标志:
1. +打印正数和负数
2. –左对齐
3. 0数字前补零
4. <引用前一个转换字符引用的值[雨林木风12]
常见转换字符（都是区分大小写的）：
1. f表示浮点数
2. s表示字符串
3. d表示十进制数
4. %百分号本身
5. n换行符
时间的格式化：
%tx, x可以有下表中的字符：
练习：
| import java.util.Date; public class TestStringFormat{ public static void main(String[] args){
//testFormatNum(); testFormatDate(); }
static void testFormat(String str){ System.out.println("外部传进来一个参数："+str+"，！！！！！！"); System.out.printf("外部传进来一个参数：%s，！！！！！！",str); }
static void testFormatNum(){ int i = 2344; double d = 234.234324; System.out.printf("小数是：%2$015.3f整数是：%1$3d, 百分号是%%, %n",i,d); System.out.printf("======="); }
static void testFormatString(){ System.out.printf("字符串：%s","aaa"); String newStr = String.format("字符串：%s","aaa"); System.out.println(newStr); }
static void testFormatDate(){ Date date = new Date(); System.out.printf("时间：%tc%n",date); //System.out.printf("时间：%tY-%1$tm-%1$td,",date); //2009-10-16, 20:43:33, 星期五 //System.out.printf("时间：%tY-%<tm-%<td,%<tH:%<tM:%<tS,%<tA,%<tp",date); //2009-10-16, 20:43:33, 星期五，下午 String str = String.format("时间：%tY-%<tm-%<td,%<tH:%<tM:%<tS,%<tA,%<tp",date);[t13] System.out.println(str); }
} |
[雨林木风1]这个可以任意写。不过一般都是这么写
[雨林木风2]驼峰写法
[雨林木风3]默认的整数类型是int型，要想使用长整型可在后面加“l”或“L”，如：1000L。（小写l容易被误认为1，不推荐用）
[雨林木风4]类似于字符数组的概念
[雨林木风5]\u0000
[雨林木风6]提升。各种基本数据类型进行混合运算，结果会是表达能力最强的那种。如：int和long运算，结果是long，整型和浮点型运算结果是浮点型。
特殊的一点是：只要类型比int小（如char、byte、short），那么在运算之前，这些值会自动地转换成int。例子：
byte b1 = 12;
byte b2 = b1 + 1; //在编译时出错了！因为b1+1已经是int型了！切记！z
[d7]&&不会抛异常；说明没有执行3/0；
[雨林木风8]经常用来代替简单的if-else判断！
[d9]使用三木运算符：
Boolean b = true;
Int a = (b)?1:0;
[雨林木风10]为什么?
[微软用户11]包含:换行符/制表符/空格
[雨林木风12]String.format("date: %tF %<tS:%<tM:%<tS", new Date());
[t13]把时间对象按照指定格式转换成字符串对象！