您的位置:首页 > 编程语言 > Java开发

Java基础语法(HelloWorld、常识、常量、变量和数据类型、数据类型转换、运算符、方法、流程控制语句、数组、开发工具)

2020-07-14 05:35 513 查看

Java基础语法

  • 2. 一些常识
  • 3. 常量
  • 4. 变量和数据类型
  • 4.3 变量的定义
  • 5. 数据类型转换
  • 6. 运算符
  • 7. 方法
  • 8.流程控制语句
  • 8.2 选择语句
  • 8.3 循环语句
  • 9. 数组
  • 9.2 数组原理内存图
  • 9.4 数组的常见操作
  • 9.5 数组作为方法参数和返回值
  • 10. 开发工具IntelliJ IDEA

  • 一个 Java 程序可以认为是一系列对象的集合,而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。
    对象:对象是类的一个实例,有状态和行为。例如,一条狗是一个对象,它的状态有:颜色、名字、品种;行为有:摇尾巴、叫、吃等。
    :类是一个模板,它描述一类对象的行为和状态。
    方法:方法就是行为,一个类可以有很多方法。逻辑运算、数据修改以及所有动作都是在方法中完成的。
    实例变量:每个对象都有独特的实例变量,对象的状态由这些实例变量的值决定。

    1. HelloWorld入门程序

    1.1 程序开发步骤说明

    Java程序开发三步骤:编写、编译、运行。

    1.2 编写Java源程序

    1. 在 d:\day01 目录下新建文本文件,完整的文件名修改为 HelloWorld.java ,其中文件名为 HelloWorld ,后
      缀名必须为 .java 。
    2. 用记事本打开(可使用notepad++)
    3. 在文件中键入文本并保存,代码如下:
    public class HelloWorld {
    public static void main(String[] args) {
    System.out.println("Hello World!");
    }
    }

    注:文件名必须是 HelloWorld ,保证文件名和类的名字是一致的,注意大小写。

    HelloWord 源程序就编写完成了,但是这个文件是程序员编写的,JVM是看不懂的,也就不能运行,因此我们必须将编写好的 Java 源文件 编译成JVM可以看懂的字节码文件 。

    1.3 编译Java源文件

    在DOS命令行中,进入Java源文件的目录,使用 javac 命令进行编译。
    命令:

    javac 源文件名.后缀名


    编译成功后,命令行没有任何提示。打开 d:\day01 目录,发现产生了一个新的文件 HelloWorld.class ,该文件就是编译后的文件,是Java的可运行文件,称为字节码文件,有了字节码文件,就可以运行程序了。

    1.4 运行Java程序

    在DOS命令行中,进入Java源文件的目录,使用 java 命令进行运行。
    命令:
    java 类名字

    注:java HelloWord 不要写 .class

    2. 一些常识

    2.1 编译和运行是两回事

    编译 :是指将我们编写的Java源文件翻译成JVM认识的class文件,在这个过程中, javac 编译器会检查我们所写的程序是否有错误,有错误就会提示出来,如果没有错误就会编译成功。
    运行 :是指将 class 文件 交给JVM去运行,此时JVM就会去执行我们编写的程序了。

    2.2 关于main方法

    main 方法:称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点,无论我们编写多少程序,JVM在运行的时候,都会从main方法这里开始执行。

    2.3 关键字keywords

    关键字 :是指在程序中,Java已经定义好的单词,具有特殊含义。

    HelloWorld 案例中,出现的关键字有 public 、 class 、 static 、 void等,这些单词已经被Java定义好,全部都是小写字母,notepad++中颜色特殊

    2.4 标识符

    标识符 :是指在程序中,我们自己定义内容。比如类的名字、方法的名字和变量的名字等等,都是标识符。

    HelloWorld 案例中,出现的标识符有类名字 HelloWorld 。

    命名规则: 硬性要求

    • 标识符可以包含 英文字母 26个(区分大小写) 、 0 -9数字 、 $ (美元符号) 和 _ (下划线)。
    • 标识符不能以数字开头。
    • 标识符不能是关键字。

    命名规范: 软性建议

    • 类名规范:首字母大写,后面每个单词首字母大写(大驼峰式)。
    • 方法名规范: 首字母小写,后面每个单词首字母大写(小驼峰式)。
    • 变量名规范:全部小写。

    3. 常量

    类型 含义 数据举例
    整数常量 所有的整数 0,1, 243, -7
    小数常量 所有的小数 0.0, -0.2, 3.95
    字符常量 单引号引起来,只能写一个字符,必须有内容 ‘a’, ‘好’
    字符串常量 双引号引起来,可以写多个字符,也可以不写 “A” ,“Hello” ,“你好” ,""
    布尔常量 只有两个值 true , false
    空常量空常量 只有一个值 null

    使用示例

    public class ConstantDemo {
    public static void main(String[] args){
    //输出整数常量
    System.out.println(249);
    //输出小数常量
    System.out.println(0.13);
    //输出字符常量
    System.out.println('A');
    //输出布尔常量
    System.out.println(true);
    //输出字符串常量
    System.out.println("你好呀Java");
    }
    }

    4. 变量和数据类型

    4.1 变量概述

    变量:常量是固定不变的数据,那么在程序中可以变化的量称为变量。

    Java中要求一个变量每次只能保存一个数据,必须要明确保存的数据类型。

    4.2 数据类型

    4.2.1 数据类型分类

    基本数据类型 :包括 整数 、 浮点数 、 字符 、 布尔
    引用数据类型 :包括 类 、 数组 、 接口

    4.2.2 基本数据类型

    四类八种基本数据类型:

    数据类型 关键字 内存占用 取值范围
    字节型 byte 1个字节 -128~127
    短整型 short 2个字节 -32768~32767
    整型 int(默认) 4个字节 -2的31次方~2的31次方-1
    长整型 long 8个字节 -2的63次方~2的63次方-1
    单精度浮点数 float 4个字节 1.4013E-45~3.4028E+38
    双精度浮点数 double(默认) 8个字节 4.9E-324~1.7977E+308
    字符型 char 2个字节 0-65535
    布尔类型 boolean 1个字节 true,false

    4.3 变量的定义

    数据类型 变量名 = 数据值;

    练习

    public class Variable {
    public static void main(String[] args){
    //定义字节型变量
    byte b = 100;
    System.out.println(b);
    //定义短整型变量
    short s = 1000;
    System.out.println(s);
    //定义整型变量
    int i = 123456;
    System.out.println(i);
    //定义长整型变量
    long l = 12345678900L;
    System.out.println(l);
    //定义单精度浮点型变量
    float f = 5.5F;
    System.out.println(f);
    //定义双精度浮点型变量
    double d = 8.5;
    System.out.println(d);
    //定义布尔型变量
    boolean bool = false;
    System.out.println(bool);
    //定义字符型变量
    char c = 'A';
    System.out.println(c);
    }
    }

    long类型:建议数据后加L表示。
    float类型:建议数据后加F表示。
    变量名称:在同一个大括号范围内,变量的名字不可以相同。
    变量赋值:定义的变量,不赋值不能使用。

    5. 数据类型转换

    Java程序中要求参与的计算的数据,必须要保证数据类型的一致性,如果数据类型不一致将发生类型的转换。

    5.1 自动转换

    自动转换 :将 取值范围小的类型 自动提升为 取值范围大的类型 。

    public static void main(String[] args) {
    int i = 1;
    byte b = 2;
    // byte x = b + i; // 报错
    //int类型和byte类型运算,结果是int类型
    int j = b + i;
    System.out.println(j);
    }

    同样道理,当一个 int 类型变量和一个 double 变量运算时, int 类型将会自动提升为 double 类型进行运算。

    public static void main(String[] args) {
    int i = 1;
    double d = 2.5;
    //int类型和double类型运算,结果是double类型
    //int类型会提升为double类型
    double e = d+i;
    System.out.println(e);
    }

    转换原理图解

    转换规则
    范围小的类型向范围大的类型提升,如 byte 、short、char 运算时直接提升为 int 。

    byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

    自动提升带来的问题

    public static void main(String[] args){
    byte b1=1;
    byte b2=2;
    //1和2是常量,为固定不变的数据,在编译的时候,已经确定了1+2的结果并没有超过byte类型的取值范围
    //所以1+2可以赋值给变量b3
    byte b3=1 + 2;  //因此 b3=1 + 2是正确的。
    //b2和b3是变量,变量的值是可能变化的,在编译的时候,编译器javac不确定b2+b3的结果是什么
    //因此会将结果以int类型进行处理,所以int类型不能赋值给byte类型,
    byte b4=b1 + b2;  //因此编译失败。
    System.out.println(b3);
    System.out.println(b4);
    }

    在jshell中的体现:

    5.2 强制转换

    如果将 1.5 赋值到 int 类型变量将产生编译失败,肯定无法赋值。

    int i = 1.5; // 错误

    double 类型内存8个字节, int 类型内存4个字节。 1.5 是 double 类型,取值范围大于 int 。
    想要赋值成功,只有通过强制类型转换,将 double 类型强制转换成 int 类型才能赋值。

    强制类型转换 :将 取值范围大的类型 强制转换成 取值范围小的类型 。
    比较而言,自动转换是Java自动执行的,而强制转换需要我们自己手动执行。
    转换格式

    数据类型 变量名 = (数据类型)被转数据值;

    将 1.5 赋值到 int 类型,代码修改为:

    // double类型数据强制转成int类型,直接去掉小数点。
    int i = (int)1.5;

    同样道理,当一个 short 类型与 1 相加,我们知道会类型提升,但是还想给结果赋值给short类型变量,就需要强制转换。

    public static void main(String[] args) {
    //short类型变量,内存中2个字节
    short s = 1;
    /*
    出现编译失败
    s和1做运算的时候,1是int类型,s会被提升为int类型
    s+1后的结果是int类型,将结果在赋值会short类型时发生错误
    short内存2个字节,int类型4个字节
    必须将int强制转成short才能完成赋值
    */
    s = s + 1;//编译失败
    s = (short)(s+1);//编译成功
    }

    转换原理图解

    强烈注意 :
    浮点转成整数,直接取消小数点,可能造成数据损失精度。
    int 强制转成 short 砍掉2个字节,可能造成数据丢失。

    // 定义s为short范围内最大值
    short s = 32767;
    // 运算后,强制转换,砍掉2个字节后会出现不确定的结果
    s = (short)(s + 10);

    5.3 ASCII 编码表

    public static void main(String[] args) {
    //字符类型变量
    char c = 'a';
    int i = 1;
    //字符类型和int类型计算
    System.out.println(c+i);//输出结果是98
    }

    编码表 :就是将人类的文字和一个十进制数进行对应起来组成一张表格。

    字符 数值
    0 48
    9 57
    A 65
    Z 90
    a 97
    z 122

    在char类型和int类型计算的过程中,char类型的字符先查询编码表,得到97,再和1求和,结果为98。char类型提升为了int类型。char类型内存2个字节,int类型内存4个字节。

    6. 运算符

    6.1 算数运算符

    符号 含义
    + 加法运算 / 字符串连接运算
    - 减法运算
    * 乘法运算
    / 除法运算,两个数字相除取商
    % 取模运算,两个数字相除取余数
    ++ 、– 自增自减运算

    Java中,整数使用以上运算符,无论怎么计算,也不会得到小数。
    +符号在遇到字符串的时候,表示连接、拼接的含义。如:“a”+“b” 的结果是“ab”,连接含义

    6.2 赋值运算符

    符号 含义
    = 等于号
    += 加等于
    -= 减等于
    *= 乘等于
    /= 除等于
    %= 取模等

    关于+=符号的小思考 :

    public static void main(String[] args){
    short s = 1;
    s+=1;
    System.out.println(s);
    }

    分析: s += 1 逻辑上看作是 s = s + 1 计算结果被提升为int类型,再向short类型赋值时发生错误,因为不能将取值范围大的类型赋值到取值范围小的类型。但是, s=s+1 进行两次运算 , += 是一个运算符,只运算一次,并带有强制转换的特点,也就是说 s += 1 就是 s = (short)(s + 1) ,因此程序没有问题编译通过,运行结果是2.

    6.3 比较运算符

    符号 含义
    == 比较符号两边数据是否相等,相等结果是true
    < 比较符号左边的数据是否小于右边的数据,如果小于结果是true
    > 比较符号左边的数据是否大于右边的数据,如果大于结果是true
    <= 比较符号左边的数据是否小于或者等于右边的数据,如果小于结果是true
    >= 比较符号左边的数据是否大于或者等于右边的数据,如果小于结果是true
    ! = 不等于符号 ,如果符号两边的数据不相等,结果是true

    比较运算符,是两个数据之间进行比较的运算,运算结果都是布尔值 true 或者 false

    6.4 逻辑运算符

    逻辑运算符,是用来连接两个布尔类型结果的运算符,运算结果都是布尔值 true 或者 false

    6.5 三元运算符

    三元运算符格式

    数据类型 变量名 = 布尔类型表达式?结果1:结果2

    三元运算符计算方式

    • 布尔类型表达式结果是 true,三元运算符整体结果为结果1,赋值给变量。
    • 布尔类型表达式结果是false,三元运算符整体结果为结果2,赋值给变量。
    public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
    }

    7. 方法

    方法: 就是将一个功能抽取出来,把代码单独定义在一个大括号内,形成一个单独的功能。
    当我们需要这个功能的时候,就可以去调用。这样即实现了代码的复用性,也解决了代码冗余的现象。

    7.1 方法的定义

    定义格式

    修饰符 返回值类型 方法名 (参数列表){
    代码...
    return 方法的返回值;
    }

    定义格式解释

    • 修饰符: 目前固定写法 public static
    • 返回值类型: 表示方法运行的结果的数据类型,方法执行后将结果返回到调用者
    • 方法名:为我们定义的方法起名,满足标识符的规范,用来调用方法
    • 参数列表: 方法在运算过程中的未知数据,调用者调用方法时传递
    • return:将方法执行后的结果带给调用者,方法执行到 return ,整体方法运行结束。如果返回值类型是void,方法大括号内的return可以不写

    举例:

    public static void methodName() {
    System.out.println("这是一个方法");
    }

    方法定义注意事项:

    • 定义位置 : 类中方法外, 方法不能定义在另一个方法的里面
    • 返回值类型 : 必须要和 return 语句返回的类型相同,否则编译失败 。
    • 不能在 return 后面写代码, return 意味着方法结束,所有后面的代码永远不会执行,属于无效代码
    public class Method_Demo5 {
    public static void main(String[] args) {
    //调用方法printHelloWorld,传递整数
    printHelloWorld(9);
    }
    /*
    定义打印HelloWorld方法
    返回值类型,计算没有结果 void
    参数:不确定打印几次
    */
    public static void printHelloWorld(int n) {
    for (int i = 0; i < n; i++) {
    System.out.println("HelloWorld");
    }
    }
    }

    7.2 调用方法的三种形式

    方法在定义完毕后,方法不会自己运行,必须被调用才能执行,我们可以在主方法main中来调用我们自己定义好的方法。在主方法中,直接写要调用的方法名字就可以调用了。

    public static void main(String[] args) {
    //调用定义的方法operator
    operator();
    }
    //定义方法,被main方法调用,在方法中定义三元运算符
    public static void operator() {
    int i = 0;
    i = (1==3 ? 100:200);
    System.out.println(i);
    int j = 0 ;
    j = (5<=2 ? 500:600);
    System.out.println(j);
    }
    • 直接调用: 直接写方法名调用
    public static void main(String[] args) {
    print();
    }
    public static void print() {
    System.out.println("方法被调用");
    }
    • 赋值调用: 调用方法,在方法前面定义变量,接收方法返回值
    public static void main(String[] args) {
    int sum = getSum(5,6);
    System.out.println(sum);
    }
    public static int getSum(int a,int b) {
    return a + b;
    }
    • 输出语句调用: 在输出语句中调用方法, System.out.println( 方法名())
    public static void main(String[] args) {
    System.out.println(getSum(5,6));
    }
    public static int getSum(int a,int b) {
    return a + b;
    }

         注:不能用输出语句调用 void 类型的方法。因为方法执行后没有结果,也就打印不出任何内容。

    public static void main(String[] args) {
    System.out.println(printHello());// 错误,不能输出语句调用void类型方法
    }
    public static void printHello() {
    System.out.println("Hello");
    }

    7.3 方法重载

    方法重载 :指在同一个类中,允许存在一个以上的同名方法,只要它们的参数列表不同即可,与修饰符和返回值类型无关。

    • 参数列表:个数不同,数据类型不同,顺序不同。
    • 重载方法调用: JVM通过方法的参数列表,调用不同的方法。

    方法重载举例 :
    比较两个数据是否相等。参数类型分别为两个 byte 类型,两个 short 类型,两个 int 类型,两个 long 类型,并在 main 方法中进行测试。

    public class Method_Demo6 {
    public static void main(String[] args) {
    //定义不同数据类型的变量
    byte a = 10;
    byte b = 20;
    short c = 10;
    short d = 20;
    int e = 10;
    int f = 10;
    long g = 10;
    long h = 20;
    // 调用
    System.out.println(compare(a, b));
    System.out.println(compare(c, d));
    System.out.println(compare(e, f));
    System.out.println(compare(g, h));
    }
    // 两个byte类型的
    public static boolean compare(byte a, byte b) {
    System.out.println("byte");
    return a == b;
    }
    // 两个short类型的
    public static boolean compare(short a, short b) {
    System.out.println("short");
    return a == b;
    }
    // 两个int类型的
    public static boolean compare(int a, int b) {
    System.out.println("int");
    return a == b;
    }
    // 两个long类型的
    public static boolean compare(long a, long b) {
    System.out.println("long");
    return a == b;
    }
    }

    8.流程控制语句

    8.1判断语句

    8.1.1 判断语句1–if

    if(关系表达式){
    语句体;
    }

    8.1.2 判断语句2–if…else

    if(关系表达式) {
    语句体1;
    }else {
    语句体2;
    }

    8.1.3 判断语句3–if…else if…else

    if (判断条件1) {
    执行语句1;
    } else if (判断条件2) {
    执行语句2;
    }
    ...
    }else if (判断条件n) {
    执行语句n;
    } else {
    执行语句n+1;
    }

    8.1.4 语句练习

    指定考试成绩,判断学生等级

    • 90-100 优秀
    • 80-89 好
    • 70-79 良
    • 60-69 及格
    • 60 以下 不及格
    public static void main(String[] args) {
    int score = 100;
    if(score<0 || score>100){
    System.out.println("你的成绩是错误的");
    }else if(score>=90 && score<=100){
    System.out.println("你的成绩属于优秀");
    }else if(score>=80 && score<90){
    System.out.println("你的成绩属于好");
    }else if(score>=70 && score<80){
    System.out.println("你的成绩属于良");
    }else if(score>=60 && score<70){
    System.out.println("你的成绩属于及格");
    }else {
    System.out.println("你的成绩属于不及格");
    }
    }

    8.1.5 if 语句和三元运算符的互换

    在某些简单的应用中,if语句是可以和三元运算符互换使用的。

    public static void main(String[] args) {
    int a = 10;
    int b = 20;
    //定义变量,保存a和b的较大值
    int c;
    if(a > b) {
    c = a;
    } else {
    c = b;
    }
    //可以上述功能改写为三元运算符形式
    c = a > b ? a:b;
    }

    8.2 选择语句

    8.2.1 选择语句–switch

    switch(表达式) {
    case 常量值1:
    语句体1;
    break;
    case 常量值2:
    语句体2;
    break;
    ...
    default:
    语句体n+1;
    break;
    }

    switch 语句中,表达式的数据类型,可以是byte,short,int,char,enum(枚举),JDK7后可以接收字符串。

    8.2.2 case 的穿透性

    在switch语句中,如果case的后面不写break,将出现穿透现象,也就是不会在判断下一个case的值,直接向后运行,直到遇到break,或者整体switch结束。

    8.3 循环语句

    8.3.1 循环语句1–for

    for(初始化表达式①; 布尔表达式②; 步进表达式④){
    循环体③
    }

    8.3.2 循环语句2–while

    初始化表达式①
    while(布尔表达式②){
    循环体③
    步进表达式④
    }

    8.3.3 循环语句3–do…while

    初始化表达式①
    do{
    循环体③
    步进表达式④
    }while(布尔表达式②);

    8.3.4 循环语句的区别

    for 和 while 的小区别:

    • 控制条件语句所控制的那个变量,在for循环结束后,就不能再被访问到了,而while循环结束还可以继续使用,如果你想继续使用,就用while,否则推荐使用for。原因是for循环结束,该变量就从内存中消失,能够提高内存的使用效率。
    • 在已知循环次数的时候使用推荐使用for,循环次数未知的时推荐使用while。

    8.3.5 跳出语句

    break

    使用场景:终止 switch或者循环

    • 在选择结构 switch语句中
    • 在循环语句中
    • 离开使用场景的存在是没有意义的
    public static void main(String[] args) {
    for (int i = 1; i<=10; i++) {
    //需求:打印完两次HelloWorld之后结束循环
    if(i == 3){
    break;
    }
    System.out.println("HelloWorld"+i);
    }
    }

    continue

    使用场景:结束本次循环,继续下一次的循环.

    public static void main(String[] args) {
    for (int i = 1; i <= 10; i++) {
    //需求:不打印第三次HelloWorld
    if(i == 3){
    continue;
    }
    System.out.println("HelloWorld"+i);
    }
    }

    8.3.6 死循环

    死循环: 也就是循环中的条件永远为true,死循环的是永不结束的循环。例如:while(true){}

    应用死循环的场景举例:我们需要读取用户输入的输入,但是用户输入多少数据我们并不清楚,也只能使用死循环,当用户不想输入数据了,就可以结束循环了,如何去结束一个死循环呢,就需要使用到跳出语句了。

    8.3.7 嵌套循环

    嵌套循环:是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环,就是嵌套循环。总共的循环次数=外循环次数*内循环次数

    嵌套循环格式

    for(初始化表达式①; 循环条件②; 步进表达式⑦) {
    for(初始化表达式③; 循环条件④; 步进表达式⑥) {
    执行语句⑤;
    }
    }

    9. 数组

    9.1 数组定义和访问

    容器: 是将多个数据存储到一起,每个数据称为该容器的元素。

    9.1.1 数组的定义

    数组概念: 数组就是存储数据长度固定的容器,保证多个数据的数据类型要一致。

    • 定义方式一
      格式:

    数组存储的数据类型[]   数组名字 = new   数组存储的数据类型[长度];

            数组定义格式详解:

    数组存储的数据类型: 创建的数组容器可以存储什么数据类型
    [] : 表示数组
    数组名字:为定义的数组起个变量名,满足标识符规范,可以使用名字操作数组
    new :关键字,创建数组使用的关键字
    数组存储的数据类型: 创建的数组容器可以存储什么数据类型
    [ 长度]:数组的长度,表示数组容器中可以存储多少个元素
    注意:数组有定长特性,长度一旦指定,不可更改

            举例:

    int[] arr = new int[3]; //定义可以存储3个整数的数组容器
    • 定义方式二
      格式:

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

            举例:

    int[] arr = new int[]{1,2,3,4,5}; //定义存储1,2,3,4,5整数的数组容器
    • 定义方式三
      格式:

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

            举例:

    int[] arr = {1,2,3,4,5}; //定义存储1,2,3,4,5整数的数组容器

    9.1.2 数组的访问

    索引: 每一个存储到数组的元素,都会自动的拥有一个编号,从0开始,这个自动编号称为数组索引(index),可以通过数组的索引访问到数组中的元素。

    索引格式:

    数组名[索引]

    数组的长度属性: 每个数组都具有长度,而且是固定的,Java中赋予了数组的一个属性,可以获取到数组的长度,语句为: 数组名 .length ,属性length的执行结果是数组的长度,int类型结果。由次可以推断出,数组的最大索引值为 数组名 .length-1 。
    索引访问数组中的元素:

    • 数组名 [索引]=数值,为数组中的元素赋值
    • 变量 =数组名[索引],获取出数组中的元素
    public static void main(String[] args) {
    //定义存储int类型数组,赋值元素1,2,3,4,5
    int[] arr = {1,2,3,4,5};
    //为0索引元素赋值为6
    arr[0] = 6;
    //获取数组0索引上的元素
    int i = arr[0];
    System.out.println(i);
    //直接输出数组0索引元素
    System.out.println(arr[0]);
    }

    9.2 数组原理内存图

    内存是计算机中的重要原件,临时存储区域,作用是运行程序。我们编写的程序是存放在硬盘中的,在硬盘中的程序是不会运行的,必须放进内存中才能运行,运行完毕后会清空内存。
    Java虚拟机要运行程序,必须要对内存进行空间的分配和管理。

    9.2.1 Java 虚拟机的内存划分

    区域名称 作用
    寄存器 给CPU使用,和我们开发无关
    本地方法栈 JVM在使用操作系统功能的时候使用,和我们开发无关
    方法区 存储可以运行的class文件
    堆内存 存储对象或者数组,new来创建的,都存储在堆内存
    方法栈 方法运行时使用的内存,比如main方法运行,进入方法栈中执行

                      

    9.3 数组在内存中的存储

    两个数组内存图

    public static void main(String[] args) {
    int[] arr = new int[3];
    int[] arr2 = new int[2];
    System.out.println(arr);
    System.out.println(arr2);
    }


    两个变量指向一个数组

    public static void main(String[] args) {
    // 定义数组,存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5;
    arr[1] = 6;
    arr[2] = 7;
    //输出3个索引上的元素值
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    //定义数组变量arr2,将arr的地址赋值给arr2
    int[] arr2 = arr;
    arr2[1] = 9;
    System.out.println(arr[1]);
    }

    9.4 数组的常见操作

    9.4.1 数组越界异常

    public static void main(String[] args) {
    int[] arr = {1,2,3};
    System.out.println(arr[3]);
    }

    创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界常是不能出现的,一旦出现了,就必须要修改我们编写的代码。

    9.4.2 数组空指针异常

    public static void main(String[] args) {
    int[] arr = {1,2,3};
    arr = null;
    System.out.println(arr[0]);
    }

    arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候会抛出 NullPointerException 空指针异常。

    9.4.3 数组遍历【重点】

    数组遍历: 就是将数组中的每个元素分别获取出来,就是遍历。遍历也是数组操作中的基石。

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

    9.4.4 数组获取最大值元素

    最大值获取: 从数组的所有元素中找出最大值。

    public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
    //定义变量,保存数组中0索引的元素
    int max = arr[0];
    //遍历数组,取出每个元素
    for (int i = 0; i < arr.length; i++) {
    //遍历到的元素和变量max比较
    //如果数组元素大于max
    if (arr[i] > max) {
    //max记录住大值
    max = arr[i];
    }
    }
    System.out.println("数组最大值是: " + max);
    }

    9.4.5 数组反转

    数组的反转: 数组中的元素颠倒顺序,例如原始数组为1,2,3,4,5,反转后的数组为5,4,3,2,1

    public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
    循环中定义变量min=0最小索引
    max=arr.length‐1最大索引
    min++,max‐‐
    */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
    //利用第三方变量完成数组中的元素交换
    int temp = arr[min];
    arr[min] = arr[max];
    arr[max] = temp;
    }
    // 反转后,遍历数组
    for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
    }
    }

    9.5 数组作为方法参数和返回值

    9.5.1 数组作为方法参数

    数组作为方法参数传递,传递的参数是数组内存的地址。

    public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //调用方法,传递数组
    printArray(arr);
    }
    /*
    创建方法,方法接收数组类型的参数
    进行数组的遍历
    */
    public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
    }
    }

    9.5.2 数组作为方法返回值

    public static void main(String[] args) {
    //调用方法,接收数组的返回值
    //接收到的是数组的内存地址
    int[] arr = getArray();
    for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
    }
    }
    /*
    方法,返回值是数组类型
    return返回数组的地址
    */
    public static int[] getArray() {
    int[] arr = { 1, 3, 5, 7, 9 };
    //返回数组的地址,返回到调用者
    return arr;
    }

    注:一个方法只能有 0或者 1个返回值,如果希望一个方法中产生多个结果数据进行返回,可以使用一个数组作为返回值类型即可。

    9.5.3 方法的参数类型区别

    • 方法的参数为基本类型时,传递的是数据值.
    public static void main(String[] args) {
    int a = 1;
    int b = 2;
    System.out.println(a);
    System.out.println(b);
    change(a, b);
    System.out.println(a);
    System.out.println(b);
    }
    public static void change(int a, int b) {
    a = a + b;
    b = b + a;
    }
    • 方法的参数为引用类型时,传递的是地址值.
    public static void main(String[] args) {
    int[] arr = {1,3,5};
    System.out.println(arr[0]);
    change(arr);
    System.out.println(arr[0]);
    }
    public static void change(int[] arr) {
    arr[0] = 200;
    }

    10. 开发工具IntelliJ IDEA

    10.1 IDEA 软件安装

    ( 此处略过 )

    10.2 IDEA 常用快捷键

    快捷键 功能
    Alt+Enter 导入包,自动修正代码
    Ctrl+Y 删除光标所在行
    Ctrl+D 复制光标所在行的内容,插入光标位置下面
    Ctrl+Alt+L 格式化代码
    Ctrl+/ 单行注释
    Ctrl+Shift+/ 选中代码注释,多行注释,再按取消注释
    Alt+Ins 自动生成代码,toString,get,set等方法
    Alt+Shift+ 上下箭头 移动当前代码行
    Ctrl+空格 (需自行修改) 补全代码

    10.3 IDEA 修改快捷键

    在IDEA工具中, Ctrl+ 空格 的快捷键,可以帮助我们补全代码,但是这个快捷键和Windows中的输入法切换快捷键冲突,需要修改IDEA中的快捷键。

    File ->Settings->keymap->Main menu->code->Completion->Basic

    双击 Basic ->remove->Ctrl+空格

    再次双击 Basic ->Add Keyboard->键入 Alt+/->点击OK

    内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
    标签: 
    相关文章推荐