本文共 4393 字，大约阅读时间需要 14 分钟。

JRE、JDK和JVM

1. JRE Java Runtime Environment，Java运行环境，包含JVM虚拟机以及Java核心类库
2. JDK Java Development Kit，Java语言的开发工具包，包含了编译工具和运行工具
3. JVM Java Vortual Machine，Java虚拟机，识别.class文件，并调用操作系统的API完成动作
4. JDK > JRE > JVM (">"是包含的意思)
5. 配置环境变量，为了任意路径下都可与访问到bin里的工具
   • JAVA_HOME
   • path

数据类型

类型转换

1. 隐式转换
   • 将取值范围小的数据，赋值给取值范围大的数据
   • 小的数据类型和大的数据类型运算，小的会提升为大的之后再进行计算
   • 数据类型排名：
     1. byte < short < int < long < float < double
     2. char < int < long < float < double
     3. byte，short，char不具有大小关系
   • byte、short、char 三种数据在运算的时候，不管是否有更高的数据类型，都会提升为int，然后再参与计算。单纯的赋值不是运算，不会自动提升为int，比如byte直接赋值给short
   • byte 和 char、short 和 char 互相转换时，都只能是强制类型转换
2. 强制转换
   • 将取值范围大的数据，赋值给取值范围小的数据
3. 常量优化机制
   • byte c = 3 + 5;
   • 3和5都是int常量，计算结果也是int，但这里不会出错，程序会正常输出8
   • 常量优化在编译时就会计算结果，得到的结果如果在byte范围内则正常，不在则会出编译错
4. 扩展运算符 +=、-=、*=、/=隐藏了强制转换

IDEA

1. 项目结构
   • project(项目、工程)
   • module(模块)
   • package(包)
   • class(类)
2. 常用快捷键
   • psvm + 回车 快速生成main方法
   • sout + 回车 快速生成输出语句
   • alt + 1 打开 / 隐藏工程目录视图
   • alt + 4 打开 / 隐藏控制台视图
   • Ctrl + alt + L 格式化代码
   • Alt + 回车 代码修正提示
   • Ctrl + D 向下复制一行
   • Ctrl + / 单行注释
   • Ctrl + shift + / 多行注释
   • Alt + shift + 上箭头 向上移动当前行
   • Alt + shift + 下箭头 向下移动当前行

数组

1. 数组的初始化方式
   • 数据类型[] arr = new 数据类型[长度];
   • 数据类型[] arr = new 数据类型[]{e1, e2…};

Java内存分配

1. 栈内存 方法运行时，进入的内存，局部变量都存放于这块内存中
2. 堆内存 new出来的内容都会进入堆内存，并且会存在地址值
3. 方法区 字节码文件加载时进入的内存 -> 运行Java程序，字节码被加载进内存中的方法区，方法没有被调用的时候，都在方法区中的字节码文件中存储。方法被调用的时候，在栈内存中运行
4. 本地方法栈 调用操作系统相关资源
5. 寄存器 交给CPU去使用

循环

1. break、continue 只能跳出自己那层的循环，再外层可以使用标记跳出

方法

1. 重载
   • 同一个类中，方法名相同，参数不同的方法
   • 参数不同：个数不同、类型不同、顺序不同
   • 识别方法之间是不是重载关系，只看方法名个参数，跟返回值无关
2. 方法参数传递
   • Java方法传递的方式，只有值传递

常用API

1. Random随机数

   java.util.Random r = new Random();int a = r.nextIne(10);

2. 键盘录入

   java.util.Scanner sc = new Scanner(System.in);int a = sc.nextInt();

3. String
   • 构造方法
     1. public String(); 创建一个空白字符串对象
     2. public String(char[] cs) 根据字符数组内容创建对象
     3. public String(String original) 根据传入的字符串内容，创建字符串对象
     4. String str = “abc” 根据直接量创建字符串对象
     5. 创建String对象的区别
        • 用""创建字符串，只要字符内容和相同，JVM都只会创建一个String对象，并在字符串常量池中维护
        • 字符串常量池在方法区中，JDK1,7之后，把字符串常量池挪到了堆内存中
   • 特点
     1. 字符串不可变，创建后改变的只是变量的引用地址
     2. “a” + “b” 编译器会优化出结果"ab"
   • 常用方法
     1. charAt
     2. toCharArray
     3. subString([start, end))
     4. replace(target, newTarget) 可以替换重复出现的内容
     5. split() 分割字符串
4. StringBuilder，是一个可变字符串类
   • 构造方法
     1. public StringBuilder()
     2. public StringBuilder(String str)
   • 常用方法
     1. public StringBuilder append() 添加内容到自己，会改变自己的内容
     2. public StringBuilder reverse() 返回相反的字符序列，将自己反转
     3. public int length() 返回长度
     4. public String toString() 返回String类型的字符串
   • 注意
     1. +字符串拼接本质上时创建一个StringBuilder对象append，所以直接用StringBuilder效率高
     2. String.equals(StringBuilder)需要把Sb转换为Str，否则比较不会为true
     3. StringBuilder类的equals方法不可以用来比较，它还是Object中的默认比较地址

