CoreJava学习第二课

CoreJava学习第二课

一:编程习惯(很重要!!!提高程序可读性)

1.注释(描述代码的文字)

1.单行注释    //注释内容

2.多行注释    /* 多行注释,
​                可以跨越多行 注意:多行注释不能嵌套
​             */

3.文档注释   /**
               配合javadoc工具使用
​            */

2.缩进

· 同级代码左对齐,每行一句代码
· 每进入一个代码块{},缩进一次

3.标识符(程序员为程序组件起的名字)

语法: 
1) 字母 数字 下划线 货币符号 数字不能开头 
2) 不能使用关键字和保留字 (goto const) true false null 
3) 大小写敏感 
4) 没有长度限制

4.命名规范:【很重要】

​ ① 望文生义
​ ② 大小写
​ 包名:全小写 com.cps.corejava.day01
​ 类名:所有单词首字母大写 HelloWorld
​ 变量名|函数名: 首单词小写,其它单词首字母大写 printStar
​ 常量名:所有单词大写,单词之间使用_连接 HELLO_WORLD

二:进制转换

1.字节(1 Byte = 8 bit)

计算机把8个二进制位固定在一起,称为一个字节

1Byte最多存8位:_ _ _ _ _ _ _ _ 128+64+32+16+8+4+2+1=255

2Byte最多存16位:_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 65535

2.进制转换

   十进制转二进制
   90
   45   0
   22   1
   11   0
    5   1
    2   1
    1   0
    0   1   结果是: 1011010
​
   小数是乘以2运算:从上往下
   0.2
   0.4  0
   0.8  0
   1.6  1
   1.2  1
   0.4  0
   0.8  0
   1.6  1
   1.2  1      90.2  = 1011010.001100110011001100110011...
   因为0.2转二进制后会出现无限循环,所以十进制90.2转二进制,最后可能会出现精度丢失 

三:变量

int a  = 10;
int是变量类型,a是变量名称,10就是变量

1.变量

 基本的数据存储单元

2.变量类型

 决定计算机要提供多大的内存空间(byte short int ...提供的最大存储量不一样)


3.强类型和弱类型约束

​ 为了提高计算机内存的使用效率,引入强类型约束:

​ 强类型:变量的类型和数据的类型必须一致

​ 弱类型:定义变量不用指定变量类型,例如:JavaScript中 的var

注:
var a = 10;在JDK10之后就是对的,因为编译器会自动推断a的字面值是10,10是int类型。
如果再写a = 2.5;就会报错,因已经认定a是int类型

四:数据类型(2种:基本数据类型,对象数据类型)

一.1 基本(原始/简单)数据类型(1-4,共8种)

​ 1.byte 1B -128 - 127
   1B 8 位 _ _ _ _ _ _ _ _ 第一个是符号位,0正1负​ 
 2.short 2B -32768 - 32767 
 3.int 4B -2147483648 - 2147483647 
 4.long 8B -9223372036854775808 - 9223372036854775807 字面值加l或L

一.2 基本数据类型(5-8,共8种)

  float double (默认)
精度 单精度浮点数 双精度浮点数
分配的内存空间 4B 8B
字面值 加 F 或 f 加 D 或 d 或不加
举例:
float f = 1.3;
这样写是错的,因为1.3的字面值是double,编译器会尝试把double降级为float,但是会丢失精度,所以编译器会报错。

1.补充:面试题

System.out.println(2.0-1.1);//结果是0.8999999999999999
因为计算机在存1.1时,需要把1.1转成二进制,此时0.1在转二进制时会丢失精度,所以计算结果就不是0.9 。
System.out.println(2.0F-1.1F);//结果是0.9
此问题涉及到 java虚拟机字节码指令。在java虚拟机底层中,2.0-1.1会被当成double做运算,结果是0.8999999999999999,但结果是一个float类型,此时虚拟机会四舍五入,“凑巧”变成了0.9 。 
​
    看下面两个就和上面的不一样了。
    System.out.println(2.0-1.2);//0.8
    System.out.println(2.0F-1.2F);//0.79999995

