Java

JDK、JRE、JVM的关系

JDK = JRE +开发工具集（例如Javac编译工具等）

JRE = JVM + Java SE标准类库

字节码文件

在机器和编译程序之间加入了一层抽象的虚拟的机器，该虚拟机在任何平台上都提供给编译程序一个共同的接口面向虚拟机编程，写出虚拟机能理解的代码,通过解释器将虚拟机码转化为特定系统的机器码执行。

提供虚拟机理解的代码叫做字节码（.class）文件，只面向虚拟机

.java 文件 ----------》 javac.exe 编译 ---------》.class文件（字节码文件）------》java.exe运行 -------》 结果

一处编译，到处报错：面向虚拟机，经过编译后，在各种操作系统中都可以运行。

变量分类

按类中的声明位置分类

按数据类型分类

自动类型转换

结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

	byte 、char 、short --> int --> long --> float --> double
      1		2		2		4		 8		  4			8字节

​ 特别的：当byte、char、short三种类型的变量做运算时，结果为int型
说明：此时的容量大小指的是，表示数的范围的大和小。

比如：float容量要大于long的容量

&和&&、|和||

& 两边都为 true 即为true，两边都需要计算

&& 当判断左边为 false 时，右边不需要进行判断。短路与

。。。同理

面向对象与面向过程

1. 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2. 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

权限修饰符

面向对象的基本特征

封装：满足程序设计追求的“高内聚，低耦合”

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。

通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

继承：

1. 减少了代码的冗余，提高了代码的复用性
2. 便于功能的扩展
3. 为之后多态性的使用，提供了前提

多态：使用父类的引用指向子类的对象

在编译期间，只能调用父类中声明的方法，但是在运行期，实际执行的时子类重写父类的方法。

编译看左边，运行看右边

重载与重写

重载 override：方法名相同，参数列表不同

重写overwrite：“两同两小一大”

• 两同：方法名相同，形参列表相同
• 两小：子类重写方法抛出的异常小于等于父类被重写方法抛出异常。子类方法的返回值类型小于等于父类被重写方法
• 一大：子类重写方法的权限修饰符大于等于父类被重写方法的权限修饰符

override（重载）：是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；

static和单例模式

static修饰的属性和方法是存在与方法区中的，所以多个实例共享一个static类型的变量

方法区：类的加载信息，静态域，常量池

单例模式：通过私有化构造器

​

// 饿汉式1：
class Bank{
    //1.私化类的构造器
    private Bank(){}
    //2.内部创建类的对象
    //4.要求此对象也必须声明为静态的
    private static Bank instance = new Bank();

    //3.提供公共的静态的方法，返回类的对象
    public static Bank getInstance(){
        return instance;
	}
}
// 懒汉式2：初始声明为 null 调用方法期间才会创建对象
class Order{
	//1.私化类的构造器
	private Order(){}
	//2.声明当前类对象，没初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		if(instance == null){
			instance = new Order();
		}
		return instance;
	}
}

// 饿汉式：使用了静态代码块
class Order{
	//1.私化类的构造器
	private Order(){}
	//2.声明当前类对象，没初始化
	//4.此对象也必须声明为static的
	private static Order instance = null;
	static{
		instance = new Order();
 	}
	//3.声明public、static的返回当前类对象的方法
	public static Order getInstance(){
		return instance;
	}
}

2.3 两种方式的对比：

饿汉式：

• 坏处：对象加载时间过长。
• 好处：饿汉式是线程安全的

懒汉式：

• 好处：延迟对象的创建。
• 目前的写法坏处：线程不安全。

final 、 finally、finalize

final : 修饰符

修饰类：表示当前类不可被其他类继承（String,System,StringBuffer)

修饰方法：当前方法不可被重写（Object类中的getClass())

修饰变量：表示当前变量为一个常量

finally：用于异常处理过程中，一定会执行的代码（除非系统关闭）

当 return 语句在 try 中，在执行之前，finally中的代码会执行

当 finally 中存在 return 时，原返回值会被覆盖

finalize：用于垃圾回收使用，目前使用地方较少

Java的异常体系

java.lang.Throwable
	|-----java.lang.Error:一般不编写针对性的代码进行处理。
	|-----java.lang.Exception:可以进行异常的处理
		|------编译时异常(checked)
				|-----IOException
					|-----FileNotFoundException
				|-----ClassNotFoundException
		|------运行时异常(unchecked,RuntimeException)
				|-----NullPointerException
				|-----ArrayIndexOutOfBoundsException
				|-----ClassCastException
				|-----NumberFormatException
				|-----InputMismatchException
				|-----ArithmeticException

编译时异常：执行 javac.exe 时，可能出现的异常

运行时异常：执行 java.exe 命名时，出现的异常

进程与线程

程序（program）：一组指令的集合。静态代码。

进程（process）：正在运行的程序。资源分配的基本单位，系统在运行时为每个进程分配不同的内存区域。

线程（thread）：一个程序内部的一条执行路径。调度和执行的单位，每个线程都拥有独立的程序计数器（ps)和运行栈，线程切换的开销小。

多线程的创建方式

1，继承 Thread 类，重写 run() 方法

2，实现 Runable 接口，重写 run() 方法

3，实现 Callable 接口，重写 run() 方法，区别于Runable的是由返回值

4，通过线程池

线程的生命周期

String、StringBuffer、StringBuilder

String:不可变的字符序列；底层使用char[]存储
StringBuffer:可变的字符序列；线程安全的，效率低；底层使用char[]存储
StringBuilder:可变的字符序列；jdk5.0新增的，线程不安全的，效率高；底层使用char[]存储

计算机组成原理

进制以及表示方式

1. 二进制（binary): 0b或0B开头
2. 十进制（decimal）
3. 八进制（octal）以数字0开头
4. 十六进制（hex）0-9+A-F，以0x或0X开头

原码、反码、补码

计算机底层的存储方式：所有数字在计算机底层都以二进制形式存在。

所有的数值，不管正负，底层都以补码的方式存储。

正数：原码=反码=补码

负数

• 原码：将一个数换算为二进制数。最高位为符号位（正0负1）
• 反码：符号位不变，其他位按原码按位取反
• 补码：反码+1

算法

计算机中只有数组和链表两种基本结构

排序算法

冒泡排序

//冒泡排序
public void bu
for(int i = 0;i < arr.length - 1;i++){
    for(int j = 0;j < arr.length - 1 - i;j++){
        if(arr[j] > arr[j + 1]){
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }	
}		

算法

计算机中只有数组和链表两种基本结构

排序算法

冒泡排序

//冒泡排序
public void bu
for(int i = 0;i < arr.length - 1;i++){
    for(int j = 0;j < arr.length - 1 - i;j++){
        if(arr[j] > arr[j + 1]){
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }	
}