我的Java成长之路001

这里开始我的学习之路，开始我的成长。

                                                                                                                                                                                                 Java基础

标识符：
注意点：a.由英文字母，数字，_（下划线）和$符组成；
        b.长度不限；
        c.不能以数字开头；
        d.区分大小写；
        e.不能包含空格；
用途：标识符一般用来命名变量，符号常量，数组，方法，类，对象，接口，包等。




关键字：虚词，没有完整的词汇意义，但有语法意义和功能含义。
    byte(1B)->short（2B）->int(4B)->long(8B)
    float(4B)->double(8B)
    char(2B)
    boolean(1B)（是独立的数据类型，既不能将整型数据赋给布尔变量，也不能将布尔类型的数转换为


整型或者其他类型）




基本数据类型定义：
注意：float  i=1.3；是错误的，浮点数的隐含类型为double型，当我们要定义一个float型的数时，必


须在该数后面加字母f，告诉编译器该数为float类型
    float型的范围：1.4×10-45至3.4×1038。
    double型的范围：4.9×10-324至1.8×10308。




字符串的声明方式：（其存储值的大小由缓冲池决定）
String str = “中国”;
String str = new String(); 
String str = new String(“中国”);
例如：
public class IfExample {
/**
 * @param args
 */
public static void main(String[] args){

String s1="234";
String s2=new  String("234");
String s3=new  String("345");

String s4="123";
s1=s4;
s2=s3;
s1=s2;

System.out.println(s1);//问题：String 字符串在内存空间中是怎样存储的
System.out.println(s2);

System.out.println(s1==s2);//存储空间不一样
System.out.println(s1==s4);//s4是s1的副本
System.out.println(s2==s3);//new String是重新开辟一个空间存储字符串的值
    }
}
运行后结果为：
345
345
true
false
true
+号，不仅仅可以用于数字运算，也可以用于字符串的连接，并且还可实现与其他类对象的连接，在连接


时其他类对象会被转换为字符串。另外，运算符“+=”把两个字符串连接的结果放进第一个字符串里。
例如：
public class Example1 {
    public  static void main(String[] args){
    int x=0,y=1,z=2;
    String sString ="x,y,z";
    System.out.println(sString+x+y+z);
    System.out.println(x+y+z+sString);
   
    }
}
运行后结果如下：
x,y,z012
3x,y,z
程序说明：
当字符串在“+”操作符左边时，则操作符右边的数据转换为字符串类型；而当字符串在操作符右边 ，


则操作符左边的数据为原来的类型挨着字符串的“+”操作符表示字符串连接操作。






注意：char类型的数据加减只能转换为ASCII码加减，不能用于连接操作。






基本数据类型转换：
隐式转换：当把级别低的变量赋值给级别高的变量时,自动完成数据类型转换。
强制转换：当把级别高的变量赋值给级别低的变量时,需要进行强制类型转换。
注意：显示类型转化（强制类型转换）可能导致数据精度的损失。
例如：
public class Number {
public static void main(String[] args){
byte a=120;
short b=255;
int c=2200;
long d=8000;
float f;
double g=123456789.123456789;
b=a;
c=(int)d;

f=(float)g;//有精度的损失
System.out.println("a="+a);
System.out.println("b="+b);
System.out.println("c="+c);
System.out.println("d="+d);
System.out.println("f="+f);
System.out.println("g="+g);

}
}
运行后得结果为：
a=120
b=120
c=8000
d=8000
f=1.23456792E8
g=1.2345678912345679E8






                          运算符、表达式、if分支语句
算术运算符：
+号，不仅仅可以用于数字运算，也可以用于字符串的连接。
-号只能进行数字运算，不能用于字符串。
算术混合运算精度从“低”到“高”的排列顺序是：
byte、short、int、long、float、double
注意：Java按照运算符两边最高精度保留结果。
即：如果int类型数据与float类型数据进行运算，结果为float类型。




关系运算符：（>,<,==,>=,<=,!=）
String类型赋值一般不用==比较，创建的地址不相同，与基本数据类型不相同
定义两个String类型的变量S1，S2
System.out.println("s1==s2："+s1==s2);//为什么不输出“”之间的内容
因为+号的优先级别比==号高，所以先执行“s1==s2”+s1,再将结果和后面的s2比较，所以才不会输出“


”之间的内容，解决办法：把s1==s2括起来即可。




位运算符：（&（与），|（或），~（非），^（异或））先将数据转换为二进制形式，在进行位运算
不得不说：以前从不知道^是异或运算符，还以为适用于写数据的指数呢，汗颜呀。
异或加密算法：
public class Example1 {
    public  static void main(String[] args){
        char c1='十';
    char c2='点';
    char c3='进';
    char c4='攻';
   
    char secret='8';
    System.out.println(" "+c1+c2+c3+c4);
    char m1=(char)(c1^secret);
    char m2=(char)(c2^secret);
    char m3=(char)(c3^secret);
    char m4=(char)(c4^secret);
    System.out.println("发送的密文："+m1+m2+m3+m4);
    char r1=(char)(m1^secret);
    char r2=(char)(m2^secret);
    char r3=(char)(m3^secret);
    char r4=(char)(m4^secret);
    System.out.println("解密后明文："+r1+r2+r3+r4);
    }
}
运行后所得结果为：
十点进攻
发送的密文：卹炁迣攃
解密后明文：十点进攻
由此可知：异或运算是可逆的。