2.补充:浮点数在内存中如何表示?

  float double (默认)
分配的内存空间 4B 8B
在内存中表示 ? 第1个是符号位,指数位8,尾数位23 第1个是符号位,指数位11,尾数位52
字面值 加 F 或 f 加 D 或 d 或不加
举例表示:1.3*10^10 1.3e10F (对) ,1.3eF10(错) 1.3e10
精度 尾数位加上小数点前的1,共24位 尾数位加上小数点前的1,共53位
float和double可以用科学计数法表示: a(尾数) *2^ b(指数)

计算机中规定,浮点数在内存中采用科学计数法保存时,小数点前必须是1.例如:
0.1011011 写成 1.011011 指数位写-1
3.char

char 存字符,分配2B的内存空间,所以表示数据范围:0-65535   
     1.字面值表示:  1.用单引号引起来'A'   
                 2. 直接写char = 65
                 3.'\u0041'    \u 表示是全球统一的Unicode编码,这是十六进制编码(十六进制编码两位是                              1B,char是2B,所以用十六进制编码表示char是4位),所以65用十六进制                                表示是0041  
     2.Unicode编码 全球统一                
        'A' ---> 65  编码 ; 65 ---> 'A' 解码    
     3.记住三个
        'A' : 65    'a':97     '0':48   
转义字符: 
          \'  输出 ' 
          \"  输出 "
          \\  输出 \
          '\n'  换行       ASCII值为10
         '\t' Tab键功能    ASCII值为9
使用:
        int n = 358;
        System.out.println(n%10+"\t"+(n/10%10)+"\t"+(n/100)%10);// 8    5   3
        System.out.println(n%10+'\t'+(n/10%10)+'\t'+(n/100)%10);//34  没用双引号时,

 

4.boolean类型

