Java编程基础第二天

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

 
(一)标识符
  Java语言的基础组成：关键字，标识符，注释，常量和变量，运算符，语句，函数，数组。
  1：关键字就是被赋予了特殊含义的单词。
 :2：标识符是程序中自定义的一些名称，比如类名。标识符由26个字母的大小写，0到9十个数字，$和_两个符号组成，标识符的书写规则包括： 不能用数字开头，不能用关键字。需要注意书写时区分大小写，另外尽量定义有意义的标识符。
--------------------------------------------------------------------------------------------------
  java中名称书写规范：
  1：包名：所有字母小写。
  2：类名和接口名：所有单词首字母大写。
  3：变量名和函数名：第一个单词首字母小写，其他单词首字母大写。
  4：常量名：所有字母大写:，多单词之间用下划线连接。
注意：除了常量名多单词间用下划线，其他名称多单词连写。
 
(二)常量
  常量表示不能改变的数值。常量的分类：
1.整数常量：所有整数
2.小数常量：所有小数
3.布尔型常量：true和false
4.字符常量：将 一个数字，字母，符号用单引号标识。 不能有空字符，就是不能有''。
5.字符串常量：将 一个或多个字符用双引号标识。 可以有空字符串，就是可以有""。
6.null常量：null
注意：空格也算一个字符。在使用println()时，括号里面可以什么都不写，就是单纯的空格，也可以是空格和数字。
--------------------------------------------------------------------------------------------------
  java中整数的几种表现形式：
1.二进制：只有0和1，计算机里面的数据全是二进制。
2.十进制：0到9，满十进一。
3.八进制：0到7，满八进一。用0开头。 三位二进制代表一位。八进制的表现形式就是0后面的那两个数字。
4.十六进制：0到9，A到F，满十六进一。用0x开头。 四位二进制代表一位。十六进制的表现形式就是0x后面的那两个字母或数字。


(三)进制的特点
  任何数据在计算机中都是以二进制形式存在，二进制早期是由电信号开关演变而来。八位二进制数代表一个字节。在计算机内存或者硬盘中存放的都是二进制数据。进制越大，表现形式越短。

(四)进制转换(十进制和二进制)
  十进制转二进制的计算举例：求13的二进制，原理是对十进制数进行除二运算。
13/2=6余1
6/2＝3余0
3/2＝1余1
然后把最后的计算结果1和余数按照从下往上的顺序写就是1101。
--------------------------------------------------------------------------------------------------
  二进制转十进制计算举例：
10001111，从最后一位开始乘以2的0次方，然后把所有结果相加。
第0位1×2的0次方＝1
第1位1×2的1次方＝2
第2位1×2的2次方＝4
第3位1×2的3次方＝8
第4位0×2的4次方＝0
第5位0×2的5次方＝0
第6位0×2的6次方＝0
第7位0×2的7次方＝128
1+2+4+8+0+0+0+128=143
--------------------------------------------------------------------------------------------------
  为了方便计算，以下是从右向左依次列出2的0次方到2的8次方：
  7       6      5      4      3      2      1      0
128    64    32    16    8     4       2      1
--------------------------------------------------------------------------------------------------
  在计算机中任何运算都是先把数据转换成二进制进行计算再转换成原数据表现形式，比如计算5+4
    101
  +100
————
   1001
1001的十进制就是9。
--------------------------------------------------------------------------------------------------
假如一个八位二进制全是1，那么对应的十进制数是255，也就是说一个字节表示的最大整数是255。IP地址最大值也是255。

(五)进制转换(八进制和十六进制)
  十进制转十六进制和八进制计算方式：
先将十进制数转换为二进制，然后分成四位一组或者三位一组，从右向左开始计算四位二进制或者三位二进制的十进制值，例如：
124先专为二进制，1111100，要专为十六进制，将1111100分为四位数一组，不足的用0补齐，则是0111  1100，0111的十进制是7，1100的十进制是12，但是在十六进制里面12是用c表示，那么124的十六进制就是0x7c。同理，将1111100分为三位数一组，则是001   111    100，其十进制依次是1，7，4，所以用八进制表示就是0174。

 负数的二进制：
