IDEA基本功能，数据类型扩展类型转换

熟悉IDEA基本功能

原文地址:

1.格式化代码:Ctrl+Alt+L

2.重命名变量：光标停留在变量上，Shift+F6

3.打开文件或者项目所在目录: 右键》Show in Explorer

4.添加包围代码块的快捷键：Ctrl+Alt+T， VS中对应的为Ctrl+K, S, 可以快速给代码添加if, try catch, region, editor-fold等包围代码块

            //region Description
            int a;
            //endregion
            //
            int a;
            //

5.折叠和展开代码

默认if, while, do等代码块不可以折叠，选中后Ctrl+., 被选中代码变得可折叠，光标在任意位置，次按下Ctrl+.,这段代码变得不可折叠

Ctrl+Shift+.会使得光标位置所在代码块变得可折叠

Ctrl+B/Ctrl+Click，快速打开光标处的类或方法（跳转到定义处）

Ctrl + Alt + <--- 代码位置后退(win10下和显卡快捷键冲突，看这里https://blog.csdn.net/u010814849/article/details/76682701/)

Ctrl + Alt + --> 代码位置前进(win10下和显卡快捷键冲突，看这里https://blog.csdn.net/u010814849/article/details/76682701/)

6.显示方法大纲（方法列表）的两种方法：

View-->Tool Windows-->Structure（Alt+7) 停靠型窗口

Ctrl+F12 弹出型窗口

7.Alt+Enter:导入包

8.快速实现接口方法的快捷键： Ctrl+i

9.快速重写基类方法：Ctrl+O

10.自动生成getter setter：Alt+Insert

11.类的包名和类文件路径不一致的时个，通过ALT+ENTER来修正

12.注释代码

[1]行注释Ctrl+/
首先你的光标要处于这一行，处于这行的哪个位置都可以,按Ctrl+/，就可以往行首添加"//"，将该行注释掉。

再次按Ctrl+/，可以去掉该行注释。

[2]块注释Ctrl+Shift+/
使用块注释需要先选中要注释的块。

按Ctrl+Shift+/注释掉该块代码

去除注释的时候，不需要全部选中这块代码，只用光标在注释内容上按Ctrl+Shift+/即可。

[3]方法或类注释
在一个方法或类的开头，输入/**，然后按回车,自动根据参数和返回值生成注释模板，我们在这个模板上面编写即可。

13.压缩中间包

在包目录中，如果多级包中存在空目录，则会收缩成aaa.bbb.ccc的形式

在某些情况下，需要显示这些目录真实的层级关系，点击设置按钮，选中或者不选Compact Middle Packages选项，就可以在两种显示形式之间进行切换

如下图所示

数据类型扩展

1. 整数拓展

• 进制 ：二进制 （0b开头） 十进制 八进制（0开头）十六进制（0x开头）

public classs Demo01 {
public static void mian(String[] args){
int i = 10;
int i2 = 010; //八进制0
int i3 = 0x10; //十六进制0x 0~9 A~F
System.out.println(i);
System.out.println(i2);
System.out.println(i3);
}
}
```

2. 浮点数拓展

• 银行业务怎么表示？

  BigDecimal 数学工具类

• float 有限 离散 舍入误差 大约 接近但不等于

• double

• 最好完全使用浮点数进行比较

3. 字符拓展

• 所有的字符本质还是数字
• 编码 Unicode 2字节 a=97，A=65
• U0000 UFFFF（char c3 = '\u0061';）
• 转义字符 \t(制表符) \n(换行)...
• 对象 从内存分析

public classs Demo01 {
    public static void mian(String[] args){
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);  //强制类型转换
        System.out.println(c2);
        System.out.println((int)c2);  //强制类型转换
    }
}

4. 布尔值拓展

• 代码要精简

public classs Demo01 {
    public static void mian(String[] args){
   boolean  falg = true;
        if (flag==true){}  //新手
        if (flag){}   //老手
    }
}

类型转换

1. 由于Java是强类型语言，所以要进行有些运算的时候，需要用到类型转换

? byte

2. 运算中，不同类型的数据先转化为同一类型，然后进行运算

3. 强制类型转换

   （类型）变量名 高->低

   public classs Demo02 {
       public static void mian(String[] args){
           int i = 128;
           byte b = (byte)i;//内存溢出
           System.out.println(i);
           System.out.println(b);
       }
   }
   

4. 自动类型转换

   （类型）变量名 低->高

   public classs Demo02 {
       public static void mian(String[] args){
           int i = 128;
           double b = i;
           System.out.println(i);
           System.out.println(b);
       }
   }
   

   • 不能对布尔值进行转换

   • 不能把对象类型转换为不相干的类型

   • 在把高容量转换到低容量的时候，强制转换

   • 转换的时候可能存在内存溢出，或者精度问题

     public classs Demo02 {
         public static void mian(String[] args){
             System.out.println((int)23.7); //23
             System.out.println((int)-45.89f);  //-45
             System.out.println("-------------"); 
             char c = 'a';
             int d = c+1;
             System.out.println(d);  //98
             System.out.println((char)d);  //b
         }
     }
     

5. 注意事项

   • 操作比较大的数的时候，注意溢出问题

   • JDK7新特性，数字之间可以用下划线分割

     public class Damo02{
         public static void main(String[] args){
             int money = 10_0000_0000
                 int years = 20;
             int total = money*years;  //-1474836480,计算的时候溢出了
             long total2 = money*years; //默认是int，转换之前就已经存在问题了
              System.out.println(total1);
             System.out.println(total2);
             long total3 = money*((long)years); //先把一个数转换为long，
             System.out.println(total3);
         }
     }
     

变量

1. 变量就是可以变化的量

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

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

4. 注意事项

   • 每个变量都有类型，类型可以是基本类型，也可以是引用类型

   • 变量名必须是合法的标识符

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

     public class Demo03{
         public static void main(String[] args){
          // int a,b,c  
          // int a=1,b=2,c=3;  (不建议，程序可读性)
             String name = "study";
             char x = 'x';
             double pi = 3.14;
         }
     }
     

5. 变量作用域

   • 类变量

   • 实例变量

   • 局部变量

     public class Demo04{
         //类变量 static   从属于类
         static double money = 2500;
         
         //属性；变量
         
         //实例变量；从属于对象；如果不进行初始化值，这个类型的默认值   0  0.0  
         //布尔值默认false
         //除了基本类型，其余的默认值都为null
         String name;
         int age;
         
         //main方法
         public static void main(String[] args){
             
             //局部变量；必须声明和初始化值
             int i = 10;
             System.out,println(i);  //输出：10
             
             //变量类型  变量名字 = new Demo04();
             Demo04 demo04 = new Demo04();
             System.oout.println("demo04.age");  //输出：0
             System.oout.println("demo04.name");   //输出：null
             
             //类变量 static
             System.out.println(money);
         }
         
         //其他方法
         public void add(){
             
         }
     }
     

6. 命名规范

   • 所有变量、方法名、类名：见名知意
   • 类成员变量首字母小写和驼峰原则：lastName 除了第一个单词以外，后面的单词首字母大写
   • 局部变量：首字母小写和驼峰原则
   • 类名：首字母大写和驼峰原则 Student GoodStudent
   • 方法名：首字母小写和驼峰原则 run ，runRun
   • 常量：大写字母和下划线 MAX_VALUE

常量

1. 常量就是初始化后不能再改变值，不会变动的值

2. 常量可以理解为一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变

      public class Demo05{
         static final double PI = 3.14;
           //final常量名=值
           //final double pi = 3.14
           //修饰符，不存在前后顺序
          public static void main(String[] args){
            d System.out.println(PI);
          }
      }
   

3. 常量名一般用大写字母