java基础

来源：互联网发布：淘宝信用值评论编辑：程序博客网时间：2024/05/19 17:05

第一个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

double

else

extends

final

finally

float

for

goto

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字节

-2¹⁵~ 2¹⁵-1 （-32768~32767）

int （integer）

4字节

-2³¹~ 2³¹-1 (-2147483648~2147483647) 约21亿

long

8字节

-2⁶³~ 2⁶³-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的数据不适合在不容许舍入误差的金融计算领域。
如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

注：

主要理由：由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。浮点数一般都存在舍入误差，很多数字无法精确表示(例如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值

退格（backspace）

\u0008

换行

\u000a

回车

\u000d

制表符（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 ) ，只有新手才那么写。
对于任何程序员 if ( whether && !done ) 都不难理解吧。所以去掉所有的==fasle 和 ==true。

固定的存储空间正是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);

运算符优先级的问题

R to L

. ( ) { } ; ,
++ -- ~ ! (data type)

L to R

* / %

L to R

+ -

L to R

<< >> >>>

L to R

< > <= >= instanceof

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]把时间对象按照指定格式转换成字符串对象！