思维导图01----Java语言基础

Java语言基础----思维导图

下载地址: https://download.csdn.net/download/q863672107/20016425

---

以下是自动转换的MakeDown文本

---

JavaSE

1.Java基础(0615)

* 标识符: 标量,类,方法等自己定义的名称就是标识符,掌握合法的标识符规则

* 关键字/保留字

• 关键字
• 保留字: goto, const

变量

• 数据类型
  Java是强类型语言

  • 1.基本数据类型(4类8种)
    存储在栈内存

    • 整 型

      • byte : 1字节(-128~127)
      • short : 2字节(-32768~32767)
      • int : 4字节(-2147483648~2147483647)
      • long : 8字节(-2^31~231-1)

    • 浮点型

      • float : 4字节,单精度
      • double : 8字节,双精度

    • 字符型

      • char : 2字节(0~65535) : 初始值为’\u0000’,判断初始化值==0时返回true

    • 布尔型

      • boolean : 1字节

  • 2.引用数据类型
    引用地址存储在栈内存,
    数据存储在堆内存

    • 类(class)
    • 接口(interface)
    • 数组类型
    • 枚举类型(Enum)
    • 注解类型(Annocation)

• 数据类型转换

  • 1.基本数据类型转换

    • 自动数据类型转换(隐式转换):
    • 强制数据类型转换:

  • 2.引用数据类型转换

    • 向上转型: 子类对象转换为父类对象
    • 向下转型(造型)

• 变量作用域

  • 类变量
  • 成员变量
  • 局部变量

运算/运算符

• 1.赋值运算符

  • =

• 二元运算符

  二元运算符的操作数皆可转化为数字类型时，那么将采用如下二元数值提升规则：

  如果任一操作数为包装类，那么对其进行自动拆箱。

  拓宽类型转换：
  if 某一操作数为double类型，那么另一个也转为double
  else if 某一操作数为float类型，那么另一个也转为float
  else if 某一操作数为long类型，那么另一个也转为long
  else 两个操作数都转为int

  • 2.算数运算符

    • /

    • %,

    • ++ 自增, 注意 i++ 和 ++i 区别

      short s = 1;
      s = s +1;//编译失败
      s +=1;
      s ++;//++ 不会改变本身变量的数据类型

    • • • 自减

  • 3.比较运算符

    • == : 比较基本数据类型

      注意用==判断String对象是否相等的情况:
      String是引用类型对象, == 只能判断字符串常量池的String对象时是否相等 (即通过直接赋值方式创建的String对象)
      不能比较通过new创建的String对象是否相等, 此时 == 比较的是String对象在栈内存中的引用地址

    • !=

    • <

    • =

    • <=

• • 复合算数运算符

  复合算数运算符的特点是不会改变运算符左边变量的类型。
  其实在运算过程中进行了自动类型转换, 后又进行强制类型转换

  • +=

    short s = 1;
    s = s +1;//编译失败
    s +=1;//+= 不会改变本身变量的数据类型

  • -=

  • *=

    int s = 1;
    i *= 0.1;
    System.out.println(i); //打印结果i=0

  • /=

  • %=

• 4.逻辑运算符

  • &
  • |
  • !
  • && 短路与
  • || 短路或
  • ^ 逻辑异或 前后条件判断不同时返回true

• 5.三元(三目运算符)
  简洁, 效率高

  三元运算符的表达式1, 表达式2 同样会执行数值类型提升机制。

  如果任一操作数为包装类，那么对其进行自动拆箱。

  拓宽类型转换：
  if 某一操作数为double类型，那么另一个也转为double
  else if 某一操作数为float类型，那么另一个也转为float
  else if 某一操作数为long类型，那么另一个也转为long
  else 两个操作数都转为int

  • 条件表达式 ? 表达式1 : 表达式2
• • 6.位运算符(了解)

  交换两个变量a,b的值:
  1.
  int temp = a;
  a = b;
  b = temp;
  2.//局限性, a+b可能超出a范围, ±只能用于数值型
  a = a + b;
  b = a - b;
  a = a - b;
  3.
  a = a ^ b;
  b = a ^ b;
  a = a ^ b;

  • << 左移 如: i<<n =i*2^n

  • 右移 如: i<<n =i/(2^n)

    最高位是0, 右移后左边补0
    最高位是1, 右移后左边补1

  • 无符号右移

    无符号右移: 不管最高位是1还是0 ,右移后都补0
    右移会根据左边符号位不同, 区分补1或者补0
    左移不会产生这个问题

  • & 与运算

  • | 或运算

  • ^ 异或运算

  • ~ 取反运算 包括符号位在内

• • 运算符的优先级(了解)

  从上到下,从左到右,优先级由高到低
  . () {} ; ,
  ! ~ – ++

  • / %

  << >> >>>
  < > <= >= instanceof
  == !=
  & ^ | && ||
  ? :
  = *= /= %=
  += -= <<= >>=

  = &= ^= |=

注释

增强可读性
调试程序

• 单行注释

• 多行注释

• 文档注释 : 使用文档注释来注释整个类或整个方法

  java特有 注释内容可以被JDK提供的工具 javadoc.exe 所解析, 生成一套以网页文档形式体现的该程序的说明文档
  /**

  • @author 作者
  • @version v1.0
    */
    dos命令 解析生成文件:
    javadoc -d explainfile -author -version HelloWorld.java

2.流程控制(16/17)

1.顺序结构: 按优先级顺序执行

