黑马程序员：java语言基础组成，基础部分知识点

---------------------- android培训java培训、期待与您交流！ -----------

java语言基础组成

1.基础语言要素

(1)标识符：在程序中定义的一些名词。不如说类名、方法、变量起的名字

A．必须以字母或下划线或 $ 符号开始，其余字符可以是字母、数字、$ 符号和下划线。

B．只能包含两个特殊字符，即下划线 _ 和美元符号 $ 。

C．标识符不能包含空格。

D．区分大小写。

注意：main不是关键字，但是，被虚拟机识别。
起名时，为了提高阅读性，尽可能有意义。

java名称规范：

包名：多单词组成时所有字母小写。例如：xxxyyyzz

类名接口名：多单词组成时，所有单词的首字母大写。例如:XxxYyyZzz

变量名和函数名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写。例如:xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接。例如:XXX_YYY_ZZZ

规则：
1.数字不能开头。
2.不可以使用关键字。

(2)关键字：被java赋予特殊含义的单词。

    注意事项：
      true、false、null不是关键字！是字面量。

      main不是关键字！但是是一个特殊单词，可以被JVM识别，主函数是固定格式，作为程序的入口。

(3)注释：用于注解说明解释程序的文字就是注释。提高了代码的阅读性。

对于单行和多行注释，被注释的文字，不会被JVM（ java虚拟机）解释执行。

对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。

注意：注释是一个程序员必须要具有的良好编程习惯。初学者编写程序可以养成习惯：先写注释再写代码。
将自己的思想通过注释先整理出来，在用代码去体现。
因为代码仅仅是思想的一种体现形式而已。

单行注释：//       多行注释：/* ……*/         (java特有注释)文档注释：/**……*/

注意事项：开发中类前、属性前、方法前，必须有文档注视。

范例：

/**
这是我的Hello World程序。
@author 小强
*/
class Demo
{
/*
这是主函数，是程序的入口
它的出现可以保证程序的独立运行，
*/
public static void main(String[] args)
{
//这是输出语句用于将括号内的数据打印到控制台。
System.out.println("Hello World");
}
}

(4)常量和变量

常量:固定不变的数值。

Java中常量的分类：
1，整数常量。所有整数
2，小数常量。所有小数
3，布尔型常量。较为特有，只有两个数值。true false。
4，字符常量。将一个数字字母或者符号用单引号( ' ' )标识。例子：'4'字符 '+' 'a'
5，字符串常量。将一个或者多个字符用双引号标识。例子："ab"
6，null常量。只有一个数值就是:null.

对于整数：java有三种表现形式。

十进制：0-9 ，满10进1.

八进制：0-7 ，满8进1. 用0开头表示。

十六进制：0-9，A-F，满16进1. 用0x开头表示。

(5)进制问题：

任何数据在计算机中都是以二进制形式存在。
二进制的由来是电信号开关演变而来。
三位可以取到的值是7，超过7就进位，这就是八进制。
四位可以取到的值是15，超过15就进位，这就是十六进制。

特点是：进制越大，表现形式越短。

实例：

System.out.println(60);
System.out.println(0x3c);//3c是60的16进制表现形式

打印结果都是：60

进制之间转换：

十进制-->二进制。
原理：对十进制数进行除2运算。
十进制数除2，取余数，得数继续除了2，直到为0。余数先取的放低位，后取的放高位，依次排开。

实例：

System.out.println(Integer.toBinaryString(6));//十进制转二进制

负数的二进制表现形式：

比如：6 = 110
-6：是6的二进制 取反+1
6: 0000 0000 0000 0000 0000 0000 0000 0110
-6: 1111 1111 1111 1111 1111 1111 1111 1010

规律：负数的最高位为1，正数的最高位为0。

变量：就是将不确定的数据进行存储。
也就是需要在内存中开辟空间（内存就是一个运算区域）。

值不确定的情况下，在内存开辟一个空间，把要运算的值或者要操作的值，存放到该空间中。空间里面的值可以任意变化，只要操作该空间，就能操作该空间的值。

如何开辟内存空间？

一片内存，搞了一个空间进来，空间定义完，把数据存放到该空间中，在该空间可以一直存变化的数据。
空间要使用，需要有一个名字，也就是变量名。明确空间的类型（数据类型），只能存一种类型的数据。

Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配了不同大小的内存空间

总结：就是通过明确数据类型，变量名称，数据来完成。三个关键：数据类型,变量名称,数据。

(6)数据类型

分为：基本数据类型 和 引用数据类型。

基本数据类型：分为 数值型、字符型(char)、布尔型(boolean)。

数值型：分为 整数类型(byte, short, int, long) 浮点类型(float, double)。

引用数据类型:类class，接口interface，数组[]

1）四种整数类型(byte、short、int、long)：

