三、java 基础提炼

一、标识符：凡是自己命名的都是标识符

标识符的定义规则：

•  由26个字母大小写，0-9，_或$组成；
• 数字不能开头；
• 不可以用用关键字、保留字，但可以包含关键字和保留字；
• java严格区分大小写；
• 标识符不能包含空格.

java中名称的命名规范：

• 包名:多单词组成时，所有字母都小写xxxyyy；类名、接口：多单词组成时，所有单词首字母大写：XxxYyy；
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz;
• 常量名：所有字母大写，多单词时，每个单词用下划线连接；XXX_YYY_ZZ；

 二、计算机中的进制：

public static void testBinerary() {
        int num1 = 0b110;
        int num2 = 110;
        int num3 = 0127;
        int num4 = 0x110A;
        System.out.println("num1="+num1);//打印出来的都是10进制
        System.out.println("num2="+num2);
        System.out.println("num3="+num3);
        System.out.println("num4="+num4);
        //自动转换
        int i= 60;
        String s1 = Integer.toHexString(i);    
        String s2 = Integer.toBinaryString(i);
        System.out.println(s1+","+s2);
                
    }

三、变量：内存中的一个存储区块，用于内存中保存数据，包含变量类型 变量名 和存储值。

1.  java中每个变量需要先声明，后使用（变量在方法内声明，必须赋值（初始化）才能使用；在类中声明，会带默认值）；
2.  使用变量访问区块数据；
3.  变量只有在共有作用域中才有效；
4.  同一个作用域内不能定义重名的变量；

java中的数据类型：

1. 基本数据类型：byte short int long float double char boolean
2. 引用数据类型：类 接口 数组

变量的使用：

/**
     *整型变量的使用；
     *byte = 8bit 可以表示2^8个数 -128 ~127；1字节</br> 
     *short 可以表示2^16个数；2字节</br>  
     *int 可以表示2^32个数；4个字节</br> 
     *long 可以表示2^64个数 8个字节,必须以大写的L/l的结尾；
     */
    public void testInteger() {
        //byte 的范围 -128 ~127
        byte b1 = 1;
        byte b2 = 127;
        //long变量 必须以大写的L/l的结尾
        long l = 34444444444L;
    }
    
    /**
     *浮点型（带小数点的）： 
     * float：4字节 7位有效数字
     * double：8字节
     */
    public void testFloat() {
        double d1 = 123.1;
        System.out.println(d1+1);
        //float 定义 后面加f/F结尾
        float f1 = 123.1f;
        System.out.println(f1);
    }
    /**
     *字符型：
     *
     *<p>1个字符 = 2字节</br>
     * 声明char 变量，通常使用单引号</br>
     * 允许使用转义符‘’ 来将其后的字符转变为特殊字符型常量；如
'表示回车</br>
     * 直接使用Unicode值来表示字符常量 \uXXXX 其中 XXXX代表一个十六进制整数</br>
     * </br>
     */
    public static void testChar() {
        //''里面只有写一个字符
        char a = 'a';
        System.out.println(a);
        //转义字符
        char c1 = '
';//回车
        char c2 = '	';//制表符
        char c3 = 97;//十进制的a
        char c4 = 'u0061';//16进制a
        char c5 = 'u34c7';//㓇
        System.out.println("a"+c1);
        System.out.println("hello"+c2+"world");
        System.out.println(c3);//对应ASC码
        System.out.println(c4);
        System.out.println(c5);
    }
    
    /**
     *boolean：只能取两个值之一：true false
     *<p>常在判断 or 循环结构中使用
     */
    public void testBoolean(){
        boolean bb1 = true;
        System.out.println(bb1);
        
    }

基本本数据类型之间的运算规则 (这里讨论的基本数据运算，不包含Boolean)

 1.自动提升：小的范围 和 大范围的做运算时 用大范围的数据类型来接收：

　　byte、short、char --> int --> long-->float --> double <br>
　　byte short char 之间做运算或者跟跟自身做运算 ，都需要用int接收
 2.强制类型转换：自动类型提升的逆运算；可能会导致精度损失
 　　需要使用强转符：（）
3.整型常量 默认是int 浮点型常量默认是 double；