负数的最高位都是1。正数的最高位都是0。负数二进制的表现形式就是正数的二进制取反加1。

  变量的定义：
就是内存中的一片存储区域，包含了变量名，数据类型，数据。
int（integer的缩写）为整数默认类型。
 
  定义变量的格式：
数据类型 变量名 = 初始化值;
比如：int a=4,b;表示定义了两个变量a和b，a的初始化值是4，但b没有初始化值，不能参与运算。
已经定义好的变量空间可以重复使用，不用再重复输入数据类型。比如：
int x = 10;
System.out.println(x);
x = 15
System.out.println(x);

  数据的类型：
java是强类型语言，每一种数据都定义了明确具体的数据类型，并在内存中按类型分配大小不同的空间。
基本数据类型：数值型，字符型，布尔型。
  数值型：整数类型，浮点类型。
    整数类型：byte（字节，一个字节用8个二进制表示，即一个八位，范围从负的2的七次方到正2的七次方减一，也就是-128到127），
                        short（短整型，一个short用16个二进制表示，即两个八位，范围从负的2的十五次方到2的十五次方减一，也就是-32768到32767），
                        int（整型，一个int用32个二进制表示，即四个八位，范围从负的2的三十一次方到2的三十一次方减一），int为整数的默认类型。
                        long（长整型，天文数字，比int更长）。比如：long x = 4l;，注意在4后面加一个l用于标识，因为默认是int，所以需要什么类型的需要在初始值后面加上一个标识。
    浮点类型：float（单精度，一个float占四个八位），比如：float x = 3.5f;，注意在3.5后面加上f用于标识，因为默认是double。
                        double（双精度，一个double占八个八位），double为小数的默认类型。
  字符型：char，一个字符占两个八位，范围是0到2的16次方减一，即0到65535。比如char x = '5';，char x ='a';，char x = '%';注意字符型的值要加单引号，多个字符就不叫字符了，叫字符串，要加双引号，注意区别。
  布尔型：boolean，就两种，true和false。
注意：同一个区间{}内不能定义两个同样的变量名，但是在同一个变量类型下面可以，新定义的变量会覆盖掉旧的变量，比如：
{
int x = 10;
System.out.println(x);
x = 15
System.out.println(x);
}
这样是可以的，结果会显示：
10
15
但是，下面这样就错了：
{
int x = 10;
byte x = 55;
}

  什么时候定义变量：
当数据不确定，但需要对数据进行存储的时候，这时候就需要定义变量。

  自动类型提升，也叫隐式类型转换，在进行运算的时候计算机会自动提升小的类型.
自动提升的 规则:
1.所有的byte 型、short型和char 的值将被提升到int型。
2.如果一个操作数是long 型，计算结果就是long 型；
3.如果一个操作数是float 型，计算结果就是float 型；
4.如果一个操作数是double型，计算结果就是double型。
例如:
byte x = 5;
x = x + 6;
System.out.println(x);
第一行中的x是指定的byte类型的，byte自动提升为int,和6相加之后还是int,但是x是先定义为byte的,所以会报错。

 强制类型转换，也叫显式类型转换，就是在赋值的时候需要把计算结果强制转换类型。
又比如：
byte x = 5;
int y = 6;
x = x + y;
同理x会自动提升为int类型，也由于x定义为byte，x + y为int，所以不能赋值给x，此时就需要进行强制类型转换，在x + y前面加上(byte)，并且将x + y括起来，即是x = (byte)(x + y);。

  注意，整数等常量可以直接赋值给变量，计算机只是判断常量是否在赋值的范围内，不会管类型，因为常量是固定的，但是如果是包含变量的运算，就要保持计算结果和等号另一边的变量类型一致了。

  什么时候进行强制转换：