面向对象

1. static声明的变量存储在堆内存中
2. 继承
   • 重写
     1. 静态方法不能被重写，但是子类可以直接调用父类的静态方法
     2. 子类重写的方法，访问权限必须大于等于父类中的方法
3. 抽象类
   • 抽象类不能创建对象
   • 抽象类有构造方法
4. final
   • final 修饰方法不能被重写
   • final 修饰变量是常量，不能再次被赋值
   • final 修饰类不能被继承
   • final 修饰成员变量要注意初始化时机
     1. 在创建的时候直接给值
     2. 在构造方法结束前（也就是构造方法内部），完成赋值
5. 代码块，用{}定义的代码部分
   • 局部代码块
     1. 在方法中定义
     2. 限定变量的生命周期，提高内存利用率
   • 构造代码块
     1. 在类中，方法并行定义
     2. 每次构造方法执行时，都会执行该代码块中的代码，并且在构造方法执行前执行
     3. 将多个构造方法中想用的代码，抽取到构造代码块中，提高代码的复用性
   • 静态代码块
     1. 在类中，方法并行定义
     2. 随着类的加载而加载执行，只执行一次
     3. 在类加载的时候做一些初始化操作
6. 接口
   • 当一个类中的所有方法都是抽象方法，我们可以将其定义为接口
   • 接口不能创建对象
   • 接口中的变量默认是static final修饰的静态常量
   • 接口中没有构造方法，实现类的super是Object的构造方法
   • 接口中的方法只能是抽象方法，JDK1.7及以前
   • 默认方法
     1. JDK8后，允许接口中定义非抽象方法，使用default修饰，即默认方法，目的是为了解决接口扩展时必须重写方法的问题
     2. 实现类重写接口中的默认方法不写default关键字
     3. 多个接口中有相同的默认方法，子类都实现这些接口，那么实现子类必须重写这个默认方法
   • 静态方法
     1. JDK8后，允许接口中定义静态方法
     2. 实现子类不能够调用这个静态方法，只允许使用接口本身直接调用
   • 私有方法
     1. JDK9以后，允许接口中定义私有方法
     2. 有一个方法，只是为接口服务，不需要其他类访问，就可以定义为私有方法
     3. 不能私有默认方法
     4. 私有方法可以是静态（给接口中的静态方法用）或者非静态（给接口中的其他私有方法使用）
   • 接口和接口之间可以多继承
7. 多态
   • 多态的前提
     1. 要有（继承/实现）关系
     2. 要有方法重写
     3. 要有父类引用，指向子类对象
   • 多态访问成员
     4. 成员变量：编译看左边（父类中必须有），运行看左边（调用的是父类中的成员变量）
     5. 成员方法：编译看左边（父类中必须有），运行看右边（调用的是子类中的成员方法）
     6. 不一样的原因是因为方法有重写，变量没有
   • 好处：提高了程序的扩展性，定义方法的时候，可以使用父类型作为参数，可以接受父类的任意子类对象
   • 弊端：不能使用子类特有的功能，编译期间看父类
   • 转型
     1. 向上转型 Fu f = new Zi();
     2. 向下转型 Zi z = (Zi)fu; // fu是上面创建的指向子类的父类引用对象，这样就可以调用子类特有的方法了
     3. 转型前用 instanceof 判断一下，可以避免ClassCastException
8. 内部类
   • 创建格式 Out.Inner i = new Out().new Inner();
   • 内部类可以直接访问外部类的成员，包括私有
   • 外部类要访问内部类的成员，必须创建外部类对象
   • 内部类可以使用private，static修饰，static创建方式 Out.Inner i = new Out.Inner();
   • 局部内部类，在方法中定义，需要在方法内部创建对象并使用，该类可以直接访问外部类的成员，也可以访问方法内的局部变量
   • 匿名内部类，前提条件必须存在一个接口或者类

     new Interface(){    @Override    public void show() {        // Do Something    }}; // 会返回一个接口对象

Lambda

1. 标准格式 (形式参数) -> {代码块}
2. 使用前提，有一个接口，这个接口有且只有一个抽象方法
3. 省略规则
   • 参数类型可以省略，多个参数必须全部省略
   • 参数只有一个的话，小括号可以省略
   • 代码只有一句话，大括号分号可以省略，甚至return也可以省略
4. 和匿名类的区别
   • 匿名内部类 可以使用接口，抽象类，具体类
   • Lambda只能使用接口
   • 接口中多个方法可以使用匿名类，不可以用Lambda
   • 编译后，匿名内部类会产生一个单独的.class文件，Lambda表达式编译后，对应的字节码会在运行的时候动态生成

转载地址：http://hikmf.baihongyu.com/