java语言基础

关键字：其实就是一个计算机语言对指定的单词赋予了特殊的含义，比如class public  static  void ，都是固定的写法，你并不能随便的变化，也就是不是自己定义的。特点：都是英文小写单词。

标识符：比如class Demo中的Demo，就是在程序中起的名字。 包含0-9，a-z，$, _   注意：1、数字不可以开头 2、名称不可以使用关键字 3、数字不可以开头 4、名字中不可以有其他符号包括空格 

类型转换，类型转换分为自动类型转换和强制类型转换两种。

自动类型转换：将一种类型的值赋给另一种类型的变量时发生的类型转换，自动类型转换需要满足以下两个条件：1）转换前的类型和转换后的类型兼容；2）转换后的类型的表示范围大于转换前的类型的表示范围。通常的转换如下：

byte→short→char→int→long→float→double    白芍茶因狼服大宝

 1 public class TypeCast {
 2     public static void main(String[] args) {
 3         int i = 100;
 4         char c1 = 'a';//注意用char生命的是要加''的
 5         byte b = 3;
 6         long l = 567L;//声明长整形的变量，其后要加上类型符L
 7         float f = 1.89f;//声明float类型的变量，其后要加上类型符f
 8         double d = 2.1;
 9         int i1 = i + c1; // char类型的变量c1自动转换为int类型参加运算
10         long l1 = l - i1; // int类型的变量i1自动转换为long类型参加运算
11         float f1 = b * f; // byte类型的变量b自动转换为float类型参加运算
12         /* int类型的变量i1自动转换为与f1一致的float类型f1/i1计算结果为float类型. 然后再转换为与d一致的double类型。 */
13         double d1 = d + f1 / i1;
14         System.out.println("i1=" + i1);
15         System.out.println("l1=" + l1);
16         System.out.println("f1=" + f1);
17         System.out.println("d1=" + d1);
18     }
19 }

i1=197

l1=370

f1=5.67

d1=2.1287817269563676

强制类型转换：当要将一个类型表示范围的数赋值给表示范围小的数的时候，例如要将一个double类型的数赋值给int类的数的时候，就需要强制类型转换，语法格式如下：

data_type var1=(data_type)var2;

例如：

float flag = 30.33f;

int num = (int)flag;

在强制类型转换中会丢失精度。在上面的例子中num的值是30。

说明：由于float和double表示的都是约数，所以不要用它们表示需要精确的数，比如货币等，如果要表示精确值，需要使用java.math.BigDecimal类。

 需要注意的细节

1、每个字母都有对应的ASCII码（注意每一句的结果）

package day2;

public class n1 {
    public static void main(String[] args) {
       System.out.println("a"+1);
       System.out.println('a'+1);
       System.out.println('a'+'1');
       System.out.println("5+5="+5+5);
       //System.out.println('5+5='+5+5);
       System.out.println(5+5);
       System.out.println("5+5="+(5+5));
    }

}

a1
98
146
5+5=55
10
5+5=10

a的ASCII码是97  1的ASCII是49。
关键点：字符串和任何数据做+动作，都是相连接，生成一个新的字符串

2、容易忽视的精度问题

比如：

package day2;

import java.util.Scanner;

public class n1 {
    public static void main(String[] args) {

    byte b1=1;
    byte b2=2;
    byte b;
    //b= b1+b2;//这里是会出现错误的
    b= (byte)(b1+b2)//这里是对的
//    b =b1+2;//这里也是不对的
    b=1+2;
//    b=b+b1;//这里也是不对的
    b+=b1;//这里虽然看起来和上面的一样，但是还是有区别的
    System.out.println(b);
    
    }

}

在这里涉及到自动强制转换的问题，还有不允许丢失精度的问题，还有一个赋值符号可以自动强制转换的问题。
byte类型的两个变量相加或者一个byte和其他的类型相加的时候会出现错误，是不允许的，容易丢失精度，因为变量的值是变化的，比如，给byte b1 = 127  byte b2 = 2   即使b = 127+2也会出现错误的情况。这是什么原因？因为在赋值的时候默认为把int型的常量赋值给byte类型的变量，程序自动识别这个byte型的变量是否能够容得下这个整形的常量，如果容得下，那么就会将这个数字转为byte类型，但是如果容不下就会报错byte b = b1+b2   或者byte b = b1+6这种情况出现了精度丢失的情况。

还有+=与=的问题：赋值符号有= += -+ /+ *= %=  赋值符号有一个功能就是自动强制转换数值类型，所以当人们怕出现错误的时候经常把b = b+b1 写成b+=b1 

