java语言基础

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);
	}
}

2.强制转换（显式类型转换）

     定义：强制类型转换需要把类型进行手动转换，否则无法正常使用

     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]);
		}
	}
}