Java语言基础组成

关键字

定义：被Java语言赋予了特殊含义的单词。
特点：关键字中所有字母都为小写。

用于定义数据类型的关键字
class	interface	byte	short	int
long	float	double	char	boolean
void
用于定义数据类型值的关键字
true	false	null
用于定义流程控制的关键字
if	else	switch	case	default
while	do	for	break	continue
return
用于定义访问权限修饰符的关键字
private	protected	public
用于定义类，函数，变量修饰符的关键字
abstract	final	static	synchronized
用于定义类与类之间关系的关键字
extends	implements
用于定义建立实例及引用实例，判断实例的关键字
new	this	super	instanceof
用于异常处理的关键字
try	catch	finally	throw	throws
用于包的关键字
package
其他修饰符关键字
native	strictfp	transient	volatile	assert

标识符

在程序中自定义的一些名称。
由26个英文字母大小写，数字： 0-9，符号： _、$ 组成。
定义合法标识符规则：
1. 数字不可以开头。
2. 不可以使用关键字。
java中严格区分大小写。

注意：在起名字的时候，为了提高阅读性，要尽量有意义。

Java中的名称规范：

包名：多单词组成时所有字母都小写。例，xxxyyyzzz。
类名、接口名：多单词组成时，所有单词的首字母大写。例，XxxYyyZzz。
变量名和函数名：多单词组成时，第一个单词首字母小写，第二
个单词开始每个单词首字母大写。例，xxxYyyZzz。
常量名：所有字母都大写。多单词时每个单词用下划线连接。例，XXX_YYY_ZZZ。

注释

用于注解说明解释程序的文字就是注释。注释提高了代码的阅读性。
java中的注释格式：

单行注释，格式：//注释文字
多行注释，格式：/* 注释文字 */
文档注释，格式：/** 注释文字 */

对于单行和多行注释，被注释的文字，不会被JVM（java虚拟机）解释执行。
对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
注释是一个程序员必须要具有的良好编程习惯。
初学者编写程序可以养成习惯：先写注释再写代码。将自己的思想通过注释先整理出来，在用代码去体现，因为代码仅仅是思想的一种体现形式而已。
例，

