Java基础语法

基础语法

目录

• 基础语法
  • 一、历史与概念
    • • 历史
      • 特点
        • 语言特点
      • 概念
        • 三组相关概念
        • 注释
        • 关键字
        • 标识符
        • 常量
        • 变量
  • 二、基础语法
    • (一)、数据类型
      • 分类
      • 转换
      • 字符&字符串类型
    • (二)、运算符
      • 算术运算符
      • 赋值运算符
      • 比较运算符
      • 逻辑运算符
      • 位运算符(了解)
      • 三目(元)运算符
    • (三)、流程控制
      • 1. 顺序结构
      • 2. 分支结构
      • 3. 循环结构
  • 三、方法
    • (一)、分类
      • 分类
      • 注意事项
    • (二)、重载
  • 四、数组
    • • 1. 数组的地址
      • 2. 初始化
      • 3. 常见异常
      • 4. 两个引用指向同一数组
      • 5. 常见操作
  • 五、JVM内存划分
    • • 1. 栈内存［常用］
      • 2. 堆内存［常用］
      • 3. 方法区［常用］
      • 4. 本地方法区［不常用］
      • 5. 程序计数器［不常用］

一、历史与概念

1. 历史

• Sun公司 詹姆斯*高斯林 Oralce

• JDK8 是目前市面是比较流行的最稳定最安全的版本

• 开发方向

  • JavaME: 手机应用的开发.
  • JavaSE: PC应用的开发.
  • JavaEE:企业级网站开发平台. 用来做一些大型的门户网站.

2. 特点

• 语言特点

  • 1.开源免费

    可以直接下载java的源码, jdk的使用是不要钱

  • 2.面向对象

    是一种编程思想, 解决问题的方式,能使编程变的更加简单.

  • 3.跨平台

    java语言可以做到,一次编写,到处运行.

    • 支持跨平台的原因

      java根据不同操作系统研发了对应操作系统的JVM(虚拟机. Java Vritual Machine , 作用是运行java程序的容器)

  • 4.编译性

    写好的java代码不能直接运行.要先编译,再运行.
    写好的java文件叫做:源文件 (.java)
    源文件编译后生成字节码文件(.class). 运行的是字节码文件.

  • 5.动态性

    java可以实现程序的执行过程, 动态的修改执行的内容.(反射)

3. 概念

• 三组相关概念

  • 1.JVM

    java的虚拟机,
    全称: Java Virtual Machine,
    一个java运行的容器.
    是实现跨平台性的根本原因.

  • 2.JRE

    java运行时环境
    全称:Java Runtime Environment.
    提供有java运行时需要依赖的核心类库 + JVM.

    用于客户演示写好的Java程序, 客户电脑只需要安装JRE即可.

  • 3.JDK

    java开发者工具包
    全称: Java Development Kit.
    这是为java开发人员准备的一个工具包,里面除了有核心类库,虚拟机,还有一些开发的工具.
    比如:运行(java.exe)和编译(javac.exe)的工具

• 注释

用来对程序中的代码进行解释说明的部分

• 特点

  • 1.编译的时候不会检测注释中的语法是否正确
  • 2.程序运行的时候不会运行注释中内容

• 分类

  • 1.单行注释

    样式:  // 注释的内容

    • 1.单行注释的内容不能回车
    • 2.单行注释可以嵌套

  • 2多行注释

    样式: /* 注释的内容  */

    • 1.多行注释可以有回车
    • 2.多行注释不能嵌套

  • 3.文本注释

• 总结

  • 1.对代码进行解释说明

  • 2.对程序的设计思路进行描述

  • 3.可以用来调试程序

    (把认为有问题的代码注释掉,逐行打开注释运行.直到找到错误所在位置)

• 关键字

在java中有一些被赋予特殊含义的英文单词,这些单词称之为保留字.
每个单词都有特殊的功能.

• 特点

  • 1.都是纯小写字母
  • 2.const,goto虽然被保留了,但是没有特殊含义
  • 3.自定内容取名不能和关键字重名.

• 标识符

定义(作用):
用来给自定义内容取名字的字符序列就叫做标识符.

• 组成内容

  • 1.英文字母大小写: a-z, A-Z
  • 2.数字: 0-9
  • 3.英文特殊符号: _(下划线) $(美元符号)
  • 4.其他国家的语言符号(中文, 日文, 泰文),实际开发不会实用.(基本不用)

• 注意事项

  • 1.不能和关键字重名
  • 2.不能以数字开头
  • 3.标识符区分大小写