算数运算符：

常见问题1：

int x=427;
x=x/100*100;

我们一看肯定=427，但是实际上程序的结果是400，因为两个整形的相除结果是不会得到double型的，在427/100的时候结果就已经变成了400

 关于自增自减得问题：

一般不做运算的情况下++a和a++没有什么区别但是在变量参与运算的时候就出现了差别

比如

b=++a
运算过程：
右边a=a+1;
      a=4;
左边b=a;
      b=4

b=a++
运算过程：因为++在a的后面说明先把a赋值给b，然后再进行自加运算：
现将a变量中的数据，进行临时存储
temp=a
自增运算
a=a+1
a=4
将临时存储的a的数据赋值给b
b = temp

易错点：

package day2;

import java.util.Scanner;

public class n1 {
    public static void main(String[] args) {

    int a = 3;
    int bb = 2;
    int c = a++;//先进行临时存储，再赋值
    int d = ++a;
    System.out.println(c+" "+d);
    
    }

}
在这里我们也许会以为结果是3  4
但是正确结果是3 5（因为上面a已经进行过一次自加运算）

赋值运算：

易错点：特殊short 

 short s = 3;
  //  s=s+6;//这里是错的
    s+=6;//这里是对的
这是为什么呢？s是short，6是int，short会转变成int，再赋值给short的时候转换不过来会丢失精度
s+=6本身是赋值运算，因为+=是赋值运算，会有一个自动转换的过程，总之记住这种特殊情况
byte a ,b;
short c ,d;
a=a+b;
a=a+6;
c=c+d;
c=d+6;
a+=b;//yes
c+=d;//yes
a=1+3;//yes
c=3+2//yes

逻辑运算符：

&：只要两边有一个为false，结果就为false，两边都为true那么结果为true。无论左边是什么，两边都运算

|：只要两边有一个true结果就为true，两边都为false，结果为false。两边都运算

&&：当左边为false时，右边不参与运算，但是当左边是true的时候右边还是要看的

||：当左边为true时，右边不参与运算，当左边是false的时候右边还是要看的

^:两边结果一致，那么运算结果为false，如果不一致结果为true。

位运算符：（这个是比较重要的，因为运算起来比较快）用于操作二进制位的符号

左移<<  又移>>   无符号右移>>>

比如3<<2=12,每往左移一位就是乘以2的次幂，方便进行乘以2的次幂运算

3*2^2 = 12

3<<3 : 3*2^3 = 24

右移6>>1  6/(2^1)

     6>>2:6/(2^2)

也就是说做乘右除

右移是除以2的次幂运算

左移的时候空位出现在低位，用0补位

右移的时候出现在高位，原来高位是什么就用什么补位

>>>空位出现在高位，无论高位是什么。空位都用0补

&：

6&3：

省略前面的0：
   110
&  011
------------
   010=2

6|3

  110
| 011
-----------
   111 =7

***一个数异或另外一个数两次还是本身**********

~：取反  ~6=-7（因为-6是6取反加1，这个只取反，没有加1）

位运算的速度非常快，比加减乘除快

判断结构

if      else if     else

虽然是多行，但是是单条语句

虽然由多个代码块组成，但是只有一个会执行

比如：

package day2;

import java.util.Scanner;

public class n1 {
    public static void main(String[] args) {
       int x = 3;
       if(x>1)
           System.out.println("a");
       else if(x>2)
           System.out.println("b");
       else
           System.out.println("c");
       System.out.println("over");

    }

}

a
over

虽然x>2这个条件也满足但是，记住if  else if  else 只能有一个执行

一个if 对应一个else

比如：

package day2;

import java.util.Scanner;

public class n1 {
    public static void main(String[] args) {
       int x = 3;
       if(x>1)
           System.out.println("a");
       
       if(x>2)
           System.out.println("b");
        if(x>3)
           System.out.println("dd");
       else
           System.out.println("c");
       System.out.println("over");

    }

}

a
b
c
over

注意switch结构，注意

switch（条件）

{  case X：

    break;

    case x:

    break;

     ……

     default：

       ……

}

 举例

package day2;

import java.util.Scanner;

public class n1 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while(true)
        {
            int x = scanner.nextInt();
        
        
        switch( x)
        {
        
        case 1:
        case 2:
        case 3:
            System.out.println("spring");
            break;
        case 4:
        case 5:
        case 6:
            System.out.println("summer");
            break;
        case 7:
        case 8:
        case 9:
            System.out.println("autome");
            break;
        default:
            System.out.println("winter");
        }    
        }
        
    }

}

