core java--day3（操作符，拼接，运算符，for循环小实例）

复习：

double a = 0.0/0.0; //NaN :非数值，其他类型分母为0会报错

\u :表示unicode编码，在注释中写\u也会被识别，java代码可以完全用unicode码编写（\u4e03\u0082......）,一般不会这样做

类：承载一些有关联关系的数据，一组具有相同属性和行为的模板
        lenovo电脑：模板
                             屏幕
                             键盘
                             触摸板
                             内存
                             显卡
                              ......
 
变量的生命周期 : 一个变量被创建并分配内存空间开始，到这个变量被销毁并清除其所占用内存空间的过程
 
        作用范围：
                 变量只能在当前声明的大括号中使用
                 出了大括号就不能使用了
 
 成员变量：
          类中，方法外，
 局部变量：
          代码块中声明的变量，
          方法中声明的变量，
          方法参数中声明的变量，
                   只能在当前方法/代码块中使用
 区别：作用范围不同
            编写位置不同
            成员变量可以在其他类中取值赋值操作，局部变量不可以
            【成员变量会初始化赋值】 jvm自动赋值 int型 默认0；double 0.0 ；boolean false ；char '\u0000'
   

---

操作符：
 赋值操作符：
          变量 = 对应的值；
          +=
          -=
          *=
          /=
  
  a+=b ==》a=a+b;  a+=b :具有强制类型转换功能
  int b = 10;
  short a = 1;
  a+=b;  // a = (a类型) a+b
  
  int b = 10;
  short a =1;
  a = a+b;
  
比较操作符：最终返回boolean类型的值
         > < >= <= == !=
 
 ==:内存地址相同
 基本数据类型：
          值相同，地址就相同
 引用数据类型：
          只要用到new关键字，一定是新建，一定不同
 
  int a = 10;
  int b = 10;
  a==b --> true;

 Student s1 = new Student();
 Student s2 = new Student();
 s1=s2 --> false

 int a =10;
 short b = 10;
 a = b --> true

加：
         + ：左右都是基本数据类型 相加
         + ：左右有一方为字符串 拼接
                  hello world
                  "hello world" + "tom"
                  12 + "tom";  12tom
                  int a = 10;
                  String b = "hello" + a;
         ++:
                  int a = 10;
                  a++;  10
                  ++a;  11
  
/   :  整除 , 操作数均为整数，运算结果为商的整数部分。

%    :  取余操作符，
  
逻辑运算符：
 & 与
          true  &  true --> true
          true & false --> false
          false & true --> false
          false & false --> false
 && 与  短路效果，当&&左边的表达式已经能够确定整个表达式的结果时(即左边为false)，右边的就不执行了
  
 | 或
          true | true --> true
          true | false --> true
          false | true --> true
          false | false --> false
 || 或 短路效果，当&&左边的表达式已经能够确定整个表达式的结果时(即左边为true)，右边的就不执行了
  
！非，取反
          ！true --> false
          !false --> true

位运算符 ：1==true  0==false 
 &  与
          0000
       & 0001
          0000
 | 或
 ^ 非
 << 有符号左移:等价于乘法；但效率是最高的，因为在底层操作
          补0
          int a = 8;
          int b =a<<2;//32
          第一位是符号位，不参与运算
          0 000 0000 0000 0000 0000 0000 0000 1000
          0 0 0000 0000 0000 0000 0000 0000 1000oo（符号位不动，数据往前移动，相当于原显示框后少了两个数据，所以在后面不上两个0，前面有两个0移走了）
  
 >> 有符号右移：等价于除法
          正数补
          负数补1
          12 >>2 =3
           0 000 0000 0000 1100
           0 oo000 0000 0000 11（后面有两个0移走了）
  
           把-12对应的二进制数向右移动一位
              1 111 1111 1111 1111 1111 1111 1111 0100
              1  111 1111 1111 1111 1111 1111 1111 010  有符号移位，-12是负数，所以前面补1
              1 1111 1111 1111 1111 1111 1111 1111 010  -->负数补1
             减一1 1111 1111 1111 1111 1111 1111 1111 001
             取反1 0000 0000 0000 0000 0000 0000 0000 110      -->结果:-6
  
 <<< 无符号左移
 >>> 无符号右移
          全部补0
  
三目运算符：
 （boolean运算符）？（）：（）

if(boolean表达式){}
if(){}else{}
if(){}else if(){}else{}
switch (变量){
 case值：{}
 case值：{}
 default：{}
}
 当某一个case匹配成功后，其他case都会匹配成功，所以要用break跳出
 
 switch表达式后面的数据类型只支持byte,short,char,int四种整形类型、枚举类型和java.lang.String类型。
           其中枚举和String在jdk1.7以后支持
 
 流程解释:
   1,获取expr值
   2,从上到下和case 的 value比较
            如果相同执行当前case下面的代码(可以是多句，多行代码),
             如果没有break,那么接下来所有的case 都会匹配成功(即使case 的value 和 expr不同),然后执行case下的代码。然后执行default
             如果有break,那么switch执行完毕，跳出。
   3,如果所有的case都匹配失败
            执行default中的代码

 
for(初始化部分;循环条件;迭代部分){} 
 初始化部分：int i = 0；
 循环部分：i<10;
 迭代部分：i++
 
 
 
 
??问题：
 

package com.briup.ch2;

public class Puzzle{
	
	public static void main(String[] args){
		
	//	System.out.println(2-1.1);
		long micros_per_day = 24*60*60*1000*1000;	
		long millis_per_day = 24*60*60*1000;
		System.out.println(micros_per_day/millis_per_day);
		float a = (float) 1.1;

		System.out.println(2- a);
		System.out.println(2.0 - a);
		System.out.println(2.0 - 1.1);
		System.out.println(1.0-0.1);
		}
	}

 

结果： 
5
0.9
0.8999999761581421
0.8999999999999999
0.9

*
**
***
****
*****

分析： 共有5行，所以最外层要遍历5次（可以将最外层的for想成对行号的赋值），且每一行都需要换行，所以把println写在最外层for里。
                     每一行的*都与行号相等，所以第二层的for循环变量肯定会用到第一层的for循环变量
第一行
System.out.print("*");
System.out.println();

第二行
System.out.print("*");
System.out.print("*");
System.out.println();

第三行
System.out.print("*");
System.out.print("*");
System.out.print("*");
System.out.println();

步骤：
1. for(
){}

实现：
for(int i = 1;i <=5;i++){
 for(int j = 1;j < =i ;j++){
  System.out.print("*");
 }
 
 System.out.println();
}

    *
   **
  ***
 ****
*****

分析：

第一行:
 syso(" ")
 syso(" ")
 syso(" ")
 syso(" ")
 syso("*")
 sysoln();
第二行:
 syso(" ")
 syso(" ")
 syso(" ")
 syso("*")
 syso("*")
 sysoln();
第三行:
 syso(" ")
 syso(" ")
 syso("*")
 syso("*")
 syso("*")
 sysoln();
 
 实现：
 
for(int i = 1;i<=5;i++){
 for(int z = 1;z<=5-i;z++){
  System.out.print(" ");
 }
 for(int j = 1;j<=i;j++){
  System.out.print("*");
 }

 System.out.println();
}

九九乘法表：
1*1 =1; 1*2=2;.....
2*1=2;
3*1=3;

for(int i = 1;i<10;i++){
 for(int j =i ;j<10;j++ ){
  System.out.print(i+"*"+j+"="+i*j+"  ");
 }
 
}