• 命名规范

  核心原则:见名知意

  • 类, 接口,枚举

    使用的大驼峰命名法, (每个单词首字母大写.)

  • 包

    采用公司域名倒写的形式, 包的作用类名冲突的问题.对java中类进行分类

  • 方法名 、变量名

    采用的小驼峰命名法,一个或多个单词第一个单词纯小写,以后每个单词首字母大写
    变量名一般使用名字.

  • 常量名

    采用的字母纯大写的形式,多个单词之间使用下划线连接

• 常量

指程序执行过程中,值不能发生改变的量.
赋值运算符: = 作用:把符号右边的值,赋值给左边的内容

• 表现形式

  • 字面值常量

    根据数据字面意思可以知道它代表什么值,这样常量就叫做字面值常量

  • 符号常量

    给常量命名后,通过名字可以获取它存储的常量值, 根据这个符号也能知道他表示的是什么意思.像这样的常量就是符号常量.

• 数据类型

  • 基本类型数据

    • 整数类型常量

    • 小数类型常量

    • 字符类型常量

      字符常量:单引号括起来的单个字符.

    • 布尔类型常量

      用来表示真假的常量.
      只有两个值: true 和 false.

  • 引用类型的数据

    • 字符串常量

      字符串常量:使用双引号括起来的字符序列.
      字符序列个数可以0或者n个.

    • 空常量

      null, 表示空,
      代表不指向任何内存空间的位置.
      null不能打印,否则报错

• 变量

变量:在程序的执行过程中,值可以发生改变的量.

• 本质

  表示内存中一小块存储空间,
  给这个空间命名(变量名).操作这块内存空间时,可以通过变量名往这块空间赋值或取出空间中的值.
  变量就相当于一个容器.

• 出现原因

  程序执行过程中有一些数据可能会发生变化,需要用一个东西存储这些会变化的数据,此时就要使用变量.

• 格式

  • 数据类型 变量名 = 初始值

    =:赋值运算符, 把符号右边的值,复制一份,赋值给左边的内容, 存储到变量名代表的内存空间中.

    变量只有在定义的时候才会加数据类型, 以后使用时候,无论是取值还是赋值,只需要使用变量名即可.

  • 数据类型 变量名1 = 初始值1, 变量名2 = 初始值2, 变量名3 = 初始值3,....;

• 注意事项

  • 可以使用变量给变量进行赋值
  • 定义float类型变量赋值时,需要在常量后加f或F.
  • 在一个大括号中不能拿定义同名的变量名.
  • 写一个小数默认当做:double类型, 写一个整数: 默认当做int类型.

二、基础语法

(一)、数据类型

• 出现原因

  Java是一种强类型语言,
  在java要存储数据的时候,要指明这个数据在内存中所占的空间大小.
  只有这样才能为这个数据开辟内存空间存储它.

