初识Java

Java语言

Java是一门编译解释性语言。

语言书写规范

Java程序必须是一个完整的class或interface

类名命名规则

• 法律原则

  绝对需要遵循，违反则编译不通过。

  • 1. 类名只能以数字大小写字母下划线美元符号组成，其他内容会导致编译不通过。
  • 2. 类名不能以数字开头，不允许有全数字组成的类名出现。
  • 3. 若存在public类，则文件名必须与public类名相同。
  • 4. 一个Java文件中至多出现1个public类
  • 5. 一个Java文件中不能出现重复的同名类

• 道德原则

  可以不遵循，但遵守会对Java的使用和维护有好处。

  • 1. 类名遵循大驼峰命名法则（首字母大写，连续单词字母开头字母大写）
  • 2. 尽量少使用数字下划线美元符号
  • 3. 不使用中文作为类名称
  • 4. 类名尽量不要超过15个字符，单词如果过长使用缩写

基本数据类型

四类八种

整型

编辑器默认为int类型

• byte

  • 1个字节表示，取值范围为-128~127

• short

  • 2个字节表示，取值范围为-32768~32767

• int

  • 4个字节表示，取值范围为

• long

  • 8个字节表示，取值范围为

    • 对于给long赋值超过int范围的数值时，必须在数值后添加小写的l使编辑器认为这个数值类型为long，不为int。

浮点型

计算机的浮点数与真正的小数存在精度差异，因此不能称为小数，浮点数是在目标小数上下浮动的数。
编辑器默认为double类型

• float

  • 4个字节

    • 给float类型赋值时，数值后需加小写的f

• double

  • 8个字节

字符型

• char

  • 2个字节

布尔型

• Boolean

  值只能为True或False

  • 动态字节（4字节，数组时为1字节）

语义与语法

语义

• 运算符

  • 算术运算符

    • +，-，，/，%（取模），–，++（源地址上加1），+=，-=，=，/=

      • 3/0 编译通过，运行提示数学错误
        3(f)/0 编译通过，运行显示Infinity
        0.0 /0 编译通过，运行显示NaN --意思结果不是一个数字
        3(f)%0 编译通过，运行显示NaN

  • 位运算符

    • • 向右移位，符号位按源数据符号位补值。相当于/2的幂次方

    • <<

      • 向左移位，符号位按源数据符号位补值。相当于*2的幂次方

    • • 向右移位，符号位补0。

    • &

      • 按位比较，同1得1

    • |

      • 按位比较，见1得1

    • ^

      • 按位比较，相同取0，不同取1

    • ~

      • 按位取反，01互换。

  • 关系运算符

    • ==
    • !=
    • <

    • =

    • <=

  • 逻辑运算符

    • &

      • 或，见假得假

    • |

      • 与，见真得真

    • &&

      • 短路或，若之前已判断为false，则不再执行之后内容。

    • ||

      • 短路与，若之前已判断为true，则不再执行之后内容。

  • 特殊运算符

    • 优先级运算符（）

      • 可以改变优先级

    • 赋值运算符=

      • 将等号右边得值赋给左边

    • 三目运算符Boolean?ele1:ele2

      • 若Boolean为真，执行ele1，若为假，执行ele2

• 运算符的优先级

  • 1. 一般来讲 算术运算符 > 位运算符 > 关系运算符 > 逻辑运算符 > 特殊运算符
  • 2. 优先级运算符优先级最高，赋值运算符优先级最低。
  • 3. 对于有目数的运算符，目数低的优先级比目数高的优先级更高。

语法

• 表达式

  通过将标识符，运算符和字面量按照一定的规则，结合到一起，得到一个结果的的式子，叫做表达式。

