Java语言基础组成
Java语言基础由关键字、标识符、注释、常量和变量、运算符、语句、函数和数组等组成。
关键字
标识符
Java中的名称规范
包名：多单词组成所有字母都小写。 例如：xxxyyyzzz
类名接口名：多单词组成时，所有单词首字母大写。例如：XxxYyyZzz
变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。 例如：xxxYyyZzz
常量名：所有字母都大写。多单词时每个单词用下划线链接。例如:XXX_YYY_ZZZ
注释
单行注释
//注释文字/*注释文字*//**注释文字*/常量表示不能改变的数值。
Java中常量的分类
1.整数常量：所有整数。
2.小数常量：所有小数。
3.布尔(boolean)型常量：只有两个数值，true、false。
4.字符常量：将一个数字字母或者符号用单引号('')标识，如：'a'。
5.字符串常量：将一个或者多个字符用双引号("")标识，如："helloworld"、"a"、""（空字符串）。
6.null常量：只有一个数值就是：null。
进制的由来
对于整数，有四种表现形式：
二进制：0-1，满2进1。
八进制：0-7，满8进1，用0开头表示，如：012。
十进制：0-9，满10进1。
十六进制：0-9，A-F，满16进1，用0x开头表示。如：0x4A2C。
进制的基本转换
1.十进制转二进制。
原理：对十进制数进行除2运算。
示例：求十进制数6的二进制数。
6/2=3余0
3/2=1余1
1/2=0余1
故，6（十进制）=110（二进制）。
2.二进制转十进制。
原理：二进制乘以2的过程。
示例：求二进制数110的十进制数。
110=0*2（0）+1*2（1）+1*2（2）=0+2+4=6
附：括号中的数值代表次方。
示例：求二进制数00110101的十进制数。
0 0 1 1 0 1 0 1
128 64 32 16 8 4 2 1
-----------------------------------
=32*1+16*1+4*1+1*1=53
示例：二进制加法，5+4=9。
101
+100
------------
1001
3.十进制转八进制。
原理：八进制，其实就是二进制位，3个二进制位，1个八进制位。
示例：求十进制数43的八进制数。
十进制43
二进制101011
三位分割000-101-011
八进制053
因此，43（十进制）=101011（二进制）=053（八进制）。
4.十进制转十六进制。
原理：十六进制，其实就是二进制位，4个二进制位，1个十六进制位。
示例：求十进制数43的十六进制数。
十进制43
二进制101011
四位分割0010-1011
十六进制2(2)11(B)
因此，43（十进制）=101011（二进制）=0x2B（十六进制）
5. 负数的进制
原理：负数的二进制表现形式就是对应的正数二进制取反加1。
示例：求-6的二进制表现形式，其实就是对应的正数6的二进制取反加1。
6
0000-0110
取反1111- 1001
加1+0000-0001
-------------------
1111-1010
变量
定义：内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），该区域的数据
可以在同一类型范围内不断变化。 如：byte b = 3;
Java语言的数据类型
Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间
byte 1个字节
short 2个字节
int 4个字节
long 8个字节
float 4个字节
double 8个字节
char 2个字节
Java语言的数据类型包括8种基本类型，3种引用类型。
类型转换
1.自动类型转换（隐式类型转换）
class TestDemo
{
public static void main(String[] args)
{
int x = 2;
byte b = 3;
x = x+b;/*注意：int类型的变量占4个字节，当byte类型的变量与其相加的时候，首先会将byte类型的变量自动转化为4个字节的int类型，
然后再进行加法操作。*/
System.out.println(x);
}
}定义：强制类型转换需要把类型进行手动转换，否则无法正常使用
byte b =3; b = (byte)15+b; 进行强制类型转换，也就是将占4个字节的int类型值，再强硬存储到占1个字节的byte变量中。
运算符
1.算数运算符
2.赋值运算符
符号：=,+=,-=,*=,/=,%=
如 int a = 1;int b =3 ;
+= ： a+=b;//相当于a=a+b;
-=: a-=b;相当于 a=a-b;
3.比较运算符
4.逻辑运算符
"&"符号的运算特点：
| A | B | A&B |
| false | false | false |
| true | false | false |
| false | true | false |
| true | true | true |
"&"符号运算规律：
运算的两边只要有一个是false，结果肯定是false。
只有两边都为true，结果才是true。
"|"符号的运算特点：
| A | B | A|B |
| false | false | false |
| true | false | true |
| false | true | true |
| true | true | true |
"|"符号运算规律：
运算的两边只要有一个是true，结果肯定是true。
只有两边都为false，结果是false。
"^"符号的运算特点：
| A | B | A^B |
| false | false | false |
| true | false | true |
| false | true | true |
| true | true | false |
"^"符号运算规律：
^符号的两边结果如果相同，结果是false。
两边的结果不同，结果是true。
"！"符号运算规律：
| A | !A |
| true | false |
| false | true |
&&：和&运算的结果是一样的，但是运算过程有点小区别。
&：无论左边的运算结果是什么，右边都参与运算。
&&：当左边为false时，右边不参加运算，这样可以提升效率。
||：和|运算的结果是一样的，但是运算过程有点小区别。
|：无论左边的运算结果是什么，右边都参与运算。
||：当左边为true时，右边不参加运算，这样可以提升效率。
使用&&和||比使用&和|更高效一些。
5.位运算符
与运算例子：
6&3=2
110
&011
-------
010
用“与运算”可以很方便提取某一二进制数的其中几位数。
例如：取17476二进制数的后四位。
0100010001000100
&0000000000001111
----------------------------
0000000000000100
或运算例子：
6|3=7
110
| 011
--------
111
异或运算例子：
6^3=5
110
^011
-------
101
一个数异或同一个数两次，结果还是这个数。
例子：
6^3^3=6
6^3=5
110
^011
-------
101
^011
-------
110
技巧：
利用异或运算可以实现对数据简单地进行加密，例如对一幅图片的所有数据异或3进行加密，那么这幅图片就
无法查看了。解密只需要再对图片的数据执行异或3操作即可。
取反运算
~ ‘非’ 运算符是将目标数的进制去反，即0变成1 ，1变成0
2的二进制码为 00000010 ， 它取反为11111101 ，可见取反后结果为负数（二进制负数转换为十进制的步骤为：将二进制去反，然后+1）
将 11111101 转换为10进制 ，第一步去反 得到 00000010 然后 加1 得到 00000011 ，得到的结果为3 ，然后在前面加上负号就可以了
所以结果为-3 //System.out.println(~2); //-3
左移运算例子：
3<<2=12相当于3*2（2）=12
00000000000000000000000000000011
00000000000000000000000000001100
3<<3=24相当于3*2（3）=24
00000000000000000000000000000011
00000000000000000000000000011000
总结：
左移几位其实就是该数据乘以2的几次方。
<<：可以完成2的次幂运算。
右移运算例子：
6>>1=3相当于6/2（1）=3
00000000000000000000000000000110
00000000000000000000000000000011
6>>2=1相当于6/2（2）=1
00000000000000000000000000000110
00000000000000000000000000000001
总结：
右移几位其实就是该数据除以2的几次幂。
P.S.
>>：对于高位出现的空位，原来高位是什么，就用什么补这个空位。
>>>：无符号右移，数据进行右移时，高位出现的空位，无论原高位是什么，空位都用0补。
例子：最有效率的方式算出2乘以8等于几？
class OperatorDemo
{
public static void main(String[] args)
{
System.out.println(2<<3);//2*2(3) 16
}
}格式：(条件表达式)?表达式1:表达式2；如 int x = 3,y; y = (x>1)?100:200; //100
程序流程控制
格式一：
if(条件表达式)
{
执行语句；
}
格式二：
if(条件表达式)
{
执行语句；
}
else
{
执行语句；
}
格式三：
if(条件表达式)
{
执行语句；
}
elseif(条件表达式)
{
执行语句；
}
……
else
{
执行语句；
}
选择结构
switch语句
格式：
switch(表达式)
{
case取值1:
执行语句；
break；
case取值2:
执行语句；
break；
…...
default:
执行语句；
break；
}
循环结构
while语句格式：
while(条件表达式)
{
执行语句；
}
dowhile语句格式：
do
{
执行语句；
}while(条件表达式);
while和dowhile的区别：
dowhile语句的特点：无论条件是否满足，循环体至少执行一次。
while如果条件不满足，循环体一次都不会执行。
for语句格式：
for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；(循环体)
}
for里面的三个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行
循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
for循环的初始化表达式、循环后的操作表达式可以是多个表达式，通过逗号分隔。
例如：
for(inta=1,b=2;a<2&b<3;a++,b++){
}
其他流程控制语句
break(跳出)，continue(继续)。
break语句：
应用范围：选择结构和循环结构。
标号的出现，可以让这两个语句作用于指定的范围。
class BreakDemo
{
public static void main(String[] args)
{
out:for(int x = 0; x < 3; x++)
{
in:for(int y = 0; y < 4; y++)
{
System.out.println("x = " + x);
break out ;//标记out后 会跳出最对应的标记的for循环 没标记会跳出当前循环
}
}
}
}函数就是定义在类中的具有特定功能的一段独立小程序，函数也称为方法。
函数的格式：
修饰符返回值类型函数名(参数类型形式参数1，参数类型形式参数2，...)
{
执行语句;
return返回值;
}
返回值类型：函数运行后的结果的数据类型。
参数类型：是形式参数的数据类型。
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数：传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函数运算后的结果，该结果会返回给调用者。
函数的特点
1、定义函数可以将功能代码进行封装。
2、便于对该功能进行复用。
3、函数只有被调用才会被执行。
4、函数的出现提高了代码的复用性。
P.S.
1、对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后
一行可以省略不写，或者写上return;。
函数的应用
两个明确：
明确要定义的功能最后的结果是什么？
明确在定义该功能的过程中，是否需要未知内容参与运算。
例如：
/**
需求：两个数是否相等。
明确一：这个功能的结果是什么？有，boolean类型。
明确二：这个功能实现过程中是否需要未知内容参与运算？有，两个整数。
*/
public static boolean equals(int a,int b)
{
return a == b;
}重载的概念：
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
重载的好处：
方便于阅读，优化了程序设计。
数组
概念：
同一种类型数据的集合。其实，数组就是一个容器。
数组的好处：
可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式1：
元素类型[]数组名=new元素类型[元素个数或数组长度];
格式2：
需要一个容器，存储已知的具体数据。
元素类型[]数组名=new元素类型[]{元素，元素，……};
数组的内存分配及特点
Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每
一片区域都有特定的处理数据方式和内存管理方式。
内存的划分：
1.寄存器。
2.本地方法区。
3.方法区。
4.栈内存。
5.堆内存。
栈内存：
用于存储局部变量，当变量所属的作用域一旦结束，所占空间会自动释放。
堆内存：
数组和对象，通过new建立的实例都存放在堆内存中。
每一个实体都有内存地址值。
实体中的变量都有默认初始化值，根据类型的不同而不同。整数类型是0，小数类型是0.0或0.0f，boolean类
型是false，char类型是'\u0000'。
如果将数组的引用实体设置为null，也就是实体不再被使用，那么会在不确定的时间内被垃圾回收器回收。
数组操作常见问题
数组脚标越界异常(ArrayIndexOutOfBoundsException)：访问到了数组中的不存在的脚标时发生。
空指针异常(NullPointerException)：当引用型变量没有指向任何实体时，用其操作实体，就会发生该异常。
数组操作常见操作
对数组操作最基本的动作就是存和取。
下面遍历并打印数组元素
class ArrayDemo
{
public static void main(String[] args)
{
int[] arr = {132,45,56,56,45};
for(int x=0;x<arr.length;x++)
{
System.out.println("arr["+x+"]"+arr[x]);
}
}
}
扫一扫
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
