JAVA基础知识

目录

IDEA快捷键

简洁语法

"hello world".sout
结果：
 System.out.println("hello world");
1
2
3

Ctrl+Alt+Shift操作

• Ctrl + D 复制当前行到下一列
• Ctrl + Alt + L 格式化代码，可以对当前文件和整个包目录使用 （必备）
• Ctrl + Y 删除光标所在行 或 删除选中的行 （必备）
• Alt + Shift + 前方向键 移动光标所在行向上移动
• Alt + Shift + 后方向键 移动光标所在行向下移动
• Ctrl + Shift + / 代码块注释 （必备）

更多内容：快捷键大全

其他常用操作

重点：手把手教你IDEA中模块的导入和删除

JAVA基础知识

注释

注释是对程序语言的说明，有助于开发者和用户之间的交流，方便理解程序。注释不是编程语句，因此被编译器忽略。

• 单行注释
  

• 多行注释
  

• 文档注释
  

字面量

软件在处理数据之前要能够表示数据。在Java中，数据被称为“字面量”

举例如下图：

    public static void main(String[] args) {
        //1.0整数
        System.out.println("66");
        System.out.println("-23");
        //2.0小数
        System.out.println("0.1");
        //3.0字符
        System.out.println('\n');//换行
        System.out.println('\t');//空格
        System.out.println('a');
        //4.0字符串
        System.out.println("");
        System.out.println("我爱你中国");
        System.out.println("string");
        //5.0bool类型
        System.out.println(true);
        System.out.println(false);
        //6.0空值(NULL)
        
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

变量

变量是存储数据值的容器。
在 Java 中，有不同类型的变量，例如：
String- 存储文本，例如“hello”。字符串值用双引号括起来
int - 存储整数（整数），不带小数，例如 123 或 -123
float - 存储带小数的浮点数，例如 19.99 或 -19.99
char- 存储单个字符，例如 ‘a’ 或 ‘B’。Char 值用单引号括起来
boolean - 存储具有两种状态的值：真或假

• 变量定义的格式

数据类型 变量名称=初始值;
例如：
int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'
1
2
3
4
5
6
7
8

数据类型

基本数据类型（8个），也称原始数据类型：

关键字

Java中的关键字有哪些？

1）48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。

2）2个保留字（现在没用以后可能用到作为关键字）：goto、const。

3）3个特殊直接量：true、false、null。 
1
2
3
4
5

更多内容：Java中53个关键字的意义及使用方法

标识符

类型转换

自动类型转换

类型范围小的变量，可以直接赋值给类型范围大的变量。

例如：

byte a=1;
int b=a;//此时发生自动类型转换
1
2

其他形式：

byte->short->int/char->long->float->double

表达式的自动类型转换

在表达式中，小范围类型的变量会自动转换成当前较大范围的类型再运算。

具体形式：

byte、short、char->int->long->float->double
1

注意事项:

• 表达式的最终结果类型由表达式中的最高类型决定。
• 在表达式中，byte、short、char是直接转换成int类型参与运算的。

强制类型转换

可以强行将类型范围大的变量、数据赋值给类型范围小的变量。

语法格式：

数据类型 变量2 = (数据类型)变量1、数据
1

例如：

int a=12;
byte b=(byte) a; 
1
2

注意事项：

• 强制类型转换可能造成数据(丢失)溢出;
• 浮点型强转成整型，直接丢掉小数部分，保留整数部分返回。

底层实现原理：

运算符

运算符是对常量或者变量进行操作的符号

算数运算符

其中特别注意计算机中的/和数学中的不一致！！！

应用：1004: 三位数的数位分离
思路：

+符号做连接符

+符号与字符串运算的时候是用作连接符的，其结果依然是一个字符串

特点：
能算则算，不能算就在一起

例如：

代码如下：
        System.out.println("abc"+"a");
        System.out.println("abc"+'a');
        System.out.println('a'+5);
        System.out.println("abc"+5+'a');
        System.out.println(5+"abc"+5);
输出结果：
abca
abca
102
abc5a
5abc5
1
2
3
4
5
6
7
8
9
10
11
12

自增自减运算符

关系运算符和逻辑运算符

• 关系运算符
  
• 逻辑运算符
  
  注意：逻辑与 “&” 、逻辑或“|”: 无论左边是 false还是 true，右边都要执行

三元运算符

• 格式：条件表达式?值1:值2;
• 执行流程：
  首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2

运算符优先级

数组

数组的静态初始化

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3… };

例如：

int[] a = new int[]{1,2,3,4};
double b = new double[]{1.0,2.0,3.0};
1
2

简化：

int[] a = {1,2,3,4};
1

注意事项

• 数组的长度：arr.length//arr为数组名
• “数据类型[] 数组名”也可以写成 “数据类型 数组名[] ”。

数组的动态初始化