if 和switch 语句的应用场景
1、如果对具体个数的数值进行判断，用if也可以，用switch也可以，但是建议使用switch因为switch会提高效率
2、如果要对区间进行判断的话，用if语句
3、如果运算结果是布尔型，用if语句

while do 与  do while区别

while (){do}，满足条件执行语句，但是do{} while;无论是否满足条件，第一次的do都执行

for( ; ; )//for语句的最简单无限循环模式
{}
while(true)//while语句的最简单无限循环模式
{}

关于转义字符" "

比如九九乘法表

package day3;

public class test1 {
     public static void main(String[] args) {
         int i;
         int j;
         for(i=1;i<=9;i++)
         {
             for(j=1;j<=i;j++)
                 System.out.print(j+"*"+i+"="+(i*j)+"   ");
             System.out.println();
         }
         
     }
}

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 //这个地方开始不对齐
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

但是你要是用了" "制表符，就会变得非常整齐

package day3;

public class test1 {
     public static void main(String[] args) {
         int i;
         int j;
         for(i=1;i<=9;i++)
         {
             for(j=1;j<=i;j++)
                 System.out.print(j+"*"+i+"="+(i*j)+"	");
             System.out.println();
         }
         
     }
}

1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81

 JAVA语言综合题目

1、

package day3;

public class test1 {
     public static void main(String[] args) {
     
         int x=1,y=1;
                 if(x++==2 & ++y==2)
                 {x=7;}
                 System.out.println(x+" "+y);
     }
}

2 2

分析：这道题看起来应该是x=7 y=2，但是实际上++在x的后面，也就是x有一个暂存变量的过程，现将x=1赋值给temp然后x再自加，这里是用的temp与2进行比较，所以这里就是false，右边++y=2没错
false &true = false，所以x=7不能执行，但是最终x++是做了自加运算的，所以x=2

 2、

package day3;

public class test1 {
     public static void main(String[] args) {
     
         int x=1,y=1;
                 if(x++==2 && ++y==2)//一个是x先比较再自加，另外一个是先自加在比较
                 {x=7;}
                 System.out.println(x+" "+y);
     }
}

2 1

分析：x=2能理解，但是为什么y=1呢？因为这里涉及到&&，&&有个特点那就是左边只要错了右边就不执行了，左边x++！=2，所以右边不执行，所以y还是=1

3、

package day3;

public class test1 {
     public static void main(String[] args) {
     
         int x=1,y=1;
                 if(x++==2 | ++y==2)
                 {x=7;}
                 System.out.println(x+" "+y);
     }
}

7 2

|是左右都看的，左边x++==2false，右边++y=2true，左右都执行了，false|true = true，所以x=7,y=2

4、

package day3;

public class test1 {
     public static void main(String[] args) {
     
         int x=1,y=1;
                 if(x++==1 || ++y==2)
                 {x=7;}
                 System.out.println(x+" "+y);
     }
}

7 1

分析：x=1 x++==1 true 因为中间是||左边对了中间不读，结果就是true所以x=7,y=1

这么来说的话就是“|”如果左边对的话右边也是读的，“&”如果左边错误的话右边也是读的。“&&”，左边错了的话右边就不读了，“||”左边对的话，右边也不读了

5、

package day3;

public class test1 {
     public static void main(String[] args) {
         boolean b = true;
         if(b==false)
             System.out.println("a");
         else if(b)
             System.out.println("b");
         else if(!b)
             System.out.println("c");
         else
             System.out.println("d");
     }
}

b

记住 if（不能是赋值符号）

6、

package day3;

public class test1 {
     public static void main(String[] args) {
         int x = 2,y=3;
         switch(x)
         {
         
         default:
         {
             y++;
             System.out.println("1");
             
         }
         case 3:
         {
             
             y++;
             System.out.println("2");
         }
         
         case 4:
         {
             y++;
             System.out.println("3");
         }
         
         }
         System.out.println(y);
     }
}

1
2
3
6

分析：如果忽视细节肯定以为这道题的答案是4 1，但是要注意的是case后面没有break啊，而且把default放在case前面和放在后面是完全不一样的，如果放在后面的话，如果case情况不符合就不会执行case里面的内容，但是要是default放在前面的话就不管case括号里面的内容是否符合都会执行case{}的内容。

       

+++++++++