byte：8位，用于表示最小数据单位，如文件中数据，-128~127

short：16位，很少用，-32768 ~ 32767(3万多)

int：32位、最常用，-2^31-1~2^31 （21亿）

long：64位、次常用

比喻：byte一两的碗，short二两的碗，int四两的碗，long八两的碗。一两为8位。

为什么这么划分？

为了节约内存，cpu里内存称为缓存，缓冲数据。

2）两种浮点数类型(float、double)：

       单精度float：32位，后缀F或f，1位符号位，8位指数，23位有效尾数。

       双精度double：64位，最常用，后缀D或d，1位符号位，11位指数，52位有效尾数。

       注意事项：
默认为高精度的double


        二进制浮点数：1010100010=101010001.0*2=10101000.10*2^10(2次方)=1010100.010*2^11(3次方)= . 1010100010*2^1010(10次方)


       尾数： . 1010100010  指数：1010  基数：2


       浮点数字面量默认都为double类型，所以在定义的float型数据后面加F或f；double类型可不写后缀，但在小数计算中一定要写D或X.X。

        float 的精度没有long高，有效位数（尾数）短。

        float 的范围大于long 指数可以很大。

      浮点数是不精确的，不能对浮点数进行精确比较。

3）一种字符类型(char)：

char：16位，是整数类型，用单引号括起来的1个字符（可以是一个中文字符），使用Unicode码代表字符，0~2^16-1（65535）。

     注意事项：

      不能为0个字符。

    转义字符：\n 换行 \r 回车 \t Tab字符 \" 双引号 \\ 表示一个\

       两字符char中间用“+”连接，内部先把字符转成int类型，再进行加法运算，char本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。

4）一种布尔类型(boolean)：true真 和false假。

5）类型转换：          char-->

自动转换：byte-->short-->int-->long-->float-->double                 


              强制转换：①会损失精度，产生误差，小数点以后的数字全部舍弃。


 ②容易超过取值范围。

定义变量的格式：

数据类型 变量名 = 初始化值;

实例：

//定义一个int类型变量.取值为4；
int x = 4;

x = 10;//变量块可以被重用

//演示其他数据类型。

byte b = 2;//-128~127;

byte b1 = 128;//错误，可能损失精度。

short s = 30000;//定义short型

long l = 4l;//定义long型

float f = 2.3f;//定义float型

double d = 34.56;//定义double型

char ch = '4';//定义char型
char ch1 = 'a';
char ch2 = '+';
char ch3 = ' ';

boolean bo = true;//定义boolean型
boolean bo1 = false;

什么时候定义变量？

当数据不确定的时候。需要对数据进行存储时。
就定义一个变量来完成存储动作。

类型转换问题：

byte b = 3;//正确，因为会自动判断，3是否在b的范围内。

b = b + 2;

System.out.println(b);

错误，java强类型导致。2为默认的int型，b + 2，结果被自动类型提升为int。

自动类型转换（也叫隐式类型转换）

自动类型提升，原则是以大的为主，小的向大的提升。
b是一两的碗，2是四两的碗。加运算 b自动类型提升为四两的碗。
四两的碗赋给一两的碗，损失精度。

b = (byte)(b + 2);//强制类型转换，如果是负数，砍掉部分，可能会丢失精度。

强制类型转换（也叫显式类型转换）

什么时候使用强制类型转换？
如果3.14只想保留整数部分3，就强制转换成int。

表达式的数据类型自动提升

所有的byte型、short型和char的值将被提升到int型。

如果一个操作数是long型，计算结果就是long型；

如果一个操作数是float型，计算结果就是float型；

如果一个操作数是double型，计算结果就是double型。

自动转换：byte-->short-->int-->long-->float-->double             

强制转换：①会损失精度，产生误差，小数点以后的数字全部舍弃。

实例:

System.out.println('a'+1);//char 16位，1 int 32位。char被自动提升为int。

//结果是:98

System.out.println((char)('a'+1));//强制转换为char

//结果是:b

(7)运算符

算术运算符

取余  %     例子：-1%5=-1     1%-5=1        取决于运算符左侧数字

字符串连接符：+     system .out.println（“a=”+a）；     结果为    a=a

实例：
//字符串数据和任何数据使用+都是相连接，最终都会变成字符串。
System.out.println("5+5"+(5+5));
结果是：5+5=10
两字符char中间用“+”连接，内部先把字符转成int类型，再进行加法运算，char本质就是个数！二进制的，显示的时候，经过“处理”显示为字符。

System.out.println("5+5"+5+5);
结果是：5+5=55

转义字符

转义字符：通过\ 来转变后面字母或者符号的含义。

\n:换行。

\b:退格。相当于backspace。

\r:按下回车键。window系统，回车符是由两个字符来表示\r\n.

\t:制表符。相当于tab键。

实例：

System.out.println("\"hello\"");