动态初始化：只指定数组长度，后期赋值，适合开始知道数据的数量，但是不确定具体元素值的业务场景。

格式：

数据类型[] 数组名= new 数据类型[长度];

例如：

int[] a = new int[3];
1

默认值：

注意：两种初始化方式不能混用！！！

数组的遍历

遍历：就是一个一个数据的访问。

例如：

    public static void main(String[] args) {
        int[] a = {1,2,3,4};
        for(int i=0;i<a.length;i++){
            System.out.println(a[i]);
        }
    }
1
2
3
4
5
6

程序设计结构

顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
总的来说：程序按照从上到下的顺序执行。

例如：

public class Order {
    public static void main(String[] args) {
        System.out.println(1);
        System.out.println(2);
        System.out.println(3);
    }
}
1
2
3
4
5
6
7

分支结构

根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句

• if结构
  

例如：

    public static void main(String[] args) {
        Scanner sn = new Scanner(System.in);
        int a = sn.nextInt();
        if(a<=10){
            System.out.println(a);
        }else{
            System.out.println(a + 1);
        }

    }
    输入：5
    输出：5
    输入：11
    输出：12
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• switch结构
  

例如：

    public static void main(String[] args) {
        Scanner sn = new Scanner(System.in);
        int a = sn.nextInt();
        switch(a){
            case 10:
                System.out.println(a);break;
            case 12:
                System.out.println(a + 1);break;
            default:
                System.out.println("-1");
        }

    }
    输入：5 输出：-1
    输入：10 输出：10
    输入：12 输出：13
    输入：6 输出：-1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

注意事项：

• 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。
• case给出的值不允许重复，且只能是字面量，不能是变量。
• 不要忘记写break，否则会出现穿透现象。

循环结构

在一定条件下，可以重复执行某些语句

• for结构

例如：

    public static void main(String[] args) {
        for(int i=1;i<=3;i++){
            System.out.println("hello world");
        }
    }
    执行结果：
	hello world
	hello world
	hello world    
1
2
3
4
5
6
7
8
9

• while结构
  

例如：

    public static void main(String[] args) {
        int i=1;
        while(i<=3){
            System.out.println("hello world");
            i++;
        }
    }
    执行结果：
	hello world
	hello world
	hello world    
1
2
3
4
5
6
7
8
9
10
11

跳转关键字

• break

跳出并结束当前所在循环的执行
只能用于结束所在循环，或者结束所在switch分支的执行

例如：

public class test {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++){
            System.out.println(i);
            if (i == 3){
                break;
            }
        }
    }
}
执行结果：
1
2
3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• continue

用于跳出当前循环的当次执行，进入下一次循环
只能在循环中进行使用

例如：

    public static void main(String[] args) {
        for (int i = 1; i < 10; i++){
            
            if (i == 3){
                continue;
            }
            System.out.println(i);
        }
    }
执行结果：
1
2
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

debug工具

IDEA自带的断点调试(排错)工具，可以控制代码从断点开始一行一行的执行，然后详细观看程序执行的情况

方法

方法是一种语法结构，它可以把一段代码封装成一个功能，以方便重复调用。

方法的定义和调用

方法定义的完整格式：

修饰符 返回值类型 方法名(形参列表){
	方法体代码(需要执行的功能代码)
	return返回值;
}
1
2
3
4

例如：

    public static int sum(int a,int b){
        return a+b;
    }
1
2
3

调用格式：

方法名(....);
1

例如：

    public static int sum(int a,int b){
        return a+b;
    }
    public static void main(String[] args) {
        int a=1,b=2;
        int s = sum(a,b);
        System.out.println(s);
    }
1
2
3
4
5
6
7
8

方法的重载

同一个类中，出现多个方法名称相同，但是形参列表是不同的，那么这些方法就是重载方法。

例如：同一函数名，不同的参数和返回格式

    public static void main(String[] args) {
        System.out.println(add(2,2));
        System.out.println(add(2.5,3.5));
        System.out.println(add(2.5,3.5,4.5));
    }
 
    public static int add(int x,int y) {
        return x+y;
    }
    public static double add(double x,double y){
        return x+y;
    }
    public static double add(double x,double y,double z)
    {
        return x+y+z;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

方法详解链接

补充内容：方法内容详解

API

定义：指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来

Scanner

键盘输入功能

例如：

输入整数：
        Scanner sn = new Scanner(System.in);
        int a = sn.nextInt();
输入字符串：
        Scanner sn = new Scanner(System.in);
        String a = sn.next();
1
2
3
4
5
6

Random

作用：用于在程序中获取随机数的技术

例如：产生0-9的随机数

    public static void main(String[] args) {
        Random r = new Random();
        int number = r.nextInt(10)+0;//0改为1，结果就是1-10的随机数
        System.out.println(number);
    }
1
2
3
4
5