/**
 * 自动类型提升
 */
    public static void testOperation() {
        byte b1 = 2;
        int i1 = 3;
        int res = b1 + i1;
        char c1 = 97;
        short s = 1;
        // char res2 = c1 +s; //char + short 运算
        // res2 = b1 +c1;//char + byte 运算
        // char res2 = b1 +s;//short + byte 运算
        System.out.println(res);
    }
    /**
     *强制类型转换 
     */
    public static void testConversion() {
        double d1 = 12.3;
        int i = (int)d1;
        System.out.println(i);
    }
    
    /**
     *整型常量 默认是int 浮点型常量默认是 double； 
     * 
     */
    public static void testSpecial() {
        byte b1 = 12;
        //byte res = b1+1;//报错：1是int ,所以这里需要用int接收
        float f = 1.1f;
        //float res2 = f+1.2;//报错：1.2默认是double，double的范围比float大不能自动类型提升；         
    }

  String类型变量的使用

1. String属于引用数据类型；（其他的引用数据类型有 类 和接口 数组）
2. 声明String类型变量时，使用“”；
3. String 可以和8中数据类型做运算，运算只能是连接运算，运算的结果是String类型；

public static void testOperation() {
        boolean b = true;
        String s = "s";
        System.out.println(s+b);//这里的“+”是连接运算；
        char c='a';
        int num = 100;
        String str = "hello";
        System.out.println(c+num+str);//c+num 是加法运算，后面是连接运算
        System.out.println(c+str+num);//c+str 是连接运算，后面是连接运算
        System.out.println(c+(num+str));//(num+str)连接，都是连接
        System.out.println((c+num)+str);//c+num 是加法运算，后面是连接运算
        System.out.println(str+c+num);//都是连接
        System.out.println("*"+"	"+"*");
        System.out.println("*"+("	"+"*"));
        System.out.println('*'+'	'+"*");
        System.out.println('*'+('	'+"*"));
        //String strw = 123;//声明String类型变量时，使用“”
        String str1 =  123+"";
        //int num1 = (int)str1;//不能强转int Integer.parseint(str1)
    }

四、运算：

算术运算符（ + - * / % ++ -- ....）

public static void testAri() {
        //除法
        int num1 = 12;
        int num2 = 5;
        System.out.println(num1/5);
        double d1 = 12;
        double d2 = 5;
        double res = d1/d2;
        double res1 = num1/num2+0.0;
        double res2 = (0.0+num1)/num2;
        System.out.println("res:"+res);
        System.out.println("res1:"+res1);
        System.out.println("res2:"+res2);
        
        //++运算，前++，先自增，再运算；后++，先运算后自增1；
        int a1 = 10;
        int b1 = ++a1;
        System.out.println("a1:"+a1+",b1:"+b1);
        
        int a2 = 10;
        int b2 = a2++;
        System.out.println("a2:"+a2+",b2:"+b2);
        
        short s1 = 10;
        s1++; //s1 = (short)(s1+1);++不会改变自身数据类型
        
        byte bb1 = 127;
        bb1++;
        System.out.println("bb1:"+bb1);
        
        
        //取余,结果的符号与被摩数的符号一样
        int m1 = 12;//被模数
        int n1 = 5;//模数
        System.out.println("m1 % n1 = "+ m1%n1);
        
        int m2 = -12;//被模数
        int n2 = 5;//模数
        System.out.println("m2 % n2 = "+ m2%n2);
        
        int m3 = -12;//被模数
        int n3 = -5;//模数
        System.out.println("m3 % n3 = "+ m3%n3);
        
        int m4 = 12;//被模数
        int n4 = -5;//模数
        System.out.println("m4 % n4 = "+ m4%n4);
    }

tips:前++ 和 后++ 的具体区别，可以查看：https://www.cnblogs.com/lixiuming521125/p/10865392.html

 
赋值运算：= +=,-+,/+,%=

public static void testSetValue() {
        //赋值符号
        int i1 = 10;
        int j1 = 10;
        
        //连接赋值；
        int i2,j2;
        i2= j2 =10;
        
        int i3,j3 =20;
                
        int num1 =10;
        num1 +=2;//num1 = num1+2
        System.out.println(num1);
        
        short s1 = 10;
        s1+=2;//+= 不能改变变量的数据类型
        System.out.println(s1);
        
        int i = 1;
        i *= 0.1;
        System.out.println("i:"+i);//i=0
        
        int m = 2;
        int n = 3;
        n *= m++;
        System.out.println("m:"+m);
        System.out.println("n:"+n);
        
        int nn = 10;
        nn += nn++ +(++nn);// nn =  nn+(nn++ +(++nn))
        System.out.println(nn);
        
        
    }