//结果："hello"

System.out.println("\\hello\\");

//结果：\hello\

注意：char里面可以装字母 也可以装 一个中文(两个字节)

赋值运算符

=赋值

+=加等  

-=减等   

/=除等

*=乘等

实例：

x+=4;//左右两边的和 赋给 左边 相当于 x = x+4;

s = s +5;//两次运算，先做+，再赋值，有一个自动类型提升的过程

s+=5;//就是一次运算，只做了一次赋值运算，内部有一个自动转化动作。

(8)位运算符(运算效率最高，但是，以二的倍数增长)

位：二进制
是二进制用来计算的运算符


1)
>> 右移 ,空位补0，被移除的高位丢弃，空缺位补0。例子：3>>1  011>>1  结果是001  
规律：右移一位，相当于 除以2的一次方。


<< 左移
规律：左移一位，相当于 乘以2的一次方。


&和&&的特点：
&:无论左边是true是false。右边都运算。
&&:当左边为false时，右边不运算。




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


^:异或。任何相同二进制位进行^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位^ 运算结果是1。1^0=1 , 0^1=1

(10)程序流程控制

java中的语句，想要表达一些复杂的东西，用到的语句。

1)判断结构

if语句：if 、if-else、if-else-if：可以处理一切分支判断。

格式：if(判断){…}、if(判断){…}else{…}、if(判断){…}else if(判断){…}

实例：

int x = 1;

if(x>1)
{
	System.out.println("yes");
}
else
{
	System.out.println("a");
}

三元运算符：

好处：可以简化if else代码。

弊端：因为是一个运算符，所以运算完必须要有一个结果。

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

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

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

总结：三元运算符可以看做if...else的简化。if else 结构 简写格式： 变量 = (条件表达式)?表达式1：表达式2；

实例：

int a = 9,b;
b = (a>1)?100:200;

2)选择结构

switch语句：switch(必须为int类型){case 常量1：…; case 常量2：… ; ….}


四个关键字：switch case break default


注意事项：


int类型指：byte、short、int，不能写long类型，要写也必须强转成int类型；而byte、short为自动转换成int。


swtich-case：若case中无符合的数，并且default写在最前（无break时），          则为顺序执行，有break或 } 则退出。


swtich-case：若case中无符合的数，并且default写在最后，则执行default。


swtich-case：若case中有符合的数，并且default写在最后，并且default前面的case没有break时，default也会执行。


实例：

int x = 3;

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

3)循环控制语句

①for：最常用，用在与次数有关的循环处理，甚至只用for可以解决任何循环问题。


注意事项：for中定义的用于控制次数的循环变量，只在for中有效，for结束则循环变量被释放（回收）。


for(1初始化表达式；2循环条件表达式；3循环后的操作表达式)
{
4执行语句；
}
执行顺序：1-2-4-3-2-4-3-2....一直到2不满足条件结束循环。
总结：顺序为，先初始化表达式，判断循环条件表达式，执行语句，之后循环后的操作表达式。再对循环条件表达式进行再判断，满足条件
执行语句，不满足结束循环。


1,变量有自己的作用域。对于for来讲：如果将用于控制循环的增量定义在for语句中。那么该变量只在for语句内有效。
for语句执行完毕。该变量在内存中被释放。


2，for和while可以进行互换。如果需要定义循环增量。用for更为合适。

总结：
什么时候使用循环结构？
当要对某些语句执行很多次时，就使用循环结构。


②while：很常用，用在循环时候要先检查循环条件再处理循环体，用在与次数无关的情况。如果不能明确结束条件的时候，先使用while(true)，在适当条件使用if语句加break结束循环。


定义初始化表达式；
while(条件表达式)
{
循环体(执行语句);
}


③do-while：在循环最后判断是否结束的循环。如：使用while(true) 实现循环的时候，结束条件break在while循环体的最后，就可以使用 do-while 。do-while 的结束条件经常是“否定逻辑条件”，不便于思考业务逻辑，使用的时候需要注意。可以利用while（true）+ break 替换。


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




④循环三要素：A．循环变量初值 B．循环条件  C．循环变量增量（是循环趋于结束的表达式）


⑤for和while循环体中仅一条语句，也要补全{ }，当有多条语句，且不写{ }时，它们只执行紧跟着的第一条语句。


⑥循环的替换：


 while(布尔表达式){} 等价 for(;布尔表达式;){}


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


 while(true){} + break 替换 do{}while(布尔表达式);


 for(;;) + break 替换 do{}while(布尔表达式);


实例：

int x = 1;
while(x<3)
{
	System.out.println("x="+x);
	x++;
}
int x = 1;
do
{
	System.out.println("do : x="+x);
	x++;
}
while (x<3);


for(int x = 0; x<3 ; x++)
{
	System.out.println("x="+x);
}