字面值 : true  false
运算符: 布尔表达式
              ==   !=   >   <   >=   <=   
            ! 逻辑非
             短路运算符: && 逻辑与,|| 逻辑或  
  
            非短路运算符:& 位运算与,| 位运算或 
              
              三元运算符 ?运算符      (布尔表达式)?值1 : 值2      (a%2==0)?"偶数":"奇数"    
        举例:短路运算符在判断(a>b)&& (c

 补充一个面试题:

面试题:
boolean类型在内存中的存储空间可以是1位/1B/4B ?
    1.在逻辑层面,只需1位即可存储布尔值
    2.在内存分配空间时,都是1字节1字节分配的,这样就浪费了7位空间。
    3.在虚拟机的字节码指令中,没有专门布尔类型的数据,所以布尔类型会转化成int类型处理,占4B空间。
1.计算机用二进制运算(原码,反码,补码)

  二进制表示:
    5:   00000101
  求-5的二进制补码表示:是把5的原码,按位求反再加1
    原码      0000 0101
    按位求反   1111 1010
    加1       1111 1011
 -5:   11111011   
 
 计算机的CPU只会做加法运算,所以12-5变成12+(-5)
  00001100   12
  11111011   -5
  00000111   7 
​
  01111111    表示 127
  10000000    表示 -128          
  11111111    表示 -1
  00000000    表示 0  
2.字面值(“=”后面的就是字面值)

 字面值:    int a = 10;     int a = 010;     int a = 0x10     int a = 0b10
                 十进制       八进制          十六进制         二进制 (since JDK1.7)

二进制         十进制                             十六进制
1010 0101    =  2^7+2^5+2^2+2^0 = 128+32+4+1   165 = A5      十六进制中2位表示一个字节
简单一点
1010=A   0101=5
3.表达式和运算符

表达式: 具有特定的值 如:a+b

运算符:  + - * /  % = 赋值运算符
         += -= *= /= %=  ++ --
11/2 = 5        4/5 = 0       11%2 =1   4%5 = 4
两个变量做运算,储存结果的数据类型由这两个变量的字面值决定。
例如:short和byte做运算,因short和byte没有默认值int大,储存结果的默认是int
long和int做运算,因long比默认值int大,储存结果是long
a+=2;和a=a+2;有区别:
byte a = 1; 
    a+=2;结果还是byte类型;
    a=a+2;因2默认是int类型,所以a+2结果也是int类型,把一个int类型存到byte里会出错。
4.位运算

&按位与   |按位或   ^按位异或     ~按位反     
<<左移    相当于*2 
>> 右移   相当于/2   高位补符号位
>>>无符号右移        高位补0    
&按位与(同1才为1)
System.out.println(10&23); //2
        /* 00 0    01 0   10 0   11 1
            00001010    10
            00010111    23
            00000010    2
        */
|按位或(有1就为1)
System.out.println(10|23); //31
        /*规则:  00  0    01  1    10  1  11 1
            00001010    10         
            00010111    23
            00011111    31
        */
^按位异或(01或10为1)      
System.out.println(10^23); //29
        /*
            00001010           00  0    01  1    10  1  11 0
            00010111
            00011101
        */
~按位反 
System.out.println(~10);   //-11
        /*
            00001010
            11110101   -11
        */
​
int a = 10;
<<左移    相当于*2       
System.out.println(a<<1);//左移1位,最左边的舍弃,最右边补0
        /*
           00001010   10
           00010100   20 
           
           11110110   -10
           11101100   -20          
           */
>> 右移   相当于/2   高位补符号位      
System.out.println(a>>1); //右移1位,最右边的舍弃,高位补符号位
        /*
           11110110  -10
           11111011  -5
           
        */
>>>无符号右移        高位补0
System.out.println(a>>>1); //2147483643
        /*
           11111111 11111111 11111111 11110110  -10
           01111111 11111111 11111111 11111011  2147483643     
        */

 

5.补充:

①交换a,b的值的三种方式
 a b 交换值:
         1.  c = a    a = b     b = c
         2.  a = a^b  b = a^b   a = a^b
         3.  a = a+b  b = a-b   a = a-b
                
           a2=a^b
           b2=a2^b=a^b^b = b^b^a = 0^a = a
           a3 = a2^b2 = a^b^a = a^a^b = 0^b = b
           
           a2 = a+b
           b2 = a2-b=a+b-b=a
           a3 = a2-b2 = a+b-a = b  
②面试题(异或)

异或用于加密:(最原始的加密方式)
    加密:把原文件的所有字节和某一个数(这个数叫做秘钥)做异或,这样原文件的数据就会改变。
    解密:再把原文件和秘钥做异或,即可解密。

6.自动类型提升和类型转换
    自动类型提升:当小类型变量赋值给大类型变量时,会自动提升类型。
    		   a+b
          1. 如果a和b中有double        ===> 结果值自动提升为double
          2. 否则, 如果a和b中有float   ===> float
          3. 否则, 如果a和b中有long    ===> long
          4. 否则                      ===> int
    
    强制类型转换/类型间赋值原则: 如果可能改变数据,则需要进行强制类型转换。
        整数间强转,会舍去多余的高位字节。
        浮点数强转整数,会把小数点后的直接抹去。
    
    public class TestCast{
    	public static void main(String[] args){
    		byte b = 1;
    		short s = 1;
    		int i = 1;
    		long l = 1L;
    		float f = 1.0F;
    		double d = 1.0;
    		char c = 'A';
    		
    		s = b;
    		i = s;
    		l = i;
    		d = f;
    		i = c;
    		
    		s = 128;   // 00000000 10000000
    		b = (byte)s ; // 10000000,大类型变量转小类型变量,直接把高位去掉。
    		System.out.println(b);//-128 类型间赋值可能会改变数据。
    		
    		f = (float)d ;
    		i = (int)f;
    		
    		s = (short)c;  // c = 40000
    		
    		f = l ; 
    	}
    }

posted @ 2018-10-11 15:56 ChenPS 阅读( ...) 评论( ...) 编辑 收藏

你可能感兴趣的:(CoreJava学习第二课)