比如计算结果是小数，需要保留整数部分，此时，转换为int就行了，或者需要查看其他类型，在ASCII中a是97，A是65，假如想查看f的对应数字是多少，则输入以下代码：
System.out.println('f'+0);或者这样输入：System.out.println((int)('f'));，假如查看102对应的字母是什么，则：System.out.println((char)(102));。同理在ASCII中字符1是49，如果想查看字符1的对应数字，则：System.out.println('1'+0);，因为当字符参与运算后，字符会被自动转为ASCII中的对应数字参与运算。

  运算符：
算术运算符
赋值运算符
比较运算符
逻辑运算符
位运算符
三元运算符

  算术运算符，注意计算的时候数据的类型，比如
int x＝1234;
x＝x/100*100;
System.out.prinln(x);
因为x和100都是int，所以1234/100的结果也应该是int，结果是12，再12*100=1200，最后的结果就是1200。

  算术运算中的取模就是取余数，取模的规律，左边小于右边，结果是左边的数字。左右相等，结果是0。右边是1，结果是0。能整除的都是0。但如果计算中出现负数，无视模数正负号，负的模数和正的模数一样。只看被模数的符号。比如：
1%5＝1
5%5＝0
10%5＝0
7%5＝2
-7%5=-2
-5%5=0
-4%5=-4
0模以除了0以外的任何数都是0。
0%2＝0


  自增运算：
a++和++a的运算方式是一样的，都是a的值加一，但是运算顺序不同，b=a++表示，先把a的原值赋给b，再把a加一，b=++a表示先把a加一，再把加一后的a赋值给b。自减同理。所以a++，++a和a=a+1一样。

  字符串相加，表示连接两个字符串，字符串和任何数据相加都表示连接，并且还是字符串。而字符和数字相加，则是字符对应的数字和另一个数字相加，注意区别。在使用打印命令的时候，为了让结果更加直观，可以这样输入：System.out.println("a="+a+","+"b="b);。

  转义字符：用\来转变后面字符或者符号的含义。比如System.out.println("hello\nworld");表示打印hello world会分两行显式，\n就表示换行的意思。还有其他的转义字符：
\n：换行
\b：退格 回删一个字符
\r：按下回车键，在windows系统中，回车符是由两个字符表示\n和\r，在linux的回车符只有\n。
\t：制表符 相当于按一次tab键
比如想打印带双引号的字符，不能system.out.pringln(""hello world"");应该把双引号转义，让其变成单纯的双引号，则是System.out.println("\"hello world\"");。

    赋值运算符：
+=：x+=4;，表示把左右两边的和赋给左边，意义等同于x=x+4;，但是有差别，比如
byte x=4;
x=x+5;
会报错，但是把第二行写成x+=5;就不会报错了，因为x=x+5是两次运算，先计算x+5，再把值赋给左边，由于类型不同，所以会报错，但是x+=5是一次运算，就相当于x=5，5会被自动转换类型。
 
  比较运算符的结果都是布尔型，注意=是赋值运算符，==是比较运算符，比较左右两边是否相等。

  逻辑运算符：
用于连接布尔类型的表达式，在java中不能写4<x<6，应该写成x>4&x<6，比如：
int x=5;
x>4&x<6=true&true=true;
与符号中，两边的boolean表达式中只要有一个是false，那结果就是false，只有两边都是true，结果才是true。
或符号中，两边的boolean表达式中只要有一个是true，那结果就是true，只有两边都是false，结果才是false。
异或符号中，只有一点和或不一样，就是true^true=false，两边相同结果是false,两边不同结果是true。注意：一个数和另一个数异或两次，不论顺序，结果还是原数，比如：
7^4^4=4^7^4=4^4^7=7，这样可以用于加密解密，比如把dvd原数据异或一次，相当于加密，再异或一次，就相当于解谜，数据还原。同理还可以添加更多的其他运算加密。
&和&&的区别：使用&的时候，无论，左边是true还是false，右边都运算。使用&&的时候，左边为true，右边运算，左边为false，右边不运算，因为左边为false，结果肯定false。
|和||的区别：使用|的时候，左右都运算，使用||的时候，当左边为true的时候，右边不运算，因为此时结果肯定是true。

  位运算符：