• 流程控制

  在没有流程控制之前，代码的执行顺序是依次从上到下，从左往右执行的。
  流程控制可以在一定的程度上，改变代码的执行顺序，跳过部分代码或重复部分代码都是流程控制的作用。
  常见的流程控制有if，for，swich，while，do，do…while

  • 分支

    遇到了某个条件成立，那么就可以选择一个分支执行，当然也可以认为某些条件不成立，就选择，或者跳过一个分支去执行。

    • if

      • 格式

        • if(boolean) {code} || if(boolean) {code} else {code}

      • 使用范围

        • 适用于连续性条件判断和离散型条件判断，但一般不适合于离散型条件判断

      • 注意

        • Java中没有else if语法。
        • 遇到了某个条件成立，那么就可以选择一个分支执行，当然也可以认为某些条件不成立，就选择，或者跳过一个分支去执行。

    • switch

      • 格式

        • switch(标识符) {
          case 目标值:
          code
          case 目标值:
          code
          …
          default:
          code
          }

          • 标识符类型可以是整型中的byte，short，int，字符型，字符串。
            标识符类型不可以是整型中的long，浮点型和布尔型

      • 使用范围

        • 只能适应于离散型条件判断

  • 循环

    条件被满足时，重复执行某一个部分的代码。

    • for

      • 格式

        • for(1;2;3) {4}

          • 1：初始化部分，可以省略，含义是只有在for循环第一次执行开始的时候，才会执行1部分的代码
          • 2：条件判断部分，默认是必然成立的，每一次循环完成，准备开始下一次循环之前必然需要执行一遍2部分代码(不填默认是true)
          • 3：条件改变部分，每次循环的代码块执行完成后，先执行3部分代码,来改变循环条件
          • 4：循环的代码块

      • 使用范围

        • 循环次数已知的循环

      • foreach增强型for循环

        • 格式

          • for(int item : array) {
            System.out.print(item + “\t”);
            }

    • while

      • 格式

        • while(boolean) {code}

      • 适用范围

        • 次数未知，知道退出循环的状态

    • 递归

• break

  • 作用于最近的循环，作用是跳出循环。

• continue

  • 作用于最近的循环，作用是跳出本次循环，继续执行下一次循环。

• 数组

  一个连续不断的内存空间，用来保存相同类型内容的一个容器。

  • 格式

    • 一维数组

      • 类型[] 标识符

    • 二维数组

      • 类型[][] 标识符

    • 多维数组

  • 操作

    • 定位

      • array[] array[][]

    • 替换

    • 求长

      • array.length

        • 一维数组的长度或者二维数组行的长度

      • array[i].length

        • 二维数组i行的列长度

  • 赋值

    • 静态赋值

      • int[] array = {1,2,3} --创建了一个长度为3，内容为1，2，3的一维数组
      • int[][]array = {
        {1,2,3},
        {1}
        }

    • 动态赋值

      • int[] array = new int[10]; --创建了一个长度为10的默认填充内容均为0的一维数组
      • int[][] = new int[10][]; – 创建一个10行0列的二维数组
      • int[][] = new int[10][10]; --创建一个10行10列填充内容默认为0的二维数组

变量

变量可分为局部变量和全局变量

格式

• 类型 标识符
• 类型 标识符 = 字面量

规范

• 变量必须先声明再使用
• 局部变量在使用前必须赋值
• 局部变量不能重复声明

类

是用来描述对象的模板，是通过抽象和封装过程得到的

类型

• 主类

  具有main方法的类，叫做主类或者场景类

• 父类||基类||超类

• 子类||延展类||SUB类

• 包装类

  基础类型的对象类型

  • 整型

    • Byte

      • BYTES – 字节数
      • SIZE – 位数
      • parseByte() – 转换为基础数据类型，给一个字符串转换为byte
      • valueOf() – 字符串转换为对应的包装类型
      • MAX_VALUE – 返回最大值
      • MIN_VALUE – 返回最小值

    • Short

      • BYTES – 字节数
      • SIZE – 位数
      • parseShort() – 转换为基础数据类型，给一个字符串转换为short
      • valueOf() – 字符串转换为对应的包装类型
      • MAX_VALUE – 返回最大值
      • MIN_VALUE – 返回最小值

    • Integer

      • BYTES – 字节数
      • SIZE – 位数
      • parseInt() – 转换为基础数据类型，给一个字符串转换为int
      • valueOf() – 字符串转换为对应的包装类型
      • MAX_VALUE – 返回最大值
      • MIN_VALUE – 返回最小值

    • Long

      • BYTES – 字节数
      • SIZE – 位数
      • parseLong() – 转换为基础数据类型，给一个字符串转换为long
      • valueOf() – 字符串转换为对应的包装类型
      • MAX_VALUE – 返回最大值
      • MIN_VALUE – 返回最小值

  • 浮点型

    • Float

      • BYTES – 字节数
      • SIZE – 位数
      • parseFloat() – 转换为基础数据类型，给一个字符串转换为float
      • valueOf() – 字符串转换为对应的包装类型
      • MAX_VALUE – 返回最大值
      • MIN_VALUE – 返回最小值

    • Double

      • BYTES – 字节数
      • SIZE – 位数
      • parseDouble() – 转换为基础数据类型，给一个字符串转换为double
      • valueOf() – 字符串转换为对应的包装类型
      • MAX_VALUE – 返回最大值
      • MIN_VALUE – 返回最小值

  • 字符型

    • Character

      • BYTES – 字节数
      • SIZE – 位数
      • valueOf() – 字符串转换为对应的包装类型
      • MAX_VALUE – 返回最大值
      • MIN_VALUE – 返回最小值

  • 布尔型

    • Boolean

      • parseBoolean() – 转换为基础数据类型，给一个字符串转换为boolean
      • valueOf() – 字符串转换为对应的包装类型

  • 自动装箱

    • 自动将基本数据类型转换为包装器类型

  • 自动拆箱

    • 自动将包装器类型转换为基本数据类型

  • 冷知识：Java在处理小于128的整型包装类时都是放置在字符常量池中的