比较运算： == != < > <= >=

1. 比较运算的结果是boolean类型；只能是true or false; 
2. < > <= >=:只能使用在数值类型的数据之间;
3. ==：不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间;

逻辑运算：只能适用于boolean的变量 （相关扩展：https://www.cnblogs.com/lixiuming521125/p/12053966.html）

public static void testLogic() {
        //区分& 和 &&
        //相同点：& 和 && 的运算结果相同；当符号左边是true时，二者都会执行右边运算；
        //不同点：当符号左边是false是，& 还是执行右边运算， && 不执行；
        boolean b1 = false;
        int num1 = 10;
        if(b1 &(num1 ++>0)) {
            System.out.println("if");
            
        }else {
            System.out.println("else");
        }
        System.out.println(num1);
        int num2 = 10;
        if(b1 &&(num2 ++>0)) {
            System.out.println("if");
            
        }else {
            System.out.println("else");
        }
        System.out.println(num2);
        
        // 区分： | 和 ||
        //相同点：| 和 || 的运算结果相同；当符号左边是false时，二者都会执行右边运算；
        //不同点：当符号左边是true是，| 还是执行右边运算， || 不执行；
        boolean b2 = true;
        int num3 = 10;
        if(b2 |(num3 ++>0)) {
            System.out.println("if");
            
        }else {
            System.out.println("else");
        }
        System.out.println(num3);
        int num4 = 10;
        if(b2 ||(num4 ++>0)) {
            System.out.println("if");
            
        }else {
            System.out.println("else");
        }
        System.out.println(num4);
    }
    

位运算：操作的是整型的数据

1.  x<<n  x*2^n   
2.  x>>n  x*2^-n       
3.  >>> 无符号右移：   
4.  &:与               
5.  |：或              
6.  ^:异或           

 面试题：最高效的计算 2*8 2<<3

public static void testBitAri() {
        int i = 21;
        System.out.println("i<<2:"+(i<<2));//21*2^2
        System.out.println("i>>:"+(i>>2));
        
        int m = 12;
        int n = 5;
        System.out.println("m&n:"+(m&n));
        System.out.println("m|n:"+(m|n));
        System.out.println("m|n:"+(m^n));
        
        //交换两个变量的方式
        //方式一：
        int num1 = 10;
        int num2 = 20;
        int temp = num1;
        num1 = num2 ;
        num2 = temp;
        System.out.println("num1:"+num1+",num2:"+num2);
        //方式二：
        num1 = num1+num2;
        num2 = num1-num2;
        num1 = num1-num2;
        System.out.println("num1:"+num1+",num2:"+num2);
        //方式三： m =（m^n）^n
        
        num1 = num1^num2;
        num2 = num1^num2;
        num1 = num1^num2;
        System.out.println("num1:"+num1+",num2:"+num2);
    }

三元运算符：（表达式)? 表达式一：表达式二

1. 条件表达式的结果是boolean类型；
2. 根据条件表达式的结果，决定执行表达式一or 二； true:表达式一，否则：表达式二
3. 表达式一 和表达式二 要求是一直的；
4. 凡是使用3元运算符的，都可以改写成 if else;反之 不成立
5. 如果既可以使用三元运算符，又可以用if else ,就使用 三元运算符，因为运行效率高

public static void testThreeAri() {
        //获取两个数的较大值
        int m= 12;
        int n = 5;
        int max = m>n?m:n;
        String res = m>n?"m 大":(m==n?"相等":"n大");
        System.out.println(max);
        System.out.println(res);
        
        if(m>n) {
            System.out.println("m大");
        }else {
            
            
        }
    }

 

五、流程控制:

分支结构：1.if else 

 if(条件表达式){

}

 if(条件表达式){
}else{

 }

if(条件表达式){
}else if{
}....
 else{

}

分支结构：2.switch case

switch("表达式"){
      case 常量一：
      执行语句
     ///break;
     case 常量二：
     执行语句；
 ///break;    
      ...
      default:
      执行语句；
  }

 switch(表达式) 这个表达式只能是如下6种数据类型： byte short int char int 枚举 String
 case后只能加常量;
 break 关键字是可选的；
 default：相当于if-else 中的else default是可选的；而且位置是可变的（比如：default可以放在第一个case之前）；
 说明：如果switch中的多个case的执行语句相同，则可以考虑合并；