/**
这个类是用于演示hello world.
作者：李阿昀
版本：V1.0
*/
class Demo {/*main函数可以保证该类的独立运行它是程序的入口它会被JVM所调用*/public static void main(String[] args) {//这是输出语句用于将括号内的数据打印到控制台。System.out.println("hello java");System.out.println("hello world");}
}

变量与常量

常量表示不能改变的数值。Java中常量的分类：

整数常量。所有整数
小数常量。所有小数
布尔型常量。较为特殊，只有两个数值：true、false
字符常量。将一个数字、字母或者符号用单引号( ' ' )标识
字符串常量。将一个或者多个字符用双引号标识
null常量。只有一个数值就是：null

对于整数，java有四种表现形式：

十进制：0-9，满10进1
八进制：0-7，满8进1，用0开头表示
十六进制：0-9、A-F，满16进1，用0x或0X开头表示
二进制：0、1，满2进1

注意：

负数在计算机内存中的二进制表现形式：对应的正数二进制取反加1。
(在计算机内存中的二进制表现的)负数转换成十进制数：对应的负数二进制减1取反，转成十进制数，最后前面加一个-。

变量的概念：

内存中的一个存储区域
该区域有自己的名称（变量名）和类型（数据类型）
该区域的数据可以在同一类型范围内不断变化

为什么要定义变量？
用来不断的存放同一类型的常量，并可以重复使用。(即当数据不确定时，需要对数据进行存储时，就定义一个变量来完成存储动作。)
定义变量的格式：数据类型变量名 = 初始化值;。注：格式是固定的，记住格式，以不变应万变。
理解：变量就如同数学中的未知数。
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。如图：

Java基本数据类型

数据类型	说明	所占内存	举例	备注
byte	字节型	1 byte	3, 127
short	短整型	2 bytes	3, 32767
int	整型	4 bytes	3, 21474836
long	长整型	8 bytes	3L, 92233720368L	long最后要有一个L字母(大小写无所谓)
float	单精度浮点型	4 bytes	1.2F, 223.56F	float最后要有一个F字母(大小写无所谓)
double	双精度浮点型	8 bytes	1.2, 1.2D, 223.56, 223.56D	double最后最好要有一个D字母(大小写无所谓)
char	字符型	2 bytes	‘a’, ‘A’	字符型数据只能是一个字符，由单引号包围
boolean	布尔型	1 bit	true, false

注意：整数默认为int，小数默认为double。
在Java中可以通过Integer.SIZE这样的方法直接查看基本类型所占内存空间的大小。通过以下程序就能够查看了：

class JavaType {public static void main(String[] args) {System.out.println("Byte: " + Byte.SIZE);System.out.println("Short: " + Short.SIZE);System.out.println("Integer: " + Integer.SIZE);System.out.println("Long: " + Long.SIZE);System.out.println("Float: " + Float.SIZE);System.out.println("Double: " + Double.SIZE);System.out.println("Character: " + Character.SIZE);}
}

输出结果为：(单位是bit)

Byte: 8(一个字节)
Short: 16(二个字节)
Integer: 32(四个字节)
Long: 64(八个字节)
Float: 32(四个字节)
Double: 64(八个字节)
Character: 16(二个字节)

Boolean类型有点奇怪，官方文档是这么说的：

This data type represents one bit of information, but its “size” isn’t something that’s precisely defined.

中文翻译：这种数据类型保存一位的信息，但是它的大小却不是精确定义的。
例，Java基本数据类型举例：

int x = 4;
byte b = 2; //2是一个int常量，但是会自动判断2是不是在byte类型的范围内（-128~127），=运算符在给b赋值时，自动完成了强转操作
byte b1 = 128; //编译未通过，超出byte类型的范围
short s = 30000;
long l = 4l;float f = 2.3f;
double d = 34.56;char ch = '4';
char ch1 = 'a';
char ch2 = '+';
char ch3 = ' ';
char ch4 = '昀'; //一个中文在内存中占2个字节，而char就是2个字节空间大小boolean bo = true;
boolean bo1 = false;

自动类型转换(也叫隐式类型转换)和强制类型转换(也叫显式类型转换)。
表达式的数据类型自动提升：

所有的byte型、 short型和char型的值将被提升到int型
如果一个操作数是long型/float型/double型，计算结果就是long型/float型/double型

试分析System.out.println('a')与System.out.println('a'+1)的区别。

System.out.println('a'); //a
System.out.println('a'+1); //98
System.out.println((char)('a'+1)); //bSystem.out.println('A'+0); //65
System.out.println('1'+0); //49

System.out.println((char)5);会输出♣的形状。

自动类型提升：

byte b = 3;
int x = 4;
x = x + b;//b会自动提升为int类型进行运算。

强制类型转换：

byte b = 3; // 3是一个int常量，但是会自动判断3是不是在byte类型的范围内（-128~127），=运算符在给b赋值时，自动完成了强转操作
b = b + 4;//报错
b = (byte)(b+4);//强制类型转换，强制将b+4的结果转换为byte类型，再赋值给b。

运算符

算术运算符的注意问题

如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。但被模数是负数就另当别论，如：-5%2=-1。面试的时候可能会考到。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只保留整数部分而舍弃小数部分。如：
```
int x = 4270;
x = x / 1000 * 1000;
System.out.println(x); // 4000
```
字符串数据和任何数据使用+都是相连接，最终都会变成字符串。如：
```
System.out.println("5+5="+5+5); //"5+5=55"
System.out.println("5+5="+(5+5)); // "5+5=10"
```

转义字符

转义字符：通过\来转变后面字母或者符号的含义。如：
\n：换行
\b：退格。相当于backspace键
\r：按下回车键。windos系统中，回车符是由两个字符来表示\r\n
\t：制表符。相当于tab键
例，

System.out.println("hello\tworld");
System.out.println("\"hello java\"");
System.out.println("\\hello java\\");char ch = '\'';

赋值运算符

例，

int a, b, c;
a = b = c = 5;

一个面试题：
思考如下代码中s = s + 2;与s += 2;的区别？

short s = 3;
s = s + 2;
s += 2;

解：

short s = 3;
s = s + 2; // 编译失败，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型
s += 2; // 编译通过，因为+=运算符在给s赋值时，自动完成了强转操作

比较运算符

注意：

比较运算符的结果都是boolean型，也就是要么是true，要么是false。
比较运算符==不能误写成=

逻辑运算符

逻辑运算符用于连接boolean类型的表达式。
&——AND(与)

boolean类型的表达式	逻辑运算符	boolean类型的表达式	结果
true	&	true	true
true	&	false	false
false	&	true	false
false	&	false	false

特点：只要两边的布尔表达式结果有一个为false，那么结果就为false。只有两边都为true，结果为true。
|——OR(或)

boolean类型的表达式	逻辑运算符	boolean类型的表达式	结果
true	\|	true	true
true	\|	false	true
false	\|	true	true
false	\|	false	false

特点：两边只要有一个为true，结果为true，两边都为false，结果为false。
^——XOR(异或)，就是和|有点不一样，当true ^ true = false

boolean类型的表达式	逻辑运算符	boolean类型的表达式	结果
true	^	true	false
true	^	false	true
false	\|	true	true
false	^	false	false

特点：两边相同，结果是false；两边不同，结果为true。
!——Not(非)，即!true = false，!fasle = true。
注意：&和&&的区别以及|和||的区别

&：无论左边是true是false，右边都运算。
&&：当左边为false时，右边不运算。

|：两边都参与运算。
||：当左边为true时，右边不运算。

位运算符

位运算符	运算	范例
<<	左移	3 << 2 = 12 → 3 * 2 * 2 = 12
>>	右移	3 >> 1 = 1 → 3 / 2 = 1
>>>	无符号右移	3 >>> 1 = 1 → 3 / 2 = 1
&	与运算	6 & 3 = 2
\|	或运算	6
^	异或运算	6 ^ 3 = 5
~	反码	~6 = -7

位运算是直接对二进制进行运算。
注意：

<<：其实就是乘以2的移动的位数次幂。
>>：其实就是除以2的移动的位数次幂。

位运算符的细节

位运算符	细节
<<	空位补0，被移除的高位丢弃，空缺位补0
>>	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1
>>>	被移位二进制最高位无论是0或者是1，空缺位都用0补
&	二进制位进行&运算，只有1&1时结果是1，否则是0
\|	二进制位进行\|运算，只有0\|0时结果是0，否则是1
^	任何相同二进制位进行^运算，结果是0：1^1=0,0^0=0；不相同二进制位^运算结果是1：1^0=1,0^1=1

例，

