JAVA在IDEA当中的快捷键

一、注释

• 1、单行注释（ctrl+/ ）
• 2、多行注释（ctrl+shift+/）
• 3、方法或者类说明注释（/**+ENTER）

这种注释比较专业，该注释信息会被javadoc.exe工具解析提取并且生成帮助文档。

二、定义方法

1、定义一个公开的定义的主方法：使用快捷键：PSVM

2、JAV输出快捷键：PSVM

3、输出：“Hello World!”

public class Day1 { //表示定义一个公开的类，名字为Day1
    /*
    * public表示公开的
    * static表示静态的
    * void表示空
    * main表示方法名是main
    * String[] args：是一个main方法的形式参数列表
    * */

    //以下方法是一个程序的“主方法”，是程序的执行入口
    public static void main(String[] args) { //表示定义一个公开的静态主方法

        //向控制台输出消息
        System.out.println("Hello World!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

4、print和println的区别

• print：输出之后换行
• println：输出之后不换行

三、public class与class的区别

• 一个Java源文件中可以定义多个class
• 一个Java源文件中public的class不是必须的
• 一个class会定义生成一个XXX.class的字节码文件
• 一个java源文件当中定义公开的类的话，只能有一个，并且该类必须和java源文件名称一致
• 每一个class当中都可以编写main方法，都可以设定程序的入口

四、标识符

1、什么是标识符

• 在java源程序当中，凡是程序员有权自己命名的单词都是标识符
• 标识符可以标识的元素有：
  • 类名
  • 方法名
  • 变量名
  • 接口名
  • 常量名

2、标识符的命名规则

• 一个合法的标识符只能由 数字，字母，下划线_，美元符号$ 组成
• 不能以数字开头
• 严格区分大小写
• 不能使用关键字作为标识符
• 理论上面无长度限制

3、标识符的命名规范

• 最好见名知意
• 遵守驼峰命名方式
  • UserService
• 类名，接口名：首字母大写，后面每个单词首字母大写
• 变量名，方法名：首字母小写，后面每个单词首字母大写
• 常量名：全部大写

五、关键字

• 关键字指在语言当中有特殊含义的单词，这些单词构成了java程序的骨架
• 关键字在java语言当中全部小写
• 常见关键字有：class import extends package…

六、字面值（常量）

• 字面值就是数据，是java源程序的组成部分
• 10,100：整数型字面值
• 3.14：浮点型字面值
• " abc "：字符串型字面值
• ’ A '：字符型字面值
• TRUE FALSE：布尔型字面值

注意：

• java当中所有字符串型字面值必须使用双引号括起来
• java当中所有字符型字面值必须使用单引号括起来

七、变量

1、什么是变量

• 变量本质是内存的一块空间，有“数据类型”，“名字”，“字面值”
• 变量是内存中存储数据最基本的单元

2、数据类型的作用

• 不同的数据有不同的类型，会分配不同的大小的空间
• 数据类型是指导程序在运行阶段应该分配多大的内存空间

1、变量声明后赋值

语法格式：变量名=字面值

要求：变量的数据类型和值的数据类型必须一致

2、变量赋值之后可以重新赋值，变量的值可以变化

    //表示定义一个公开的静态主方法
    public static void main(String[] args) {
        //声明一个int类型的变量，起名为i
        int i;

        //编译报错：变量i并没有初始化
        System.out.println(i);

        //给i变量赋值，i变量在这里完成初始化，内存开辟
        i=100;
        System.out.println(i);

        //i再次重新赋值
        i=200;
        System.out.println(i);

        //一行上面可以同时声明多个变量
        //此时a,b尚未初始化，c赋值300
        int a,b,c=300;

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3、变量应该先声明之后访问，因为java的程序是依次执行的

以下程序错误的原因在于i内存没有开辟就访问

4、在同一个“作用域当中”，变量名不能重名，但是变量可以重新赋值

2、变量的分类

根据变量声明的位置来分类：

• 局部变量：在方法体当中声明的变量
• 成员变量：在方法体外【类体之内】声明的变量
• 类体中不能直接编写java语句【除了声明变量之外】
• java遵循就近原则，即如果成员变量名和局部变量名相同的情况下，就选择局部变量名

public class Day1 {

    int k=200;//成员变量
    
    //主方法：入口
    public static void main(String[] args) {

      int i=10;//i变量就是局部变量
    }
    
    int i=100;//成员变量

    //doSome方法
    public static  void doSome(){
        
        int i=10;//i变量就是局部变量
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 在不同的作用域当中，变量名是可以相同的
• 在同一个作用域当中，变量名不能重名

八、作用域

• 变量的作用域

只要记住一句话：出了大括号就不认识了

public class Day1 {
    public static void main(String[] args) {
        //变量i的作用域是main方法
        //在整个卖你方法当中是有效的，可见的，可以访问的
        int i=10;
    }
    
    public static  void doSome(){
        //这里无法访问main方法当中的变量i
        //已经出了i变量的作用域
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

下面的代码报错：因为a的作用域是在for循环的内部

 public static void main(String[] args) {

       for(int a=0;a<10;a++){

       }
        System.out.println(a);
    }
1
2
3
4
5
6
7

下面的代码不报错：因为a的作用域是在main方法当中

九、数据类型

1、数据类型的作用：指导JVM在运行程序的时候给该数据分配多大的内存空间

2、java中的数据类型包括两种：

• 基本数据类型
• 引用数据类型

1、基本数据类型

• 第一类：整数型 byte，short，int，long
• 第二类：浮点型 float，double
• 第三类：布尔型 boolean
• 第四类：字符型 char

1.1 整数类型

• JAVA当中“整数型字面值”被默认当做int型来处理。要让这个整数型被当做“long”来处理的话，需要在“整数型字面值”后面添加1/L，建议使用大写的L
• JAVA语言当中的整数型字面值有三种表示方式：
  • 第一种： 十进制【一种缺省的默认方式】
  • 第二种： 八进制【在编写八进制整数型字面值的时候需要以0开始】
  • 第三种： 十六进制【在编写十六进制整数型字面值的时候需要以0x开始】

    public static void main(String[] args) {
        int a=10;
        int b=010; //八进制：输出8
        int c=0x10; //十六进制：输出16
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
1
2
3
4
5
6
7
8

1.2 浮点类型（小数）

在java语言当中，所有的浮点型字面值【3.0】，默认被当做double类型来处理，要想该字面值当做float类型来处理，需要在字面值后面添加F/f

 public static void main(String[] args) {

        //3.0是double类型的字面值
        //d是double类型的变量
        //不存在类型转换
        double d=3.0;
        System.out.println(d);

        //5.1是double类型的字面值
        //f是float类型的变量
        //大容量转换成小容量需要加强制类型转换符，所以以下程序编译报错
        float f=5.1;//报错
        
        //解决方案：
        //第一种方式：强制类型转换
        float f=(float) 5.1;
        
        //第二种方式：没有类型转换
        float f=5.15f;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.3 字符类型

 public static void main(String[] args) {

        //定义一个char类型的变量
        char c='a';
        System.out.println(c);

        //一个中文占用两个字节，char类型正好是两个字节
        //所以java中的char类型可以存储一个中文字符  
        char x='国';
        System.out.println(x);
    }
1
2
3
4
5
6
7
8
9
10
11

1.4 布尔类型

• 在JAVA当中boolean类型只有两个值：TRUE和FALSE，没有其他值。不像C语言当中，0和1可以表示真假
• 布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中

    public static void main(String[] args) {
        
        //编译错误：不兼容类型
        boolean flag=1;//报错
        
        boolean loginSuccess=true;
        
        //if语句【条件控制语句】
        if(loginSuccess){
            System.out.println("登录成功");
        }else{
            System.out.println("登录失败");
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

注：字符串 属于引用数据类型

2、引用数据类型

3、转义字符

    public static void main(String[] args) {

        //下面按照语法，应该是两个字符，即不能使用单引号括起来，因为是一个字符串
        //但是编译能够正常通过，说明不是一个字符串，而是一个字符
        //这是一个换行符，属于char类型的数据
        char c='\n';
        System.out.println(c);
    }
1
2
3
4
5
6
7
8

• 要求在控制台上输出“反斜杠字符”：

报错：

    public static void main(String[] args) {
        
        //报错：因为反斜杠将后面的单引号转义成不具备特殊含义的普通单引号字符
        //左边的单引号缺少了结束的单引号字符，编译报错
        char c='\';
        System.out.println(c);
    }
1
2
3
4
5
6
7

正确写法：

    public static void main(String[] args) {

        //正确写法：第一个反斜杠具有转义功能，将后面的反斜杠转义成为普通的反斜杠字符
        char c='\\';
        System.out.println(c);
    }
1
2
3
4
5
6

• 要求在控制台上输出带双引号的helloworld：

public static void main(String[] args) {

        System.out.println("hello world");
        System.out.println("“hello world”");
        System.out.println("\"hello world\"");
    }
1
2
3
4
5
6

4、自动类型转换机制

    public static void main(String[] args) {

        //456整数型字面值被当做int类型来处理，占用4个字节
        //x变量在声明的时候是long类型，占用8个字节
        //int类型的字面值456赋值给long类型的变量x，存在类型转换
        //int类型转换成long类型
        //int类型是小容量
        //long类型是大容量
        //小容量可以自动转换成大容量，称为自动类型转换机制
        long x=456;
    }
1
2
3
4
5
6
7
8
9
10
11

    public static void main(String[] args) {

        //编译错误：过大的整数
        //2147483648被当做int类型4个字节处理，但是这个字面值超出int类型的范围
        long x=2147483648;
        
        //解决错误
        //2147483648字面值一上来就当做long类型来处理，在字面值后面添加L
        //2147483648L是8个字节的long类型
        //z是long类型的变量，以下程序不需要类型转换
        long z=2147483648L;
        System.out.println(z);
      
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

5、强制类型转换

    public static void main(String[] args) {

        //100L是long类型的字面值
        //x是long类型变量
        //不存在类型转换，直接赋值
        long x=100L;

        //x变量是long类型，8个字节
        //y变量是int类型，4个字节
        //以下程序编译报错，因为大容量不能直接赋值给小容量
        int y=x;

        //大容量转换成小容量，需要进行强制类型转换
        //强制类型转换需要加“强制类型转换符”
        //加上强制类型转换符之后编译通过了，但是运行阶段可能损失精度

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

    public static void main(String[] args) {

        //以下程序可以编译通过
        //因为在java语言当中，当一个整数型字面值没有超出byte类型的取值范围的话，
        // 该字面值可以直接赋值给byte类型的变量
        byte b=50;//可以
        byte c=127;//可以
        byte b1=128;//不可以，超出范围

    }
1
2
3
4
5
6
7
8
9
10

十、类型转换

• 八种基本数据类型除了布尔类型之外剩下的7种类型之间都可以相互转换

• 小容量向大容量转换，称为自动类型转换，容量从小到大排序为：

• byte < short ( char )< int < long < float < double

• 注：任何浮点类型不管占用多少字节，都比整数型容量大

• char和short可以表示的种类数量相同，但是char可以取更大的正整数

• char=97; 存在类型转换

• 当整数字面值没有超出byte，short，char的取值范围，可以直接赋值给byte，short，char类型的变量

• byte，short，char混合运算的时候，各自先转换成int类型，再做运算

• 多种数据类型混合运算，先转换成容量最大的那种类型再做运算

关于javac当中语法是否报错问题：

        //可以编译通过，3没有超出byte的取值范围
        byte b1=3;
        
        //编译报错，因为编译器只检查语法，不会运算i/3
        int i=10;
        byte b2=i/3;

		//报错，因为编译器只检查语法，不进行运算，i+j是int类型
        short i=10;
        byte j=5;
        short k=i+j;
1
2
3
4
5
6
7
8
9
10
11

区分好编译器与运行期，编译器只考虑语法，而不会进行运算。只有到了运行期，才会做运算。

		//出现错误，1000超出了byte范围
        //byte a=1000;

        //正确，因为20没有超出byte的范围
        byte a=20;

        //错误，因为变量在一个作用域当中不能重名
        //short a=1000;

        //正确，因为1000没有超过short的范围
        short b=1000;

        //正确，因为默认就是int类型，并且没有超出范围
        int c=1000;

        //正确，因为可以自动类型转换
        long d=c;

        //错误，出现精度丢失（大类型转换成小类型会出现问题）
        //int e=d;

        //正确，将long类型强转成int类型
        int e=(int)d;

        //正确，因为10/3的结果为int类型,(两个int类型做算术运算的结果仍然是int类型)
        int f=10/3; //结果是3，而非3.33333

        double ff=10/3;//结果是3,但由于发生自动类型转换，因此结果未3.0

        double fff=10.0/3;//结果是3.333333335，因为此时会把除数3先转换成double类型，即变成10.0/3.0相除

        //正确，发生自动类型转换
        long g=10;

        //报错，因为g先转换成int类型，然后再转换成byte类型，但是由于除数3是int类型
        // 因此最终的结果仍然是int类型，而int类型不能直接复制给byte，因此语法报错
        //编译器只负责语法，不进行运算。JVM才涉及运算，而javac只负责语法检查。
        //byte h=(byte)(int)g/3;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38