格式

• 返回名类型 方法名(参数列表) {代码块}

访问控制

• public

  • 所有位置上都可以使用

• protected

  友元访问

  • 同包和继承可以使用

• default

  • 默认设置，同包可用

• private

  • 只有本类可以使用

构造方法

默认会给1个没有参数，没有方法体的构造方法，用来创建方法。

• 构造方法遵循大驼峰命名规则
• 真正意义上的没有返回值，方法不能有返回值的描述，void不可以加
• 这个方法一般是在new方法后调用的，是用来创建这个类的对象的。
• 如果我们不写这个方法，那么Java会给一个没有参数，没有方法体的默认的构造方法。
• 任何的类中，都有构造方法。
• 子类构造方法第一行必须调用直接父类的构造方法，Java默认会隐式调用无参的构造方法

重写

• 子类中重新定义父类中已经存在过的方法的过程叫做重写。
• 重写的英文叫做Override
• 重写过程中访问控制只能扩大，不能缩小
• @Override叫做注解，下面这个注解的作用是告诉编译器eat这个方法
• 是从父类继承过来的，并且在本类中重新实现的

重载

• 方法名一致，但是方法的参数列表从类型，个数，顺序三个方向考量，是不一致的

继承

• 类与类之间只支持单继承和链式继承，任何类都是Object的子类

• 里氏替换原则

  • 在任何可以使用父类对象的位置上，都可以使用子类对象替换。

• 子类构造方法第一行必须调用直接父类的构造方法，Java默认会隐式调用无参的构造方法

继承

abstract 
这个东西是个关键字，它可以用来修饰类型和方法，他的意思是指这个类型或者方法是抽象的，是不知道里面是如何
实现的，也不用知道是如何实现的。

• 抽象类

  被abstract修饰的类型，抽象类是具有承载抽象方法的能力的类型。
  抽象类存在的意义就是被继承，抽象方法存在的意义就是被重写；
  抽象类没有对象。

• 抽象方法

  只知道方法的特征（方法名，返回值类型，参数列表），但是不知道方法具体应该怎么实现的方法，叫做
  抽象方法，抽象方法应被abstract关键字来修饰。
  普通类不能承载抽象方法，只有抽象类才能承载抽象方法
  抽象方法没有方法体。

接口

所有的属性都默认加public static final

接口中的方法为抽象方法或静态方法或普通方法，静态方法和普通方法有方法体

接口不能承载普通方法，具有承载抽象方法的能力

接口没有构造方法

Java针对接口是多实现

类与接口之间是实现和被实现的关系

接口与接口之间是继承关系

常用类

java.lang

• 不需导入即可使用的包

String

String是一个类型，遵照Java对于类型的定义，使用一维char类型的数组实现，不可继承，不可修改

• 求长

  • length() – 求长

• 定位

  • 知道角标求内容

    • charAt() – 返回角标对应的单个字符，角标范围不能越界
    • substring() – 返回规定角标之间的内容，角标范围不能越界

  • 知道内容求角标

    • indexOf() – 返回从前往后查找字符串开头所在的角标，没有返回-1，输入数值可以超过数组角标，但前值必须不大于后值
    • indexOf() – 返回从后往前查找字符串开头所在的角标，没有返回-1，输入数值可以超过数组角标，但前值必须不大于后值

  • 是否包含字符串

    • contains() – 查找是否包含字符串，返回布尔值

  • 是否开头

    • startsWith() – 是否以字符串开头，返回布尔值

  • 是否结尾

    • endsWith() – 是否以字符串开头，返回布尔值