• 作用

  就是用来规定数据在内存中所占空间大小.
  java中提供了丰富的数据类型,不同的数据类型,表示的内存空间大小是不一样的.
  设计这么多数据类型的原因:就是为了节省内存空间, 现在我们的设备内存都非常大,
  以后存储整数: 基本都用int, 存储小数: double

  1. 分类

  • 基本类型数据类型

    这些类型都是在jdk中已经提前定义好了,不能添加也不会减少,
    描述的都是一些简单的数据,描述的都是数据本身.
    数据类型范围的大小关系罗列
     byte < short<int<long<float<double
     char < int < long < float < double

    • 整数类型

      整数类型   内存空间大小  存储数据范围 
      byte        1个字节     -128-127  -27 - 27-1
      short      2个字节      -215 - 215-1
      int       4个字节      -231 - 231-1
      long        8个字节      -263 - 263-1

    • 小数类型

      (IEEE754标准存储,属于科学计数法存储) 
      float(单精度浮点型) 4个字节   float > long
      double(双精度浮点型) 8个字节   double > float

    • 字符类型

      char ,2个字节   无符号整数: 0-65535 
      存储的都是使用单引号括起来的单个字符.

      • ASCII码表

        • 出现原因

          在计算机中,所有数据最终存储到计算机中都是以二进制存储,符号不能直接放到内存或者硬盘上.
          为解决上面的问题,制作一张数字和字符之间一一对应的表格, 最早的表格叫做ASCII码表.这个表中定义的都是英文符号和数字之间的关系.
          这个编码表中只有128个字符.所以其他国家的语言其他国家语言符号要想存储到计算机中需要制定自己的编码表. 无论哪个国家制定编码表,前128个符号和ASCII码表中一模一样.

        • 中国制作

          • GB2312(已经很少使用),
          • GBK(使用最多的).

        • 世界通用

          • Unicode编码表

            存储所有的字符都要两个字节存储, 0-65535. 能表示所有国家的语言符号

            Unicode编码表中如何存储字符和数字的之间的关系:
              字符 --> ‘\u****’ 字符对应的是16进制的数据.
              ‘a’ ---> 十进制97 ---> ‘\u0061’

          • UTF-8编码表

            在网页上用的比较多,也是包含世界上所有国家语言符号.
            如果是英文符号用1个字节存储, 如果中文用3个字节存储.

      • 编码

        把字符转化为数字的过程

      • 解码

        把数字转为字符的过程

    • 布尔类型

      boolean      未知     true和false

  • 引用类型的数据类型

    负责的数据类型,描述的不是数据本身,而是数据在内存中地址,
    根据这个地址就可以找到他存储的数据.
    在jdk中有一些引用类型的数据已经提前定义好了,但是我们也可以自定引用类型的数据.

    • 字符串类型

      类型名为:String
      定义:String 变量名 = 初始值;

  2. 转换

  • 隐式转换

    当小范围数据类型和大范围数据类型在一起运算符时, 程序自动将小范围数据类型提升为大范围数据类型.再进行运算. 运算结果依然是大范围数据类型.

    • 直接体现

      • 大范围类型变量 = 小范围类型变量;

    • 注意事项

      • 数据类型隐式转换只针对数值类型数据. boolean不是数值类型数据.
      • byte, short, char, int这几种类型在运算的时候,统统都会提升为int类型.
      • int及int类型范围的数据类型做运行的时候, 也会进行类型向上提升,哪个类型的范围大,最终就提升为那个范围的数据.

  • 显示转换(强类型转换)

    当使用大范围数据类型给小范围的数据类型赋值的时,就需要使用显示转换或者强制转换的方式才能完成, 否则不允许直接赋值.

    • 格式

      • 小范围数据类型 = (小范围数据类型名) 大范围的数据类型;

    • 注意事项

      • 强制类型转换有风险, 会导致数据溢出.也就是数据的丢失.

  3. 字符&字符串类型

(二)、运算符

用来对程序中的数据进行的操作的符号.

1. 算术运算符

用来做算术运算符的符号

• +:加号运算符

  1. 做加法运算符
  2. 表示正数
     3.表示字符串的拼接

• -:减号运算符

  1.做减法运算符
  2.表示负数

• *:乘法运算符

  表示求两个数据的乘积

• /:除法运算符

  表示求两个数的商

  • 注意事项

    • 1. 两边都是整数,结果依然整数
    • 2.两边只要有一边是小数,结果就是小数.
    • 3.除数不能为0,否则运行报错

• %: 取余(模)运算符

  求出两个数相除之后的余数
  除不尽,余数的正负只和被除数有关,被除数是正的,余数就是正的,否则就是负的.
  除的尽余数就是0.

  • 作用: 判断一个数字的奇偶.

• 自增和自减运算符

  只能操作变量,不能操作常量.
  自增运算符运算完之后让变量+1, 自减运算符运算完之后会让变量-1.
   ++和--都可以即出现在变量前,也可以出现变量后.

  • ++和--出现变量前后对整个式子值的影响

    ++在变量前: 先对变量加1,再把变量的值当做式子的值.   ---> 先加后用
     ++在变量后: 先取出变量的值当做式子的值,再对变量加1 ---> 先用后加
     --在变量前: 先对变量减1,再把变量的值当做式子的值.   ---> 先减后用
     --在变量后: 先取出变量的值当做式子的值,再对变量减1 ---> 先用后减

2. 赋值运算符

用来给变量进行赋值操作的符号

• 1.基本赋值运算符: =

• 2.复合赋值运算符

  工作特点: 将变量使用第一个符号对右边的数据操作之后,重新赋值给这个变量本身.

  • +=

    a+=3, 等价于: a = a + 3

  • -=

    a-=3. 等价于: a = a - 3;

  • *=

    a=3 等价于: a = a3;

  • /=

    a/=3 等价于: a = a / 3;

  • %=

    a %=3 等价于: a = a % 3;

3. 比较运算符

比较数据大小和数据是否相等的运算符.
比较运算符的结果都是boolean的数据, 要么为true,要么为false

• 1.比较大小

  , <, >=, <=
  只能用来比较数值类型数据

• 2.比较是否相等

  ==, !=
  可以任意类型的数据

4. 逻辑运算符