左移就是左边乘以2的右边次方，右移是左边除以2的右边次方，比如：3<<2=3*2*2，3<<3=3*2*2*2，3>>1=3/2。
左移空出来的都是补零，右移的时候空出来的位要以最高位为准，最高位是0就补零，是一就补一，如果是负数，由于负数最高位都是1，所以是补一，但是无符号右移都是补零，其结果都是正数。
与运算：0表示false，1表示true，所以6&3就是
  110
&011
=010，再把结果转换为十进制，就是2。或运算和异或运算同理。
位运算是一种高效的运算，但是只能用于计算与2的方次相乘的运算，比如：2乘以8的最有效运算方式不是2*8而是2<<3。

  反码运算：就是反向。所以负数就是正数取反加一，比如-6=~6+1=-7+1=-6。

  思考：如何更换两个整数变量。
方式1：借助第三方变量。
int temp;
temp=n;
n=m;
m=temp;
方式2：不借助第三方变量。但是如果n和m的值非常大，两者相加后就容易超出int的范围。
int n=3,m=4;
n=n+m;
m=n-m;
n=n-m;
方式3：不借助第三方变量，使用异或，而且不会出现相加后超出范围的问题。
int x=3,y=4;
x=x^y;//x=3^4
y=x^y;//y=3^4^4=3
x=x^y;//x=3^4^3=4
同理也可以这样写：
int x=3,y=4;
x=y^x;
y=x^y;
x=y^x;
因为一个数和两个相同的数异或，结果是那个单独的数，不论先后顺序。方式三的特点是左边从上到下是xyx，右边全是x^y。
总结：在实际开发的时候多用方式一，比较容易理解，方式而容易超出范围，方式三带有一定技巧性，不容易理解。

  要获取一个十进制的十六进制方式，比如获取60的十六进制方式：
int x=60;
int a=x&15;//获取60的最低四位，通过&15,也就是二进制的1111。
//如果a的值超过了9，要用字母表示，所以要求出是那个字母就要用到ASCII码，因为从10开始就要用字母表示，而a-10和那个字母减去A的ASCII值相同。
System.out.prinln((a>9)?(char)(a-10+'A'):a);
int b=60>>>4;//要获取下一组四位，需要右移四位,需要把有效位全部移光，所以需要用无符号右移，这样不论正负都是补零。
int c=b&15;//获取b的最低四位，通过&15.
System.out,println((c>9)?(char)(c-10+'A'):c);
结果会是
67
3
正确结果应该是
C
3
因为(char)(c-10+'A')被提升为int，这里不能在前面加强制转换，也就是不能System.out.println((char)((c>9)?(char)(c-10+'A'):c));，因为这样c也会被转为字符了，如果正确结果是数字，那转换后就成数字了，显然不行。也就是说如果结果是选择两种不能类型的时候，就不不能在前面直接加强制转换。所以结果会显示67而不是C，如何处理，这里的问题稍候再讲。另外计算是从最后四位开始的，所以正确的十六进制表示应该是3C。八进制同理，只是四位改为了三位。二进制也是一样，四位改为两位。

  三元运算符：有三个元素参与运算
格式：(条件表达式)?表达式1:表达式2;，如果条件表达式是true，执行表达式1，如果是false，执行表达式2。 注意表达式1后面的冒号和条件表达式后面的问号都是一个运算符，所以会出现上面在转换十六进制时出现的自动类型提升而导致的结果不正确。

  程序流程控制：
