必须掌握的Java基础知识（一）
程序的三个基本机构：1、顺序结构 2、选择结构 3、循环结构
面向对象是一种更为优秀的程序设计方法，它的基本思想是使用类、对象、继承、封装、消息等基本概念进行程序设计。
面向对象的三个基本特征：封装、继承和多态。
封装：将对象的实现细节封装起来，然后通过一些公用的方法来暴露该对象的功能。
继承：是面向对象实现软件复用的重要手段，子类继承父类，子类将直接获得父类的属性和方法。
多态：子类对象可以直接赋给父类变量，但是在运行时依然表现出子类的行为特征，这意味着同一个类型的对象在执行同一个方法时，可能表现出多重行为特征。
类和对象的关系：
类是对象的抽象，而对象是类的实例。对一个类的定义而言，包含了三种最常见的成员：构造器、成员变量和方法。
static 是一个特殊的关键字，可以用于修饰方法和成员变量，被static修饰表明属于类本身，而不属于该类的单个实例，因此成为类变量和类方法，而实例方法与其不同，访问该类的成员和方法不受限制。
UML（统一建模语言）
面向对象软件开发需要经过OOA（面向对象分析）、OOD（面向对象设计）和OOP（面向对象编程）的三个阶段。
Java语言支持的类型分类：基本类型和引用类型。
- 基本类型
整数类型：byte（1个字节）、short（两个字节）、int（4个字节）和long（8个字节）
字符类型：char（2个字节）
浮点类型：float（4个字节）、double（8个字节）
布尔类型：boolean
整数值的4种表示方式：0b或0B表示二进制、o表示八进制、0x或者oX表示十六进制。
整数值默认是int，占32位，例如0b11101001，如果加L或者l，这个二进制默认占64位。
字符型值也可以用十六进制表示，范围是'\u0000'~'uFFFF'，和ASCII码中的字符完全重合。
负数在计算机中以补码的形式出现。
浮点类型默认是double类型。
类型的强制转换和表达式自动提升。强制转换，右边的范围一般高于左边。自动提升注意赋值的左右两边类型一致，否则报错。
++：自加（自减）
如果把++放在左边，则先把操作数加1，再把操作数放入表达式中运算，如果++放在右边，则先把操作数放入表达式运算，在把操作数加1。
<<：左移运算符
>>：右移运算符，左边空出来，负数补1，整数补0。即以符号位填充。
>>>：无符号右移运算符，左边空出来的总是补0。
对低于int类型的数据，先转换为int类型，再进行移位。对于移位大于被移位数据类型时，要进行先求余，再移位。
break、continue、return、foreach用法。
2.引用类型
数组是一种引用数据类型，数组元素和数组变量在内存里是分开存放的。数组引用变量只是一个引用，这个引用可以指向有效内存的任何地方。实际数组对象存储在堆内存中，引用该数组的变量是一个局部变量，存储在栈内存中。
堆内存和栈内存有什么区别？
当一个方法被调用时，每个方法就会建立自己的内存栈，在这个方法内定义的变量将被逐个放入该内存中，随着方法的结束，这个方法的内存也就销毁了，而在程序中创建一个对象时，这个对象就会被放在堆内存中，以便反复利用，即使方法结束对内存的对象也不会内销毁，有可能被另一个引用变量引用，除非没有其他引用，Java虚拟机的垃圾回收机制在合适的时候自动回收该对象。
关键字：this
对象的this引用：对象的一个方法依赖（调用）于另一个方法的情形。大部分时候，一个方法访问该类中的其他方法、成员变量时，可以省略this，效果是一样的。但是，对于static修饰的方法而言，使用this无法指向合适的对象，所以被static修饰的方法不能够访问非静态的成员。因此Java语法规定：静态成员不能够访问非静态成员。
尽可能使用类名调用静态方法，因为该静态方法是属于类的，不属于该类的实例。
方法的理解
Java里的方法不能够独立存在，调用方法必须使用类或者对象。
参数传递的机制：基本类型和引用类型的参数传递。基本类型情况下，就是将实际参数复制到传入的方法中，参数本身不受影响；而引用类型传递的引用变量给形参，实参和形参同时指向同一个对象，通过形参改变对象的值，实参所指向的对象也将改变。
递归方法的一个重要原则：递归一定要向已知的方向递归。
方法重载
重载： 发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。
成员变量和局部变量
成员变量包括：实例变量和类变量，类变量的范围大于实例变量的范围，同一个类的所有实例访问类变量时，实际上访问的是该类同一片内存区域的一个变量。
class Person{
//实例变量
public String name;
//类变量
public static int eyeNum;
}
//创建第一个Person对象
Person p1 = new Person();
//创建第二个Person对象
Person p2 = new Person();
//分别给两个对象的name实例变量赋值
p1.neme = "张三";
p2.name = "孙悟空"；
//分别给两个Person对象的eyeNum类变量赋值
p1.eyeNum = 2;
p2.eyeNum = 3;
局部变量包括：形参、方法局部变量和代码块局部变量。
访问代码块局部变量之前必须初始化，否则出错。离开了代码块局部变量所在的代码块，这个局部变量也就被销毁了。
局部变量会覆盖成员变量，成员变量依然可以使用this和类名来调用。
类加载器先初始化类，然后创建实例，eyeNum是属于类的，并不属于Person对象，创建第一个实例对象时，系统并不需要为eyeNum分配内存，只是为实例变量name分配了内存。如果再创建第二个Person对象，不需要对Perso类进行初始化。
与成员变量不同的是，局部变量不属于任何类和实例，因此它总是保存在其所在方法的栈内存中，基本类型的变量保存的是值，引用类型的变量保存的是地址。
访问控制符：private,protected,public
import 和static import
使用import可以省略写包名，使用static import则可以连类名就能省略。
构造器
构造器初始化，构造器重载
例如使用this(name.color)调用另一个构造器的初始化代码。
类的继承
重写父类的方法，父类private方法不能够子类重写（覆盖），该方法对其子类是隐藏的。
重写：“两同两小一大原则” ，发生在父子类中，方法名、参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符范围大于等于父类；如果父类方法访问修饰符为 private 则子类就不能重写该方法。
关键字super
super调用父类被覆盖的方法，调用父类的变量和方法。子类实例变量名和父类实例变量名相同，子类会隐藏父类的实例变量。可以使用super.变量访问父类的实例变量。
如果在某个方法中访问变量a,（1）先查找该方法中是否有局部变量（2）查找当前类是否有该成员（3）查找直接父类是否有该成员变量，进而追溯上一级的父类，知道找到该变量，否则编译错误。
调用父类的构造器super(name,color),子类构造器调用父类构造器时，super语句必须放在子类构造器的第一行。
创建任何一个java对象时，最先执行的Object类的构造器。执行原则：从该类所在继承树最顶层类的构造器开始执行。
多态性
如果编译时类型和运行时类型不一致，当运行时调用该变量的方法时，其方法行为总能够表现出子类方法的行为特征，而不是父类方法的行为特征，这就是传说中的多态。另外注意一条原则：编译看左边，运行看右边。
在开发中首先使用instanceof运算符判断是否具备该类的特性，然后用（type）强制转换，增加了程序的健壮性，而且不会出现错误。
继承和组合
都能够实现类的复用手段，但是继承会破会封装，组合提供更好地封装，组合很常见啊，Spring中注入bean，就是组合。
初始化块
这是在笔试题中经常遇到的问题，java类四个成员，成员变量，方法，构造器和初始化块。
初始化代码块的修饰符只能是static，称为静态代码块。
先执行实例变量的赋值，再执行代码块的赋值。
先执行代码块，再执行构造器。
静态代码块不管顺序如何，都会在main函数之前执行。
Java初始化的顺序：父类静态变量-->父类静态代码块-->子类静态变量-->子类静态代码块-->父类非静态变量-->父类菲静态代码块-->父类构造函数-->子类非静态变量-->子类菲静态代码块-->子类构造函数
普通初始化块、声明实例变量指的默认值都可认为对象的初始化代码，它们执行的顺序和源程序的顺利一致。
public class Demo1 {
{
a = 6;
System.out.println("a = 6;");
}
int a = 9;
public static void main(String[] args){
System.out.println(new Demo1().a);
}
}
public class Demo1 {
int a = 9;
{
a = 6;
System.out.println("a = 6;");
}
public static void main(String[] args){
System.out.println(new Demo1().a);
}
}
静态初始化块、声明静态成员变量指的初始值可认为是该类的初始化代码，它们执行的顺序和源程序的顺利一致。
public class Demo1 {
static {
a = 6;
System.out.println("a = 6;");
}
static int a = 9;
public static void main(String[] args){
System.out.println(new Demo1().a);
}
}
public class Demo1 {
static int a = 9;
static {
a = 6;
System.out.println("a = 6;");
}
public static void main(String[] args){
System.out.println(new Demo1().a);
}
}
基本类型和包装类的对应。
parseXxx(String s) String.valueOf(基本类型)
打印对象和toString()方法
package com.quan.sort.fastsort;
public class Demo1 {
public static void main(String[] args) {
Person p = new Person("zhangsan");
System.out.println(p);
System.out.println(p.toString());
}
}
class Person{
String name;
Person(String name){
this.name = name;
}
}
结果：类全名+@+十六机制的哈希值
为什么是这样的格式？？？com.quan.sort.fastsort.Person@1540e19d
Person继承了Object类的toString方法。源码分析：
==和equals方法
如果比较的是两个基本类型的值，只要值相同就返回true。引用类型的比较，必须指向同一个对象才能够返回true。
"abc"和new String("abc")的区别？"abc"编译时就计算出来的字符串值，JVM将会使用常量池管理这些字符串。而是用new String("abc")时，JVM将会使用常量池管理这个直接量，然后再调用String类的构造器创建一个新的String对象，新创建的String对象放在堆内存中。换句话说，new String("abc")一共产生了两个字符串对象。
JVM常量池保证相同的字符串只有一个，不会出现副本。
String类中的equals方法比较的是引用变量所指对象的值相等，就会返回true，因为重写了Object的equals方法。
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
严格上说equals方法，是具体的实现，想怎么相等就怎么相等。全部自己做主。
final关键字修饰类、变量和方法
final变量：被final修饰的基本类型的变量只能赋值一次，不能够再次改变被final修饰的引用变量不能够被重新赋值，但是引用变量所指对象的值可以改变。
final方法：被final修饰的方法不能够被重写，但是可以被重载。
final类：不可以有子类，保证不被继承。
不可变类：8个包装类 和 String类
Integer的缓存范围为-128~127.
Integer in1 = new Integer(6);
//创建一个新的对象，并缓存该对象
Integer in2 = Integer.valueOf(6);
//直接冲缓存中取出该对象
Integer in3 = Integer.valueOf(6);
System.out.println(in1 == in2);
System.out.println(in3 == in2);