用来对逻辑值进行操作的运算符.
逻辑值指的就是boolean类型的数据 ,
逻辑运算符处理之后的结果依然是逻辑值.

• &&: 逻辑与, 两边全真则真, 一假则假

  true && true --> true
    false && true --> false
    true && false --> false
    false && false -->false

• ||:逻辑或, 一真则真,同假才假

  true || true --> true
    false || true --> true
    true || false --> true
    false || false --> false

• !:逻辑非, 非真既假,非假既真

  !true -- > false
    !false --> true

5. 位运算符(了解)

对内存中的二进制数据进行直接操作的运算符.
只能操作整数, 不能操作小数
如果想让数据快速求出乘2或者2除的结果,就可以使用这个符号,比直接做*和/的效率要高的多.

• <<

  左移运算符 ,每移动一位,相当于乘以2的一次方. 移动几位就乘以2的几次方.

  5 << 1  5 * 21 = 10

• 右移运算符, 每移动一位,相当于除以2的一次方,移动几位就除以 2个几次方

  8 >> 1  8 / 2 = 4
  -16 >> 2 -16 / 4 = -4

• 无符号右移运算符: 每移动一位,相当于除以2的一次方,移动几位就除以 2个几次方

  只能操作正整数. 负数不要使用它操作.

6. 三目(元)运算符

1.    目和元一个意思: 指的就是运算符能操作的数据个数.
2.    三目运算符: 同时能操作三个数据.

• 格式

  • 表达式1 ? 表达式2 : 表达式3;

    1.表达式1: 必须是一个返回值是布尔类型的式子, (如果一个式子返回值是boolean类型,这个式子就称之为布尔表达式).
    2.表达式2和表达式3可以是任意类型结果的式子.

• 运行规则

  1. 计算表达式1的值, 要么为true,要么为false
  2. 如果表达式1计算结果为true, 就会把表达式2的结果当做整个三目运算符的结果返回.
  3. 如果表达式1计算结果为false, 就会把表达式3的结果当做整个三目运算符的结果返回.

(三)、流程控制

流程:在一个程序中，有很多很多的代码，代码执行的顺序就是所谓的流程。
流程控制:Java中用来控制程序中代码执行顺序的方式就是流程控制。

1. 顺序结构

这种执行结构是java默认的流程控制方式，
从上往下逐行执行，一行代码从左向右执行。

2. 分支结构

程序执行到某个状态时，可能会有多种情况，每种情况都是提前准备好的,多种情况的代码最终只能走其中一种情况对应的代码.
特点: 代码写的比较多，但是执行比较少。

• if语句

  • 第一种格式

    if(布尔表达式) {
        语句体；
    }

    if后小括号中必须是布尔类型表达式，这个表达式在这里充当的作用就是当做判断条件。
    语句体：可以写任何的代码

    • 流程说明

      先计算布尔表达式的值，结果只有两个，要么为true，要么为false。
      如果计算结果为：true， 就执行语句体
      如果计算结果为：false， 就不执行语句体

  • 第二种格式(ifelse语句)

    if(布尔表达式) {
      语句体1；
    }else{
     语句体2；
    }

    • 流程说明

      先计算布尔表达式的结果，结果只有两个，true和false
      如果结果为:true,那么就执行语句体1，执行完之后直接跳出if..else语句。
      如果结果为：false，就直接去执行语句体2.执行完之后，跳出if..else语句.

    • 注意事项

      1. 在if..else语句中,语句体1和语句体2,必然会有一个执行.不可能两个都不执行.
      2. 语句体1和语句体2不可能同时执行, 只能执行其中一个.

  • 第三种格式(if语句的级联)

    if(布尔表达式1) {
        语句体1;
    } else if (布尔表达式2) {
        语句体2;
    }else if(布尔表达式3) {
       语句体3;
    }... else if(布尔表达式n ){
       语句体n;
    }else {
       语句体n+1;
    }

    • 流程说明

      1. 计算条件表达式1,如果为true,就执行语句体1,跳出if级联语句
      2. 表达式1为false, 继续计算条件表达式2的结果, 如果为true,执行语句2.跳出if级联语句
      3. 条件表达式2为false,继续计算条件表达式3的结果,如果为true,执行语句体3,跳出if级联语句
      4. 只要上一个条件表达式为false,就会继续向下判断
      5. 如果条件表达式n也不成立,就会执行最后的else后大括号内的语句体n+1

    • 使用总结

      如果程序执行第n条件语句后的语句体,说明第n个条件语句为true.而且说明前面的n-1条件表达式结果都是false.
      如果省略了最后的else语句, 可能if级联语句中,没有一条语句体执行.
      最后的else是可以省略的
      如果加了else语句.那么if级联语句中,必然会有一条语句体执行.