public static void testSwitchCase() {
    int num = 4;
    switch (num) {
    case 1:
        System.out.println("one");
        break;
    case 2:
        System.out.println("two");
        break;
    case 3:
        System.out.println("three");
        break;
        default:
            System.out.println("其他");
    }
    
    //case 0 到case5 合并了；（）
    int score  = 78;
    switch (score/10) {
    case 0:
    case 1:
    case 2:
    case 3:
    case 4:
    case 5:
        System.out.println("不合格！");
        break;
    case 6:
    case 7:
    case 8:
    case 9:
    case 10:
        System.out.println("合格！");
        break;
    
    }
    
}

for 循环
循环结构的4个要素：
  1.初始化条件；
 2.循环条件（boolean）；
 3.循环体；
 4.迭代条件

 for循环的结构
      for(1;2;4){
          3
      }
 for 的无限循环： for(;;)

public static void testFor() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数：");
        int num1 = scanner.nextInt();
        System.out.println("请输入第二个数：");
        int num2 = scanner.nextInt();
        int min  = num1>num2?num2:num1;
        int max  = num1>num2?num1:num2;
        for(int i=min;i>=1;i--) {
            if(num1%i ==0 && num2%i == 0) {
                System.out.println("他们之间的最大公约数是："+i);
                break;
            }
        }
        for(int i=max;i<=(min*max);i++){
            if(i%min ==0 && i%max==0) {
                System.out.println("他们之间最小公倍数是："+i);
                break;
            }
        }
    }

while 循环
循环结构的4个要素：
 1.初始化条件；
 2.循环条件（boolean）
 3.循环体
 4.迭代条件
 
while循环的结构
       1
       while(2){
           3
           4
      }
 while 无限循环 ： while(true)
 for循环和while循环可以相互转换

    public static void testWhile() {
        int i=1;
        while(i<=100) {
            if(i%2==0) {
                System.out.println(i);
            }
            i++;
        }
    }

do while 循环:
循环结构的4个要素：
 1.初始化条件；
 2.循环条件（boolean）
 3.循环体
 4.迭代条件
 
   1
   do({
       3;
       4;
   }while(2)
 
  do while至少会执行一次循环体

public static void testDoWhile() {
        int i=1;
        do {
            if(i%2==0) {
                System.out.println(i);
            }
            i++;
        }while(i<=100);
                
        
    }

break和continue    关键字的使用
break：switch- case  ；循环结构中使用（结束当前循环）
continue： 循环结构中使用（结束当次循环）
关键字后面不能有执行语句；

public static void testBreakContinue() {
        for(int i=1;i<10;i++) {
            if(i % 4 ==0) {
                System.out.println(i);
                //break; 1,2,3
                //continue  1 2 3 5 6 7 9
            }
        }        
    }
    
    public static void testBreakContinue1() {
        label:for(int i=1;i<4;i++) {
            for(int j=1;j<10;j++) {
                if( j%4 ==0) {
                    //break;//结束当前for循环
                    //break label;//结束标识的层的循环
                    continue label;//结束指定标识的一层循环结构；
                }
                System.out.println(j);
            }
        }        
    }

for-for 循环 9 9 乘法表 ，100以内质数...

public static void testForFor1() {
        for(int i=1;i<=5;i++) {
            for(int j=1;j<=i;j++) {
                System.out.print("*");
            }
            System.out.print("
");
        }
        
        
    }
    //9 9 乘法表
    public static void testForFor2() {
        for(int i=1;i<=9;i++) {
            for(int j=1;j<=i;j++) {
                System.out.print(i+"*"+j+"="+i*j+"    ");
            }
            System.out.print("
");
        }        
    }
    
    public static void testForFor() {
        for(int i=2;i<=100;i++) {
            boolean flag = false;
            for(int j=2;j<i;j++) {//普通算法  高级算法：for(int j=2;j<=Mth.sqrt(i);j++);
                if(i % j == 0 ) {
                    flag = true;
                    break;
                }
            }
            if(!flag) {
                System.out.println("100以内的质数："+i);
            }
            
        }        
    }
    
    public static void testForFor3() {
        label:for(int i=2;i<=100;i++) {
            for(int j=2;j<i;j++) {//普通算法  高级算法：for(int j=2;j<=Mth.sqrt(i);j++);
                if(i % j == 0 ) {
                    continue label;
                }
            }
                System.out.println("100以内的质数："+i);
            
        }        
    }