1.判断结构：
if语句，包含三种格式：
  1.//如果满足条件，就执行大括号里面的语句，否则就不执行。if和else if的条件表达式结果都应该是boolean型，所以条件表达式里面必含比较运算符和逻辑运算符。
      if(条件表达式)
{
      执行语句;
}

  2.if(条件表达式)//如果满足条件，就执行if大括号里面的语句，否则就执行else大括号里面的语句。
//三元运算符等同于if else语句，可以简化if else语句，另外三元运算符还可以写在其他运算符中，但是三元运算符是运算符，必须要有一个结果，而if else不用必须有结果。
{
       执行语句;
}
else
{
       执行语句;
}

  3.if(条件表达式)//如果满足if条件，则执行if语句，不满足则执行else if，如果else if还是不满足，则执行else。
{
      执行语句;
}
else if(条件表达式)
{
      执行语句;
}
....
else
{
      执行语句;
}
注意(条件表达式)后面没有分号。假如if下面没有大括号的话，那么if只对离if最近的那句命令有效。这三种都称之为一个独立的单条语句。

if语句举例：
例子1：
//需求：按照输入的数字打印对应的星期。
class Demo
{
    public static void main(String[] args)
    {
    int x;
    x=4;
    if(x==1)
        {
        System.out.println("星期一");
        }
    else if(x==2)
        {
        System.out.println("星期二");
        }
    else if(x==3)
        {
        System.out.println("星期三");
        }
    else if(x==4)
        {
        System.out.println("星期四");
        }
    else if(x==5)
        {
        System.out.println("星期五");
        }
    else if(x==6)
        {
        System.out.println("星期六");
        }
    else if(x==7)
        {
        System.out.println("星期日");
        }
    else
        {
        System.out.println("输入错误");
        }
}
例子2：
//根据输入的数字，打印对应的季节并显示输入的数字。
class Demo
{
    public static void main(String[] args)
    {
    int x;
    x=7;
    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 Demo
{
    public static void main(String[] args)
    {
    int x;
    x=5;
    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+"月 冬季");
        }
    }
}     

2.选择结构
switch语句的格式：
switch(表达式)
{
  case 取值1://如果取值1的答案匹配，则执行下面的执行语句，并以break结尾。
      执行语句;
      break;
   case 取值2://如果取值1不符合，则看取值2是否符合，如果还不符合就继续往下面看。
      执行语句;
      break;
    ...
    default://如果上面都不匹配，那么就执行这个默认的。
      执行语句;
      break;
}
命令结尾的break可以省略。

switch语句的特点：
  1.switch选择的类型只有四种：byte short int char，也就是switch后面的表达式和case的取值只能是数字或字符。
  2.case和default之间在书写上没有顺序，把default写在case的前面也行，但是程序是从第一个具体的答案开始读的，也就是从第一个case的取值开始读。
  3.switch语句的结束是到break结束或者到最后那个大括号结束。
  4.如果匹配条件的case或者default没有对应的break或者大括号，那么程序会继续往下面执行可执行的语句，直到遇到大括号或者break结束。比如：
int x;
x=7;
switch(x)
{
    default:
        System.out.println("a");
    case 2:
        System.out.println("b");
    case 3:
        System.out.println("c");
    case 5:
        System.out.println("d");
}
上面这段命令，从case 2开始读，一直读到case 5，再倒回来读default，满足条件，打印a，但是default后面没有break或者大括号，所以会继续打印b，c，d，d后面就有大括号了，程序到此停止。

也可以让多个case取值执行同一执行语句，比如之前写的根据输入数字打印对应季节。
int x;
x=6;
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+" 冬季");
    default:
        System.out.println(x+" 该月份不存在");
}

switch的应用，当判断的数值不多，并且符合byte，short，int，char的时候用switch，而当结果是boolean型或者是区间的时候，用if就比较方便了。

---------------------- android培训、 java培训、期待与您交流！ ----------------------详细请查看： http://edu.csdn.net/heima