逻辑运算符：（&&(与),||(或),!(非)）
&&和||的结合方向是从左至右；
！的结合方向是从右至左。
位运算符与逻辑运算符的区别：
逻辑运算符又称短路运算符，可以连接两个表达式，这两个表达式的值必须是布尔类型，即true或者


false，在条件判断时，如果前一个表达式成立，则后面的表达式也都不再运算。
位运算符不是短路运算符，所连接的表达式不一定是逻辑表达式，也可以进行数值运算，在条件判断时


，如果前一个表达式成立，后面的表达式要进行运算。
例如：


public class Example1 {
    public  static void main(String[] args){
    int x=10,y=10,a=10,b=10;
    if(((x=0)==0)||((y=20)==20))
       System.out.println("y="+y);
    if(((a=0)==0)|((b=20)==20))
        System.out.println("b="+b);
    }
}
运行后所得结果为：
y=10
b=20




移位运算符：
1. >> 右移运算符：将二进制数据进行右移运算。
2. << 左移运算符：将二进制数据进行左移运算。
3. >>> 无符号右移运算符：无论正负，都在高位插入0。
例如：
public class Example1 {
    public  static void main(String[] args){
    System.out.println(2<<2);
    System.out.println(3<<2);
    System.out.println(-2<<2);
    System.out.print(-3<<2);
    System.out.println(16>>>3);
    System.out.println(-16>>>3);
   
    }
}
运行后结果如下：
8
12
-8
-12
2
536870910




运算符的优先级：


                                   运算符    优先级


                                   括号         1
                                   ++,-- 2
                                     ~,! 3
                                   *,/,% 4
                                     +,- 5
                                   >>,<<,>>> 6
                                   >,<,>=,<= 7
                                   ==!,!= 8
                                       & 9
                                       ^ 10
                                       | 11
                                       && 12
                                       || 13
                                       ?: 14
注意：运算时要特别注意运算符的优先级，以免出现失误。






if语句的几种形式：
1.if ( <布尔表达式> ) {  
满足布尔表达式时需要执行的代码;
}


2.if ( <布尔表达式> ) {  
满足布尔表达式时需要执行的代码;
} else { 
不满足布尔表达式时需要执行的代码;
}


3.if ( <布尔表达式1> ) {  
满足布尔表达式1时需要执行的语句体;
} else if ( <布尔表达式2> ) { 
不满足布尔表达式1，但满足表达式2时需要执行的语句体;
} else {
不满足布尔表达式1，也不满足表达式2时需要执行的语句体;
}




switch语句：
switch ( <整型表达式> ) { 
 
case <整型常量1> :  当整型表达式的值等于整型常量1时执行的语句;
  break;
  
case <整型常量2> :  当整型表达式的值等于整型常量2时执行的语句; 
  break;
  
case <整形常量3> :  当整型表达式的值等于整型常量3时执行的语句; 
  break;
  
default:  当整型表达式的值不满足任何一个case的值时，执行的语句;


}
例如：
public class Example1 {
    public  static void main(String[] args){
    int x=2,y=1;
    switch(x+y){
    case 1:
    System.out.println("ji");
    break;
        case 2:
    System.out.println("jij");
    break;
    case 3:
    System.out.println("lll");
    break;
        default:
        System.out.println(" cannot  found");
    }
    }
}
运行后结果为：
lll




for循环语句：
for ( <初始化循环因子>;<布尔型循环条件>;<循环因子步进> ) {     当循环因子满足布尔型循环条件


时执行的语句，


     当前一次循环执行完成后循环因子步进执行，     然后回到循环体首进行下一次循环;


}注意：初始化循环因子后，只要循环因子满足条件，循环就要执行。






While循环语句：
1.while ( <布尔型循环条件> ) {
当布尔型循环条件的值为真（true）时，执行的语句，
直到布尔型循环条件的值为假（false）时，退出循环;
}


2.do {
执行语句，然后判断布尔型循环条件的值，
如果为真（true），则继续循环，否则退出循环;
} while ( <布尔型循环条件> );




continue关键字：
continue用于在循环体内，跳过continue之后的代码，回到循环体首执行下一次循环。
例如：
public class Example1 {
    public  static void main(String[] args){
    int i=0;
    for(i=0;i<10;i++){
    if(i%2==0)
    continue;
    System.out.println(i);
    }
    }
}
运行后结果为：
1
3
5
7
9




break关键字：
break用于跳出当前循环体，结束循环。
例如：
public class Example1 {
    public  static void main(String[] args){
    int i=0;
    for(i=1;i<10;i++){
    if(i%2==0)
    break;
    System.out.println(i);
    }
    }
}
运行后结果为：
1




新知识：
接收控制台（console）输入的方法 
【1】import java.util.Scanner;
【2】Scanner scan = new Scanner(System.in);
int m = scan.nextInt();
//此时，m为接收到的用户输入
用于产生随机数的方法：
double b = Math.random();

基础总结完了，如果各位觉得有什么不妥当的，一定要吐槽呀！！！