• 替换

  • String不能直接替换内容

• 特殊方法

  • replace() – 替换
  • concat() – 拼接
  • toUpperCase() – 变大写
  • toLowerCase() – 变小写
  • equals() – 先匹配是否是同一类的实例，不是返回false，是匹配内容，内容相同则返回true，不同返回false
  • contentEquals() – 直接比较内容
  • trim() – 去除字符串两端开头的空格
  • isEmpty() – 内容是否为空str = ("");
    注意：str=null不能用
  • split() – 按照规律分割字符串
  • compareTo() – 按照字典序比较字符串，返回int类型

StringBuffer

针对String的操作工具类，是个容器

• 求长

  • length() – 求长

• 定位

  • 知道角标求内容

    • charAt() – 返回角标对应的单个字符，角标范围不能越界
    • substring() – 返回规定角标之间的内容，角标范围不能越界

  • 知道内容求角标

    • indexOf() – 返回从前往后查找字符串开头所在的角标，没有返回-1，输入数值可以超过数组角标，但前值必须不大于后值
    • indexOf() – 返回从后往前查找字符串开头所在的角标，没有返回-1，输入数值可以超过数组角标，但前值必须不大于后值

• 替换

  • 可以直接修改内容，强于String

    • append() – 后接
    • delete() – 删除
    • insert() – 插入
    • replace() – 替换
    • reverse() – 倒序

StringBuilder

Arrays

操作数组的工具类

• toString() – 转成字符串
• sort() – 排序（只能比较可以比较的内容，如果需要将不能比较的内容转为可以比较的内容，需要实现Comparable接口，重写compareTo()方法
• parallelsort() – 多线程排序
• copyOf() – 复制到
• copyOfRange() – 范围复制
• fill() – 填满

Random

• nextInt

  • 生成1个int范围内的随机数

• nextInt（int bound）

  • 生成1个0到bound（不含bound）的随机数，因此bound必须为大于0的正整数。

  • 扩展

    • random.nextInt(31) + 30
      31–宽度 30–起始点

• nextLong

• nextFloat

• nextDouble

• nextBoolean

Math

• abs()

  • 绝对值

• max()

  • 返回最大值

• min()

  • 返回最小值

• random()

  • 返回值为 double值 为正号，大于等于 0.0 ，小于 1.0

容器

求长

• size()

定位

• indexOf()
• lastIndexOf()
• get()

替换

• add()
• set()
• remove()

List

List是有序的 collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。

用户插入的顺序或者指定的位置就是元素插入的位置。它与Set不同，List允许插入重复的值。

List 接口提供了特殊的迭代器，称为 ListIterator，除了允许 Iterator 接口提供的正常操作外，该迭代器还允许元素插入和替换，以及双向访问。

• ArrayList

  1.8之前必须写之后的Integer 1.8之后不用必须写 类型的推倒 语法糖 ArrayList list = new ArrayList();

  • 求长

    • size（）

  • 定位

    • get()
    • indexOf()
    • lastIndexOf()
    • contains()

  • 替换

    • add()
    • set()
    • remove() – 从左往右删除找到的第一个

  • 遍历方法

    • 一个一个取出

      • for(int i =0;i < size;i++) {}

    • foreach增强for循环

      • 增强for循环是语法糖，增强for循环底层是使用迭代器实现的

    • 迭代器

      • hasNext() – 有没有下一个值
      • next() – 下一个
      • remove() – 移除游标所在位置的值

• LinkedList

• ArrayList与LinkedList区别

  • ArrayList取值快，LinkedList删除插入元素快

Set

Set，顾名思义，集合的意思。java的集合和数学的集合一样，满足集合的无序性，确定性，单一性。所以可以很好的理解，Set是无序、不可重复的。同时，如果有多个null，则不满足单一性了，所以Set只能有一个null。
Set类似于一个罐子，丢进Set的元素没有先后的差别。
Set判断两个对象相同不是使用"=="运算符，而是根据equals方法。也就是说，我们在加入一个新元素的时候，如果这个新元素对象和Set中已有对象进行注意equals比较都返回false，则Set就会接受这个新元素对象，否则拒绝。
——因为Set的这个制约，在使用Set集合的时候，应该注意两点：
为Set集合里的元素的实现类实现一个有效的equals(Object)方法；
对Set的构造函数，传入的Collection参数不能包含重复的元素。