    7 ^ 4111^ 100 (加密)------
    011^ 100 (解密)，密钥：100------
    111 = 7;  ----> 7 ^ 4 ^ 4 = 7;

结论：一个数异或同一个数两次，结果还是那个数。
练习：对两个整数变量的值进行互换(不需要第三方变量)。
解：
第一种方式：(使用第三方变量，实际开发时使用)

int n = 3, m = 8;
System.out.println("n = " + n + ", m = " + m);int temp;
temp = n;
n = m;
m = temp;System.out.println("n = " + n + ", m = " + m);

第二种方式：(不需要第三方变量)

int n = 3, m = 8;
System.out.println("n = " + n + ", m = " + m);n = n + m; // 如果n和m的值非常大，容易超出int范围
m = n - m;
n = n - m;System.out.println("n = " + n + ", m = " + m);

第三种方式：(不需要第三方变量，炫技型)

int n = 3, m = 8;
System.out.println("n = " + n + ", m = " + m);n = n ^ m;
m = n ^ m; // (n ^ m) ^ m = n;
n = n ^ m; // n ^ (n ^ m) = m;System.out.println("n = " + n + ", m = " + m);

三元运算符

格式：(条件表达式) ? 表达式1 : 表达式2

如果条件为true，运算后的结果是表达式1
如果条件为false，运算后的结果是表达式2

例，

int x = 2, y;
y = (x > 1) ? 'a' : 200;
System.out.println("y = " + y); // 97，自动类型提升

练习：取出三个数中的最大值(三元运算符的嵌套)。

int a = 2;
int b = 10;
int c = 3;
int max = a > b ? (a > c ? a : c) : (b > c ? b : c); // 取出三个数中的最大值(三元运算符的嵌套)
System.out.println("max = " + max);

程序流程控制

判断结构

if else结构简写格式：变量 = (条件表达式) ? 表达式1 : 表达式2;
三元运算符的特点：

好处：可以简化if else代码
弊端：因为是一个运算符，所以运算完必须要有一个结果。

if语句练习：
练习一：根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。
解：

class IfTest
{public static void main(String[] args) {/*需求：根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。思路：1，咋获取这个数值呢？来源有很多，不确定，只要是不确定的数据，都用变量存储。只要操作该变量即可。2，数值不确定，如何显示对应的星期呢？那就需要对该数值进行判断。3，咋显示呢？通过输出语句就可以显示在屏幕上。步骤：1，定义变量，记录数据。2，通过判断结构语句对该变量进行判断。3，根据不同的条件，通过输出语句显示不同的结果。*/// 1，定义变量，记录数据。int week = 9;// 2，通过判断结构语句对该变量进行判断。if (week == 1)// 3，根据不同的条件，通过输出语句显示不同的结果。System.out.println(week + "对应的是星期一");else if (week == 2)System.out.println(week + "对应的是星期二");else if (week == 3)System.out.println(week + "对应的是星期三");else if (week == 4)System.out.println(week + "对应的是星期四");else if (week == 5)System.out.println(week + "对应的是星期五");else if (week == 6)System.out.println(week + "对应的是星期六");else if (week == 7)System.out.println(week + "对应的是星期日");elseSystem.out.println(week + "没有对应的星期");}
}

练习二：根据用户的给定月份数据，显示该月份在哪个季节。
解：
第一种方式：

//需求：根据用户的给定月份数据，显示该月份在哪个季节。
// 3,4,5 春季  6,7,8 夏季  9,10,11 秋季  12,1,2 冬季
class IfTest {public static void main(String[] args) {int x = 4;if(x == 3 || x == 4 || x == 5) {System.out.println(x + "春季");} else if(x == 6 || x == 7 || x == 8) {System.out.println(x + "夏季");} else if(x == 9 || x == 10 || x == 11) {System.out.println(x + "秋季");} else if(x == 12 || x == 1 || x == 2) {System.out.println(x + "冬季");} else {System.out.println(x + "月份不存在");}}
}

第二种方式：

class IfTest {public static void main(String[] args) {int x = 4;if(x > 12 || x < 1) {System.out.println(x + "月份不存在");} else if(x >= 3 && x <= 5) {System.out.println(x + "春季");} else if(x >= 6 && x <= 8) {System.out.println(x + "夏季");} else if(x >= 9 && x <= 11) {System.out.println(x + "秋季");} else {System.out.println(x + "冬季");} }
}

选择结构

switch语句特点：

switch语句选择的类型只有四种：byte，short，int，char。但JDK7.0对switch语句进行了增强，可以判断字符串，JDK5.0对switch语句也进行了增强，可以对枚举类型进行判断。
case之间与default没有顺序。先执行第一个case，没有匹配的case执行default。
结束switch语句的两种情况：遇到break，执行到switch语句结束。
如果匹配的case或者default没有对应的break，那么程序会继续向下
执行，运行可以执行的语句，直到遇到break或者switch结尾结束(switch特性——case穿透性)。

例，

int x = 3;switch(x) { // byte,short,int,chardefault:System.out.println("d");case 4:System.out.println("a");case 6:System.out.println("b");break;case 2:System.out.println("c");break;
}

以上代码输出：

d
a
b

switch语句练习：
练习一：根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。
解：

class SwitchTest
{public static void main(String[] args) {// 需求1：根据用户的给定的数值，显示该数值对应的星期。如：2，星期二。int week = 9;switch (week){case 1:System.out.println(week + "对应的是星期一");break;case 2:System.out.println(week + "对应的是星期二");break;case 3:System.out.println(week + "对应的是星期三");break;case 4:System.out.println(week + "对应的是星期四");break;case 5:System.out.println(week + "对应的是星期五");break;case 6:System.out.println(week + "对应的是星期六");break;case 7:System.out.println(week + "对应的是星期日");break;default:System.out.println(week + "没有对应的星期");break;}}
}

练习二：根据用户的给定月份数据，显示该月份在哪个季节。

class SwitchTest {public static void main(String[] args) {int x = 4;switch(x) {case 3:case 4:case 5:System.out.println(x + "春季");break;case 6:case 7:case 8:System.out.println(x + "夏季");break;case 9:case 10:case 11:System.out.println(x + "秋季");break;case 12:case 1:case 2:System.out.println(x + "冬季");break;default:System.out.println("nono");}}
}

if和switch语句很像，具体什么场景下，应用哪个语句呢？
答：如果判断的具体数值不多，而且符合byte short int char这四种类型，虽然两个语句都可以使用，但建议使用switch语句，因为效率稍高。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。

循环结构

while：先判断条件，只有条件满足才执行循环体。
do while：先执行循环体，再判断条件，条件满足，再继续执行循环体。
简单一句话：do while无论条件是否满足，循环体至少执行一次。
for循环格式：

for(初始化表达式；循环条件表达式；循环后的操作表达式)
{执行语句；
}

例1，

class ForDemo {public static void main(String[] args) {for (int x = 0; x < 3; x++) {System.out.println("x = " + x);}//System.out.println("x ======= " + x);int y = 0;while (y < 3) {System.out.println("y = " + y);y++;}System.out.println("y ======= " + y);}
}

从以上代码中可得：

变量有自己的作用域，对于for来讲，如果将用于控制循环的增量定义在for语句中，那么该变量只在for语句内有效，for语句执行完毕，该变量在内存中被释放。而while循环使用的变量在循环结束后还可以继续使用。
for和while可以进行互换。如果需要定义循环增量，用for更为合适。

总结：
什么时候使用循环结构？
答：当要对某些语句执行很多次时，就使用循环结构。
例2，for循环还可以写成：

int x = 1;
for (System.out.println("a"); x < 3; System.out.println("c"), x++) {System.out.println("d");
}

输出结果为：

a
d
c
d
c

例3，

for (int y = 0; y < 3; y++) {}

以上代码可以写成如下代码：

int y = 0;
for ( ; y < 3; ) {y++;
}

例4，最简单无限循环格式：

for(;;) {}while(true) {}

无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。
练习一：获取1~10的和，并打印。
解：

class ForTest2 {public static void main(String[] args) {int sum = 0;for (int x = 1; x <= 10; x++) {sum += x;}System.out.println("sum = " + sum);}
}

其实这就是累加思想。原理：通过变量记录住每次变化的结果，并通过循环的形式，进行累加动作。
练习二：获取1~100之间7的倍数的个数，并打印。
解：

/*
获取1~100之间7的倍数的个数，并打印思路：
1.先对1~100进行循环(遍历)
2.在遍历的过程中，定义条件，只对7的倍数进行操作
3.因为7的倍数不确定，只要符合条件，就通过一个变量来记录这个变化的次数。步骤：
1.定义循环语句，选择for语句
2.在循环中定义判断，只要是7的倍数即可，使用if语句。条件：7的倍数 x % 7 == 0;
3.定义变量，该变量随着7的倍数的出现而自增
*/
class ForTest3 {public static void main(String[] args) {int count = 0;for (int x = 1; x <= 100; x++) {if(x % 7 == 0) {count++;}}System.out.println("count = " + count);}
}

其实这就是计数器思想，原理：通过一个变量记录住数据的状态变化，也需要通过循环完成。
for循环嵌套
例1，使用for循环打印如下所示的图形：
****
****
****
解：对于打印长方形，外循环控制行数，内循环控制每一行的列数，也就是一行中元素的个数。代码如下：

class ForForDemo {public static void main(String[] args) {for (int x = 0; x < 3; x++) {for (int y = 0; y < 4; y++) {System.out.print("*");}System.out.println(); }}
}

例2，使用for循环打印如下所示的图形：
*****
****
***
**
*
解：发现图形有很多行，每一个行有很多列，所以得使用嵌套循环。原理：形象说法，大圈套小圈。代码如下：

class ForForDemo {public static void main(String[] args) {for (int x = 0; x < 5; x++) { for (int y = x; y < 5; y++) {System.out.print("*");}System.out.println();}}
}

例3，使用for循环打印如下所示的图形：
*
**
***
****
*****
解：

class ForForDemo {public static void main(String[] args) {for (int x = 0; x < 5; x++) {for (int y = 0; y <= x; y++) {System.out.print("*");}System.out.println();}}
}

总结：不是规律的规律：

尖朝上，可以改变条件，让条件随着外循环变化
尖朝下，可以初始化值，让初始化值随着外循环变化

例4，使用for循环打印如下所示的图形：
1
12
123
1234
12345
解：

class ForForDemo {public static void main(String[] args) {for (int x = 0; x < 5; x++) {for (int y = 1; y <= x + 1; y++) {System.out.print(y);}System.out.println();}}
}

例5，打印一个99乘法表。
解：

class ForForDemo {public static void main(String[] args) {for (int x = 1; x <= 9; x++) {for (int y = 1; y <= x; y++) {System.out.print(y + "*" + x + "=" + (y*x) + "\t");}System.out.println();}}
}

例6，打印如下所示的图形：
□□□□*
□□□*□*
□□*□*□*
□*□*□*□*
*□*□*□*□*
注意：□表示空格。
解：

class ForForDemo {public static void main(String[] args) {for (int x = 0; x < 5; x++) {for (int y = x + 1; y < 5; y++) {System.out.print(" ");}for (int z = 0; z <= x; z++) {System.out.print("* ");}System.out.println();}}
}

其他流程控制语句

break(跳出)，应用于选择结构和循环结构。
例，

w:for (int x = 0; x < 3; x++) {for (int y = 0; y < 4; y++) {System.out.println("x = " + x); break w;}
}

可以给循环标号，然后通过break指定跳出哪个循环。
continue(继续)，只能作用于循环结构，继续循环。特点：结束本次循环，继续下一次循环。
例1，

for (int x = 1; x <= 10; x++) {if(x % 2 == 1) continue;System.out.println("x = " + x);
}

例2，也可以给循环标号，然后通过continue指定继续哪个循环。

w:for (int x = 0; x < 3; x++) {for (int y = 0; y < 4; y++) {System.out.println("x = " + x); continue w;}
}

记住：

break和continue语句作用的范围
break和continue单独存在时，下面不可以有任何语句，因为都执行不到

Java语言基础(一)相关推荐

java语言中声明布尔型_【Java初探02】——Java语言基础
本篇博文就Java语言的一些基本元素进行一些记录和阐述,主要讲解一下Java语言的一些基本构成元素和Java的主类结构. Java语言基础的大致组成 java主类结构基本的数据类型变量与常量运算 ...
[JAVA_开课吧资源]第一周 Java语言概述、Java语言基础
主题一 Java语言概述 » JDK介绍及其基本组件 Sun公司利用Java开发工具箱(Java Development Toolkit ,JDK)发布Java的各个版本.JDK由开发和测试Java程 ...
Java语言基础(数组)
Java语言基础(数组概述和定义格式说明) A:为什么要有数组(容器) 为了存储同种数据类型的多个值 B:数组概念数组是存储同一种数据类型多个元素的集合.也可以看成是一个容器. 数组既可以存储基本数 ...
“面试不败计划”： java语言基础面试题（三）
点击上方"好好学java",选择"置顶公众号" 优秀学习资源.干货第一时间送达! 好好学java java知识分享/学习资源免费分享关注精彩内容 java实 ...
计算机java语言教程,计算机JAVA教程二讲Java语言基础知识.doc
计算机JAVA教程二讲Java语言基础知识 2．1简单数据类型 2．1．1 标识符和保留字 1．标识符程序员对程序中的各个元素加以命名时使用的命名记号称为标识符(identifier).Java语言 ...
java基础1之java语言基础1
一.常量的概述和使用 A:什么是常量 * 在程序执行的过程中其值不可以发生改变 B:Java中常量的分类 * 字面值常量 * 自定义常量(面向对象部分讲) C:字面值常量的分类 * 字符串常量用双引 ...
java单引号转义_Java基础入门——Java语言基础（上）
本篇我们开始进入Java的学习,首先在学习如何编写Java语言前要先了解Java程序的基本结构. 一.Java程序的基本结构一个Java程序的基本结构大体可以分为包.类.main()主方法.标识符. ...
java语言基础02
一.Java语言基础(常量的概述和使用)(掌握) 1:什么是常量就是在程序的执行过程中其值不发生改变的量. 2:Java中常量的分类 (1):字面值常量 (2):自定义常量(面向对象部分讲解) 3: ...
java语言定义一个具备栈功能的类_Java学习笔记第二章 Java语言基础
第二章 JAVA语言基础一.关键字 1.关键字的定义和特点定义:被Java语言赋予了特殊含义的单词特点:关键字中所有的字母都为小写 2.用于定义数据类型的关键字 c;ass interface ...
Java语言基础（常见对象3（数组排序（冒泡排序、选择排序、直接插入排序、快速排序、归并排序）、Arrays、基本数据类型包装类、Integer类、自动拆箱、自动装箱））
Java语言基础常见对象数组排序冒泡排序相邻元素两两比较,大的往后放,第一次完毕,最大值的元素就会出现在最大索引处:以此循环 //冒泡排序:public static void main(St ...

Java语言基础(一)