• switch语句

  switch: 英文单词的含义: 开关;
  case: 情况 
  break: 破坏, 退出, 跳出 
  default: 默认

  switch语句中有各种情况,情况对应的就是case. 每个case就相当于是一扇门一样.
  通过开关里的数据跟case后面数据比较,如果相等,就能打开这扇门,执行case后的代码.

  • 格式

    swtich(表达式) {   表达式会有结果: 数据 
        case 常量1:
             语句体1;
             break;
        case 常量2: 
             语句体2;
             break;
        ...
        case 常量n: 
            语句体n;
            break;
        default:
            语句体n+1;
             break;
    }

  • 执行流程

    计算switch后表达式的值
    使用表达式的值,从上到下分别给每个case后的常量值比较,如果相等就进入case执行里面的语句体.碰到break,就跳出switch语句.
    如果表达式的值,和每个case后的常量值都不相等,就会执行default语句中内容.

  • 注意事项

    • switch中小括号: 表达式的类型

      jdk1.5之前表达式只能是: byte, short, int , char
      jdk1.5: 枚举类型 
      jdk1.7: String类型

    • case后只能跟常量,不能变量

      case后的常量类型,要和switch后小括号中表达式返回值类型一致.

    • 每个case后的语句体,必须都要跟break吗?

      可以不写break,语法检测不会报错. 但这种写法是有使用场景的:(当多个case对应处理方式是相同的,可以省略前面case中break. )简化代码.
      case是有穿透效果的,只有一个case满足条件之后,就会进入case后执行语句体,碰不到break就会一直往下钻,直到碰到break,才会跳出.
      break不能省略的情况是,每个case后对应的处理方式都不一样,就不能省略break;

    • default可不可以省略?

      可以省略, 省略之后就会导致没有一条语句体执行.

    • default只能出现最下面的吗?

      不是, 可以出现在任意位置.
      不会影响所有case都不满足,最后去执行default.
      虽然可以出现在任何位置,但是一般都写在最下面.

    • swtich语句执行结束的方式

      碰到:break.
      碰到右侧大括号

    • case后的常量值不能重复

• switch语句和if级联

  • 1.都可以处理多种情况
  • 2.执行的都是从上到下逐个比较条件是否成立
  • 3.如果所有的条件都不满足,switch执行default的内容,if级联执行else

3. 循环结构

程序执行到某个状态时，根据判断条件是否成立，如果成立，就反复执行某一段相同或者相似的代码，
特点： 代码写的少，但是执行次数多

• for循环 [最常用的]

  • 格式

    for(①循环变量初始化 ; ②循环结构的判断条件; ④循环变量的变化){
          ③反复执行某一段相同或者相似的代码; 循环体;
    }

    数字步骤: ①--> ② ---> ③ ---> ④ ---> ② --> ③ ---> ④ ----> ②---> ③ ---> ④---> ③ ---> ④....--> ②

    1.循环变量初始化: 定义一个变量,用来记录循环次数
    2.循环结构的判断条件: 必须是一个boolean类型表达式,结果为true,条件程序,表示循环可以继续执行. 结果为false,循环条件不成立,循环就会停止. 作用:用来决定循环能够继续执行的条件.
    3.循环变量的变化: 用来改变循环变量初始化时定义的变量中的值. 可以自增,也可以是自减.
    4.反复执行某一段相同或者相似的代码: 就是循环判断条件满足时需要执行的内容

  • 执行步骤

    1. 先执行循环变量的初始化
    2. 执行循环的判断条件,如果结果为false,循环直接结束.
    3. 如果结果为true. 执行循环体语句.
    4. 执行循环变量变化操作.
    5. 回到第2步

  • 注意事项

    • 1.循环变量初始化语句,在整个循环中,只会执行一次.
    • 2.循环判断条件必须是boolean表达式
    • 3.循环语句中小括号后一定不要加分好
    • 4. 循环变量变化: 即可以自增,也可以减, 增量也不一定每次都是1.

• 2.while循环 [常用]

  • 格式

    循环变量初始化;
       while(循环判断条件) {
       循环体;
       循环变量的变化;
    }

  • 执行流程

    1. 执行循环变量初始化语句
    2. 执行循环判断条件, 结果如果为false, 循环结束
    3. 结果如果true,循环体, 循环变量的变量
    4. 回到第2步

  • 注意事项

    • 1.循环判断条件,必须是布尔类型表达式
    • 2.一定不要忘了循环变量的变化.

