【116天】尚学堂高琪Java300集视频精华笔记（9-12）

第9集：char、字符串入门、boolean

char、字符串入门

1. 单引号用来表示字符常量。例如‘A’是一个字符，它与“A”是不同的，“A”表示含有一个字符的字符串。

2. char 类型用来表示在Unicode编码表中的字符。

3. Unicode编码被设计用来处理各种语言的所有文字，它占2个字节，可允许有65536个字符；ASCII码占1个字节，可允许有128个字符，是Unicode编码表中前128个字符。

   char eChar = 'a'; 
   char cChar ='中'; 

4. Unicode具有从0到65535之间的编码，他们通常用从’u0000’到’uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）

       char c = '\u0061';

5. Java 语言中还允许使用转义字符 ‘’ 来将其后的字符转变为其它的含义。

   char c2 = '\n';  //代表换行符 

boolean

if ( is == true && done == false ) 只有新手才那么写。
对于任何程序员if ( whether && !done )都不难理解吧。所以去掉所有的==fasle 和 ==true。

package test009;

public class test009 {
    public static void main(String[] args){
        /*
        char c1 = 'a';
        char c3 = '是';
        char c2 = '\n';
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        */
        
        char c4 = 'a';
        int i = c4 + 2;
        char c5 = (char)i;
        System.out.println(c5);
        
        
        for(int j=0;j<26;j++){
            char temp = (char)(c4+j);
            System.out.println(temp);
        }
        
        String str = "abcdefghijklmnopqrstuvwxyz";
        System.out.println(str);
        
        boolean b = false;
        if(b){
            System.out.print("true");
        }else{
            System.out.println("false");
        }    
    }
}

第10集:基本数据类型自动转换、强制转型、类型提升问题

基本数据类型自动转换

1. 一般规律：表数范围小的数据类型可自动转换为表数范围大的数据类型。

2. 记住下图即可
   

int可以自动转换成float，为啥？主要因为能不能转换看的是表数范围，而不是看占用存储空间多少字节（int存储空间8字节、float存储空间4字节）。

1. 特例：整型常量可直接赋值给byte、short、char等类型变量，不需要进行强制类型转换，只要不超过其表数范围即可。

   //注意1：
   int i = 100;
   char a = 100;//正确，这是将整型常量赋值给a
   char a = i;//错误，这是将整型变量赋值给a
   char a = (char)i;//正确，这是将整型变量强制类型转换。
   
   //注意2：
   short b = 12;//OK
   short b = 12345678;//NO
   

强制转型

1. 强制类型转换，又被称为造型，用于显式的转换一个数值的类型. 在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。

2. 当将一种类型强制转换成另一种类型，而又超出了目标类型的表示范围，就会被截断成为一个完全不同的值。

3. 强制类型转换的语法格式：“(type)var”，运算符“()”中的type表示将值var想要转换成的目标数据类型。

   double x = 3.14;
   int nx = (int)x;//值为3
   char c = 'a';
   int d = c+1;
   System.out.println(d);
   System.out.println((char)d);
   

类型提升问题

1. 所有二元运算符都有类型提升问题(+-*/%)。

2. 提升方向为更大的容器。

   int a=3；
   long b=4；//则a+b之后将变成long。

3. int a=20亿；int b=10；这时候long c = long(a*b)没用，a*b结果出来的时候已经是int型了，应该是long c = (long)a*b，这样的写法是先将a变成long，再提升a*b结果的类型为long。

4. 在结果溢出前提升类型，等计算出来就晚了

   byte a=10
   byte b=10
   byte c=10
   byte d=10
   short e = 10*10*10*10s与
   short e = 10s*10*10*10结果不同
   前者还没提升类型就已经溢出，后者先提升类型再溢出。
   
   //下面是本集代码
   
   package test010;
   
   public class test010 {
       public static void main(String[] args){
           /*
           byte b = 123;
           //byte b2 = 300;//超过表数范围
           //char c = -3;//超过表数范围
           char c2 = 'a';
           int i = c2;
           long d01 = 123213;
           float f = d01;
           */
           
           //测试强制转换
           int i2 = -100;
           char c3 = (char)i2;
           System.out.println(c3);//超过表数范围，所以转换为完全不同的值，无意义的值
           
           //类型提升问题
           int a = 3;
           long b = 4;
           double d = 5.3;
           int c = (int)(a+b);
           float f = (float)(a+d);
           
           int money = 1000000000;
           int years = 20;
           //long total = money*years;//返回负数
           long total = (long)money*years;
           System.out.println(total);
           
       }
   }
   

第11集：【补充】JDK7特性：二进制整数/下划线分隔符

二进制整数

JDK7提供了二进制整数的类型，只要以0b开头即可。int a = 0b0101;

下划线分隔符

针对特别长的数字，读懂它令人头疼，这时候用下划线分割数字，可增加代码可读性。long a = 2222_2222_2222;

package test011;

public class test011 {
    public static void main(String[] args){
        int a = 0b0000_0000_0000_0000;
        int b = 1_2312_3131;
        System.out.println(a);
        System.out.println(b);
    }
}

第12集：变量、成员变量、局部变量、常量的命名规范

变量（variable）

1. 我们通过变量来操纵存储空间中的数据，变量就是指代这个存储空间！空间位置是确定的，但是里面放置什么值不确定！ 

2. Java是一种强类型语言，每个变量都必须声明其类型。

3. 类型可以是8种基本类型，也可以是引用类型。

4. 变量名必须是合法的标识符。

5. 变量声明是一条完整的语句，因此每一个声明必须以分号结束。

6. Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

7. 变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为：

   type  varName  [=value] [{,varName[=value]}] ；
   //[]代表可选

8. 变量可划分为局部变量、实例变量（成员变量member variable）、静态变量（类变量static variable）

   1. 局部变量(local  variable)：方法或语句块内部定义的变量。生命周期是从声明位置开始到”}”为止。在使用前必须先声明和初始化(赋初值)。

      public void incorrectLocalVariable(){
          int i;
          i = 10;
          int j = i+5;//编译报错，变量i还未被初始化
      }

   2. 实例变量（）:方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

   3.  静态变量（类变量 static variable）：使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。如果不自行初始化，他会自动初始化成该类型的默认初始值（数值型变量初始化成0或0.0，字符型变量的初始化值是16位的0，布尔型默认是false）

变量命名规则(规范)

1. 所有变量、方法、类名：见名知意

2. 类成员变量：首字母小写和驼峰原则  :  monthSalary

3. 局部变量：首字母小写和驼峰原则

4. 常量：大写字母和下划线：MAX_VALUE

5. 类名：首字母大写和驼峰原则:  Man, GoodMan

6. 方法名：首字母小写和驼峰原则: run(), runRun()

package test012;

public class test012_1 {
    public static void main(String[] args){
        boolean flag = true;
        char c1,c2;
        c1 = '\u0041';
        c2 = 'B';
        int x;
        x = 9;
        int y = x;
        float f = 3.15f;
        double d = 3.1415926;
    }
}

package test012;

public class test012_2 {
    public static void main(String[] args){
        final double PI = 3.14;
        //PI = 3.15; //error
        double r = 4;
        double area = PI * r * r;
        double circle = 2 * PI * r;
        System.out.println("area = " + area);
        System.out.println("circle = " + circle);
    }
}