Map

• HashMap

  • 求长

    • size()

  • 定位

    • get()
    • getOrDefault()

  • 替换

    • put()
    • replace()

  • 特殊方法

    • keySet() – 拿出所有的键，返回结果是Set
    • values() – 拿出所有的值，返回结果是Collection

• HashMap

  • 求长

    • size()

  • 定位

    • get()
    • getOrDefault()

  • 替换

    • put()
    • replace()

  • 特殊方法

    • keySet() – 拿出所有的键，返回结果是Set
    • values() – 拿出所有的值，返回结果是Collection

• HaseSet

  • 可以认为没有顺序，底层是一个HashMap

• LinkedHashMap

  • 有顺序，顺序为放入顺序

• TreeSet

  • 有顺序，顺序是字典序升序，保存的内容必须实现Comparable接口

错误与异常

关键字

• throw
• throws
• try
• catch
• finally

错误

• error

异常

• exception

  • 继承Exception

    • 继承Throwable

迭代器

Iterator

hasNext()

next()

remove()

进程与线程

进程

• 执行同一任务的容器，管理线程的包
• 管理任务的最小单元

线程

• CPU处理任务的最小单元

• 独占区域

  • 程序计数器
  • 本地方法栈
  • 虚拟机栈

• 共享区域

  • 堆
  • 本地方法区

• synchronized

  • synchronized (对象) {
    代码块
    }

特性

跨平台

组件

JDK

Java development kit
Java开发者工具，是编写Java程序不可或缺的套件，内含JRE和JVM。

JRE

Java runtime environment
运行Java程序必备的套件，内置JVM。

Jvm

全程为Java Virtual Machine
JAVA引入虚拟机使得Java程序编译后不仅修改即可在多种平台运行。JVM是Java程序运行的必备条件。

当我们的程序开始运行的时候，虚拟机（JVM）就将内存已经分配好了，这个时候，JVM给我们一小片空间，来记录当前的代码执行在哪些方法中，哪些属性记录，这些东西都在栈这个空间中。
但是面向对象的语言，有一个特别的特征，就是需要对象去操作业务流程，而栈的大小不能满足很多个对象，所以我们需要将对象放置在堆中。
如果栈里面需要执行的代码，要用到堆里的对象，怎么办？
栈需要记录这个对象在堆里面的位置，并不记录这个对象。

什么时候在堆里面创建对象呢？什么时候在栈里面申明引用呢？
我们把java代码中的，这一行，拆解一下
Item item = new Item();
这一行，其实是两个动作的简写，分别是声明和赋值。

声明：Item item；当代码执行在声明时，JVM会在栈中一个叫做栈帧的东西里面创建一个指向空白的引用（就是C语言的指针），这个空白的引用，指向了null

赋值：当我们写了item = new Item();这个动作又能分成两个部分，第一个部分叫做对象的创建，就是new Item（）；
new这个关键字：最主要的行为，就是在堆里面，划分一片合理的内存空间，用来保存创建的对象

当我们写了=时，这个时候，栈里面的引用就可以和栈里面的内存空间关联上

• 程序计数器

  • 记录程序执行位置

• 虚拟机栈

• 本地方法栈

• 堆

• 非堆 || 元数据区 || 方法区

面向对象

首先，我们要了解面向对象，必须了解第一件事情，java面向对象说：万事万物皆对象
我们认知对象看，是通过自己对这个世界的统一认识出发的，
其中包括提前对于某个对象归属于某个哪个类型的定义
比如说，当我们看到一个手机，由于这个手机符合我们对手机类型的
全定义，所以我们叫这个东西为手机
而我们创建一个相似对象的分类时，使用的工具叫做抽象，就是将描述
这一类对象的名词，当作对象的属性，将描述这一类的名词提取出来作为
属性，描述这一类动词提取出来当作方法，作为模板，任何符合这个模板
定义的对象都属于这个类型的对象
这个模板，在Java中叫做类
而我们说的万事万物皆对象，就是如何用一个类型，创建属于这个类型的对象。

特征

• 封装
• 继承
• 多态