• for和while循环的区别

  • for循环定义循环变量,只能在for循环中使用.出了for循环就不能使用过

  • while循环中定义循环变量,出了while依然可以使用.

  • 使用场景不同

    • 如果一个循环我们知道具体会循环多少次, 就使用for循环来完成.
    • 如果一个循环我们不知道具体循环次数, 但是我只知道循环结束的条件,就是用while循环

• 死循环

  无限循环, 循环永远都不停止.

  • 格式

    • for循环

      for(;😉 {
            循环体语句;
      }

    • while循环

      while(true) {
        循环体语句;
      }

  • 使用场景

    在开发中有的时候就会使用死循环,虽然判断条件上永远成立,感觉不会停下来,但是我们会在死循环加入一些控制循环的语句, 能够在循环中让循环停掉.
    在服务器设计中,我们希望服务器程序永远运行下去,就把服务器程序写到死循环中.

• 跳转语句

  在循环的循环体语句中, 用来结束循环,控制循环执行的语句

  • continue语句

    结束本次循环, 继续下次循环;

  • break语句

    结束当前层的循环.

• 循环嵌套

  一个循环中写了另一个循环,这种格式就是循环的嵌套.

  • 格式

    for(初始化语句1; 循环判断条件1; 循环变量改变1) {
         for(初始化语句2; 循环判断条件2; 循 环变量改变2) {
               循环体;
    }
    }

  • 执行流程

    初始化语句1;
    循环判断条件1, 计算结果为false,外层循环结束.
    循环判断条件1,计算结果为true, 执行初始化语句2;
    循环判断条件2, 计算结果为false, 内层循环结束. 执行循环变量改变1, 回到第2步
    循环判断条件2, 计算结果为true, 执行循环体, 执行循环变量改变2, 回到第4步.

三、方法

deft: 能完成特定功能的代码段

出现原因:

如果某段代码(某个功能)经常被使用, 每次用都要写一遍,做的都是重复(类似)的操作, 为了简化程序的设计难度, 使用一个大括号,把这段代码包裹起来, 然后取一个名字, 将来要使用这段代码的时候,直接使用这个名字就可以访问这段代码.

好处:

• 1.提高了代码的复用性

• 2.提高了代码的封装性,也能提高程序的安全性.

  别人在使用方法是不能直接看到内部的实现,他只需要会调用即可.

• 3.简化了程序的设计难度

格式:

修饰符 返回值类型 方法名(参数列表) {
          方法体;
}

• 修饰符

  用来修饰方法访问权限,

• 返回值类型

  方法内部产生数据的数据类型.
  注意:没有数据产生这里写: void (空)

• 方法名

  就是给封装的代码段起的名字,小驼峰命名法,见名知意即可.

• 参数列表

  这段代码要完成功能时,可能会需要一些数据, 这些数据就需要通过参数列表传入到方法的内部. 需要告诉调用者你要传入什么类型数据.

  参数列表的书写格式 (数据类型1 参数名1, 数据类型2 参数名2, ...) 这样调用者就知道要传入什么类型数据,以及传入几个数据.

• 方法体

  能完成特定功能的代码段

  如果方法内部有数据产生, 需要使用return(返回)关键字, 把方法内部产生的数据返回给调用者.
  return 数据;
  只要方法的返回值类型不是void.就必须写return,把要返回的数据跟到后面.

调用:

方法名(实际参数)

实际参数: 就是让方法执行,真实传入的数据

• 直接调用

  使用没有返回值产生的方法 
  方法名(实际参数);

• 赋值调用

  必须是有返回值产生的方法,
  数据类型 变量名 = 方法名(实际参数);

• 打印(输出)调用

  必须是有返回值产生的方法

(一)、分类

分类

• 1. 无参数无返回值 -->无参无返

  修饰符 void 方法名() {
     方法体;
  }

• 2. 无参数有返回值 --> 无参有返

  修饰符 数据类型 方法名() {
     方法体;
     return 数据; 
  }

• 3. 有参数无返回值 --> 有参无返

  修饰符 void 方法名(数据类型1 参数名1, 数据类型2 参数名2,....) {
      方法体;
  }

• 4. 有参数有返回值 -->有参有返

  修饰符 数据类型 方法名(数据类型1 参数名1, 数据类型2 参数名2,....) {
     方法体;
   return 数据;
  }

注意事项

• 定义方面

  1. 方法是不能嵌套定义的, 方法必须定义一个类后面的大括号中
  2. 方法定义先后是没有区别的
  3. 方法之间是平级的关系,没有优先级

• 调用方面

  1. 方法是可以嵌套调用的, 就是在一个方法中调用其他方法
  2. 甚至一个方法可以自己调用自己, 这种现象叫做递归调用, 递归有风险, 效率极低(实际开发中基本不用)

• 参数方面

  1.定义方法的时候,叫做形式参数 (形参), 形参的书写格式 (数据类型 参数名, 数据类型 参数名, ...)  每个参数名前都要数据类型, 每定义完一个后要加逗号, 如果是最后一个就不加,
  形参的作用: 告诉调用者需要什么类型数据以及的数据的个数.

  2.调用方法的时候, 叫做实际参数(实参), 就是真正参与执行的数据, 
  1 实参不要数据类型(直接常量, 变量名 )
  2 实参的数据类型一定要形参的数据类型一致(形参式类型,实参可以是小类型) 
  3 实参的个数一定要形参的个数一致
  4 实参的顺序一定要形参的顺序一致

• return语句

  第一个作用,就是把有返回值的方法中产生的数据返回给调用者 return 数据;
  第二个作用, 可以提前结束一个方法, 一般用来结束返回值为void的方法.
  如果一个方法的返回值类型不是void, 那么就必须提供return语句.
   一个方法如果没有数据产生,也可以写return关键字, 但是必须写为: return; 表示提前结束方法, 即使写也是放到判断语句中.
  return语句之后不要在写代码了,方法执行时执行完return方法就结束,

(二)、重载

在同一个类中, 方法名相同,但是参数列表不同,与返回值类型无关, 这样多个方法之间的关系就是重载. 
重载描述的是方法和方法之间的关系

说明:
在同一个类中: 必须是写在一个类中的方法, 不同类的中是不可能发生重载的.
方法名相同: 方法名要一模一样
参数列表不同: 参数的类型不同, 参数的个数, 参数的顺序不同. 与参数的名字没有关系. 
与返回值类型无关: 即使返回值类型不同, 也不算重载, 这叫做方法重复.

• 好处

  有了重载后,同一个类中相同逻辑的代码段,就可以只取一个名字, 定义方法的人工作量减轻了,调用者只需要记忆一个名字,就能访问多个相同逻辑的方法.

四、数组

deft: 用于存储多个相同数据类型数据的一个容器

出现原因:

要存储多个相同类型数据, 就需要定义多个变量来存储, 每个变量名都不一样, 每个变量之间是没有关系的. 此时想访问多个数据, 就会比较困难.

有了数组之后: 存储多个相同类型数据时,只需要定义一个容器, 一次开辟多个数据需要内存空间, 每个数据所占的内存空间是连续的, 会对数据所占的内存空间进行编号, 这时候这些数据就有了规律. 就可以通过指定的编号, 有规律访问所有的数据.

格式:

• 标准格式

  元素数据类型[] 数组名 = new 元素数据类型[元素的个数];

  • 元素: 就是数组中要存储的数据, 每一个数据都是一个元素
    元素数据类型: 指明数组要存储什么类型的元素. 可以跟据元素数据类型来申请内存空间, 用来决定每个元素所占内存空间大小
  • [] : 数组定义标志, 只写一个中括号,表示定义的是一个一维数组
    数组名:　数组本身也是一个变量，　数组名就是变量名，数组名存储的是数组在内存中的地址．
  • =: 赋值运算符, 作用将数组的地址赋值给数组名存储
  • new: 单词含义:新建,创建 new表示在堆内存中申请内存空间
  • 元素数据类型: 保证和前面的元素数据类型一致即可

1. 数组的地址

[: 表示打印的是一个一维数组 
I: 表示数组中数据类型, I表示数组中存储的是int类型的元素
@: 就是一个普通分隔符,没有任何意思
16进制: 0, 1, 2, 3, 4 ,5, 6 ,7, 8, 9, a, b, c, d, e, f
15db9742: 数组是有内存地址的,这个内存地址经过一个叫HashCode方法,计算之后得到一个哈希值, 15db9742就是数组的哈希值. 这是一个16进制的数据

2. 初始化

为数组分配内存空间, 并且赋值

• 动态初始化

  程序的运行过程中, 才知道究竟为数组的每个元素赋了什么值.

  • 定义数组

    元素数据类型[] 数组名 = new 元素数据类型[元素个数];

  • 通过 数组名[索引] 为元素赋值

    索引: 又称之为下标, 脚标, 角标, 其实就是数组对元素的编号, 元素的编号从0开始,最大到元素到元素个数-1;

    数组名[索引]给元素赋值的格式: 
                数组名[索引] = 元素值; 
    取出数组元素值的格式: 
                数组名[索引] 
    数组名[索引] 就可以看一个变量使用.
    

  • 总结

    我们定义数组的时候,只知道数组的长度(元素个数), 所有的元素的需要: 逐个赋值
    如果我们不给数组的元素赋值: 数组的元素有默认值的 
    整数数组: 默认值0
    小数数组: 0.0
    字符串数组: null
    布尔数组: false
    字符数组: ‘ ’

• 静态初始化

  在程序书写的时候,就已经知道数组的存储的元素是什么了. (没有运行的时候)

  静态初始化的完整版, 可以先定义,后赋值
  静态初始化的语法糖格式: 只能定义的同时赋值

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

  • 语法糖格式

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

  • 注意事项

    1. 第二个元素数据类型后中括号内一定不要写元素个数
    2. 大括号内元素罗列时, 每个元素以逗号分隔, 最后一个元素就不要加逗号, (可以加)
    3. 大括号内罗列的元素,一定要元素数据类型一致

• 使用场景

  • 动态初始化的使用场景

    知道定义数组的长度,而不知道应该往数组中存储那些元素的时候,就是用动态初始化;

  • 静态初始化的使用场景

    定义数组的就是知道应该往数组中存储那些元素,就是用静态初始化.

3. 常见异常

异常指的就是程序出问题了, 程序出现问题之后,jvm认为就没有必须继续执行下去了,程序会直接停止.

• 数组索引越界异常

  • 产生原因

    访问了数组中不存在的下标, 因为数组的下边范围[0, 数组长度-1].这个范围才是合法的范围. 只要超出这个范围都会报这个异常.

  • 解决方法

    每次操作下标时，先判断是否在合法范围．在的话才访问．

• 空指针异常

  所有引用类型的数据都有可能爆发空指针异常

  • 解释

    1.空: 就是null, 表示没有指向任何堆区的空间 
    2.指针: 是C语言中概念, C语言中认为内存地址就是指针. 很多语言的指针的概念都是从C语言继承过来, java也不例外, 所以在java中,指针概念就是舶来品(偷过来).
    3.数组名如果存储的是null, 表示不指向任何堆区位置,此时就不要使用数组名操作任何东西,否则就会报空指针异常.

  • 避免方式

    判断数组名中存储的内容是不是null, 如果是就不操作, 如果不是才操作.

4. 两个引用指向同一数组

指的就是两个数组名中,存储的是同一个堆区数组的地址.
只要使用其中的数组名修改数组的元素.
使用另一个数组名访问时就是修改之后的结果.
因为它俩操作的是同一块内存空间

• 引用

  引用也是内存中一个变量,
  这个里面存储不是数据,而是堆区的地址.
  简单理解:一个变量存储的不是数据,而是堆区的地址,管这样的变量叫做引用.
  以后我们管存储着地址的变量叫做: 引用类型的变量
  数据地址指的就是引用

5. 常见操作

• 数组的遍历

  1. 遍历: 就是把一个容器中数据,全部取出来打印(操作)一遍.
  2. 数组的遍历: 把数组中元素一个一个取出来,打印(操作)一遍.

  • 穷举法

    一个一个使用输出语句把数组中元素打印一遍. (几乎不用)

  • 循环的方式

    使用for循环根据下标变化取出数组的一个一个元素. 以后常用的方式

    循环变量存储就是数组元素的下标(索引)
    循环变量起始值: int i = 0
    循环的结束条件: i < 数组长度
    增量: i++
    循环体: System.out.println(数组名[i])

    • 获取数组长度:数组名.length

• 获取数组种最大值

• 数组的反转

• 数组元素的查找

五、JVM内存划分

1. 栈内存［常用］

用于执行方法，
每一个方法进入栈内存中会分配一个独立空间，称之为栈帧．
方法中定义的变量都在方法栈帧中开辟空间．　
每个方法执行的时候称之为入栈，每个方法执行完就会出栈．
先进后出，后进先出 
普及知识: 队列方式：　先进先出

2. 堆内存［常用］

用于存储数组，对象等引用类型的数据，　
存储都是引用类型的数据

3. 方法区［常用］

用于存储执行程序时用到的字节码文件对象，存储常量（常量池）.

4. 本地方法区［不常用］

用于执行本地方法，
这些本地方法都是用Ｃ和Ｃ＋＋的写的．

5. 程序计数器［不常用］

用来决定程序的执行顺序，
控制程序执行那段代码