• • 初始化顺序:

    • 1. 父类静态初始化
      • 1.父类静态变量初始化
      • 1.父类静态代码块执行

    • 2.子类静态初始化

      • 2.子类静态变量初始化
      • 2.子类静态代码块执行

    • 3.父类普通初始化

      • 3.父类成员变量初始化
      • 3.父类普通代码块执行

    • 4.父类构造器执行

    • 5.子类普通初始化

      • 5.子类成员变量初始化
      • 5.子类普通代码块执行

    • 6.子类构造器执行

2.分支结构

• 1.if-else 条件判断
• 2.switch 等值判断, 效率稍高

3.循环结构

初始化部分(init_statement)
循环条件部分(test_statement)
循环体部分(body_statement)
迭代部分(alter_statement)

• 1.for循环 : 已知循环次数, 优先使用for循环

• 2.while循环 : (1)不知道循环次数, 通过条件判断
  (2)循环条件的变量需要被外层调用时, 一般使用while 也能用for, 不写初始化语句

• 3.do-while循环 : 不知道循环次数, 至少执行一次

• • 增强for循环: for each

• 4.流程控制 关键字

  循环嵌套: 优化: 循环次数小的优先放在外层, 次数多的放在内层

  • break : 退出switch或本层循环
  • continue : 结束本次循环
  • return : 从函数返回

  • • Java中的标签

      Java 中的标签是为循环设计的，是为了在多重循环中方便的使用 break 和 coutinue 而设计的。
      Java 的标签只能定义在三种循环 (for() {}, do{} while(), while() {}) 的开始位置。
      　　在循环前面加上标签，就好像给循环起了个名字。而后在循环中使用 break 或者 continue 语句的时候，就可以带上这个标签做为参数，指明跳出 (break) 或者继续 (continue)标签对应的哪个循环，如“break mylabel;”、“continue mylabel;”。

3.数组(0618)

• 数组其实是个容器, 可以存储很多个值
• 数组 是引用类型; 声明数组时定义的数据类型, 代表的是数组中存储的元素的数据类型
• 数组中的元素必须为同一数据类型
• 数组的长度一经确定, 不可改变

1.一维数组

• 初始化

  数组一旦初始化完成, 其长度就是确定的
  数据组长度一旦确定, 不可修改

  • 静态初始化

    • 数组的初始化和元素赋值同时进行

  • 动态初始化

    • 数组的初始化和元素赋值分开进行

• 常见算法:

  • 求值: 最值, 总和, 平均数, 方差, 标准差

  • 复制, 反转, 查找(线性查找, 二分法查找)

  • 排序算法
    时间复杂度,空间复杂度,稳定性

    • 内部排序

      • 选择排序

        • 直接选择排序
        • 堆排序

      • 交换排序

        • 冒泡排序
        • 快速排序

      • 插入排序

        • 直接插入排序
        • 折半排序
        • 希尔排序

      • 归并排序

      • 基数排序

    • 外部排序

2.多维数组

• 二维数组 : 常见算法–杨辉三角, 回形数

  一维数组arr1作为另一个一维数组arr2的元素

• …

* 工具类Arrays

• Arrays.toString()
• Arrays.copyOf()
• Arrays.sort()
• Arrays.equals()

* 异常

• 数组索引越界异常

  • java.lang.ArrayIndexOutOfBoundsException

• 空指针异常

  • java.lang.NullPointerException

4.方法

提高代码复用率
减少代码冗余

方法的组成

• 权限修饰符

  • public : 包内✔ 子类✔ 包外✔
  • protected : 包内✔ 子类✔
  • (default) : 包内✔ 子类✖
  • private : 包内✖ 子类✖

• 返回值

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

• 参数

  • 参数阶段

    • 形参

      • 传递机制:值传递机制

        • 基本数据类型, 传递数据值
        • 引用数据类型, 传递引用地址

    • 实参

  • 参数类型

    • 基本数据类型

    • 引用数据类型

    • 可变参数 JDK5.0

      可变参数和多个参数的方法可以共存, 如
      方法1: public void test(int m, int…n){}
      方法2: public void test(int a, int b, int c){}

      调用的时候, 如果两个方法都能被调用, 程序优先调用确定参数个数的方法
      如 test(1, 2, 3); 会优先调用方法2

      • 可变参数要放在最后
      • 可变参数使用跟数组参数相同, 两者重复

• 方法体

方法的递归(recursion)

递归方法: 一个方法体内调用它自身
方法递归包含了一种隐式的循环, 他会重复执行某段代码, 但这种重复执行无需循环控制。
递归一定要向已知方向递归, 否则这种递归就变成了无穷递归, 类似于死循环。
死循环会导致 栈溢出错误 java.lang.StackOverflowError
例:递归求和
public int getSum(int n) {
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}

碰到的问题

子类继承父类, 子类构造器直接调用父类构造器时
如果再在子类里面写初始化块

初始化顺序: 父类构造器–>子类代码块-/->子类构造器

这时候调用有参构造器设置的属性都会被代码块覆盖(白写)
可以把子类的初始化应该把初始化参数写到子类的无参构造里。防止通过构造器赋予的属性被代码块覆盖。

public class Benz extends Car{
// {
// name = “本次”;
// }
//子类初始化属性应该写到无参构造器里
public Benz() {
this.name = “奔驰”;
}
public Benz(String color, String name, int wheels) {
super(color, name, wheels);
}
}

new Driver().drive(new Benz(“绿色”,“本吃”,4));

JVM内存模型

堆内存(Heap)

• 存储new出来的对象

栈内存(Stack)

• 存储局部变量

方法区

• 常量池
• 静态域

运算的可逆性, 用来交换数值, 或者加密解密

a ^ b ^ b == a : 数值a 经过两次 ^b 运算后跟原数值相等