java基础知识的学习笔记，对知识点的详细理解（第一部分）

1.1 深入java虚拟机
1、垃圾回收机制的优先级最低，调用java.lang.System.gc()/java.lang.Runtime.gc()只能提醒jvm回收垃圾，但不会改变优先级，只是提醒，不会立刻回收。
2、类加载器有四个：启动类加载器，扩展类加载器，系统类加载器、网络类加载器
3、 加载机制（双亲委托机制），向上委托，向下加载。
1.2 java类型转换
一、类型转换
1、隐式类型转换：
byte，short，char类型数据在进行算数运算的结果会自动提升为int，其他类型运算时，表示范围小的会自动提升为大的，然后再运算
小类型可以直接赋值给大类型，类型自动转换为大的。
基本类型:精度小可以自动转换为精度大的
byte b = 1;
int a = b;
引用类型:子类类类型可以自动转换为父类类型
Student s = new Student();
Object o = s;
2、显式类型转换
赋值过程中，大类型赋值给小类型，会报错，出现精度损失，必须通过强制类型转换实现
3、浮点型转整型需要强制类型转换，整型转浮点型是隐式转换。
1.3 局部变量与实例变量
一、局部变量的生命周期应该注意
定义在类包含的大括号里面，可以定义在方法以及流程控制语句（if，while，for）内部，局部变量在使用前必须初始化；生命周期：在声明局部变量的大括号结束后，局部变量将不能再使用。
例如：if（true）{
string s=“hello”
}
System.out.println(s);//报错，s是在if语句的流程括号内部定义，生命周期已结束。
二、实例变量（成员变量）不能称为全局变量（不准确）
java虚拟机会给对象分配内存，对（实例）成员变量默认初始化整型为0、boolean型为false、引用类型为null。
1.4 操作符
1.instanceof关键字是针对引用类型而言的，用来判断实例化对象是否属于某个引用类型的实例。
2.按照平移的方向和填充数字的规则分为三种：<<(左移)、>>(右移)和>>>(无符号右移)。
>> : 右移运算符，num >>1,相当于num除以2的n次方

<<  : 左移运算符，num <<1,相当于num乘以乘2的n次方

>>> : 无符号右移，忽略符号位，空位都以0补齐，（计算机中数字以补码存储，首位为符号位）。
       注：无符号左移没有意义，和左移运算一样。

3.三目运算符：
（1） 1>2?4:“hello”;//是否正确？
答：正确，冒号左右的数据类型没有限制，可以是基本数据类型、引用数据类型，但是只能直接输出，没办法用变量接收（无法定义是double，还是String）。
（2） 1>2?4:6;//结果是？
答：6.0（结果存在隐式转换，从int—float）。
4、/ 与 %
/：除法 - 左操作数除以右操作数；小数计算结果强转int类型时取整数部分
%：取余 - 左操作数除以右操作数的余数；计算取“余数”
1.5 流程控制
1.switch语句中的条件只能放的数据类型String、menu(枚举)、char、byte、short、int六种类型。
2.在Java中，如何跳出当前的多重嵌套循环？
return可以直接跳出多重循环。
3.if…else if…else 语句
if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。使用 if，else if，else 语句的时候，需要注意下面几点：
if 语句至多有 1 个 else 语句，else 语句在所有的 else if 语句之后。
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
4.switch语句中的break和default：
（1）当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。
（2）case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。
（3）switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。
（4）default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。
1.6 数组
1.6.1 一维数组
在java中，根据数组的定义int array[]=new int[size]，可以看出数组是对象是引用类型。
1.6.2 二维数组
1、在java中，二位数组的理解应该是一维数组的一维数组，
例如：int[][] arr=new int[size1][size2];如果size2（列）不分配空间，则应该在初始化之前分配空间，arr[]=new int[size2]来实例化分配空间，然后初始化，否则会出现空指针异常！
2、可变参数的底层是数组实现的,方法名(int. . .)用三个点表示。
1.7 面向对象的思想
1、Java的三大特性：继承（Encapsulation），封装（Inheritance），多态（Polymorphism）。
2、类是属性和方法的抽象。
1.8 方法
1、方法重载
就是说一个类的两个方法拥有相同的名字，但是有不同的参数列表（参数类型，顺序，参数个数）。重载的方法必须拥有不同的参数列表。不能依据修饰符或者返回类型的不同来重载方法。
注意：下面两个方法不是方法重载，因为int. . .底层是数组实现的。
public void student(int. . . a);
punlic void student(int [] a);
2、构造方法
（1）构造方法没有返回值的类型，方法名与类名相同。一旦你定义了自己的构造方法，默认构造方法就会失效，不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法（无参，方法体内无语句），默认构造方法的访问修改符和类的访问修改符相同，(类为 public，构造函数也为 public；类改为 private，构造函数也改为 private)。
（2）构造器重载和方法重载一样：方法名相同，参数列表不同。
3、方法重写
继承父类的方法，根据自己的需求修改所继承方法的功能。（重写仅仅是对方法而言，成员变量不会被重写）
4、参数传递（参数传递分为两种）
（1） 值传递:对于基本数据类型，参数通过值传递。(把实参的值复制一份再传给形参)
（2） 引用传递:对于引用类型，参数通过引用(对象的引用)传递。(把实参引用中地址值复制一份再传给形参)
1.9 类
1.9.1 继承细节（单继承）
1、构造器不能被继承
2、方法和实例变量可以被继承
3、子类构造器隐式地调用父类的默认无参构造器;
4、如果父类中没有定义无参构造器，只定义了有参构造器，那么子类构造器则必须 显式地调用父类的有参构造器(通过super(…))，且必须放置在第一条语句，否则会有语法错误。
5、this()和super()在构造器中都必须为第一条语句，两者不能同时出现。
6、当一个子类继承了一个父类后，父类中所有的字段和方法都被子类继承拥有，子类可以任意的支配使用，每个子类对象中都拥有了父类中的所有字段。当构造一个子类的实例对象时，该对象的实例变量包括了子类本身以及父类中的所有实例变量，实例方法也包括了子类和父类中的所有实例方法。
7、子类构造器用来初始化子类中所有的实例变量，而父类构造器super(实参)用来初始化父类中所有的实例变量。所以在堆中为子类实例对象分配的内存区域中包括了子类和父类中所有初始化后的实例变量
1.9.2 方法重写（override）
1、重写是子类对父类的允许访问的方法的实现过程进行重新编写, “基本返回值类型”（但是引用类型父类和子类都可以定义，子类会向父类隐式转换）和形参都不能改变。即外壳不变，核心重写！
2、重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
3、访问修饰符不能被缩小，异常不能扩大，返回值（引用类型）可以缩小。
4、重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。
5、声明为final的方法不能被重写。
6、声明为static的方法不能被重写，但是能够被再次声明。
7、构造方法不能被重写（因为构造方法不能被继承）。
1.9.3 多态
1、编译阶段（看左边），只是检查参数的引用类型。
2、然而在运行时（看右边），Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。
3、多态存在的三个必要条件：
继承、重写、父类引用指向子类对象
4、多态的实现方式
方式一：继承重写：
方式二：接口
方式三：抽象类和抽象方法
5、编译看左边，运行看左边（看左边的父类）——》针对成员变量
编译看左边，运行看右边（看右边的子类）——》针对成员方法
6、在继承中的成员变量不能被“重写”。
7、注意：继承中的静态方法被重新定义（不称为重写），但在父类引用指向子类对象时（多态），调用方法时会调用父类的（而不是像普通成员方法一样，就近原则调用子类的）。
总结：重写仅仅是对普通的成员方法而言，不包括静态方法和构造方法。
1.9.3 抽象类
1、抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
2、声明抽象方法会造成以下两个结果：
（1）如果一个类包含抽象方法，那么该类必须是抽象类。
（2）抽象类不一定含有抽象方法。
（3）任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
3、抽象方法：
（1）抽象方法只能用public，protected，，default，abstract修饰
（2）抽象方法不能有final，static关键字
原因：抽象方法需要具体的实现类实现抽象方法，然而final修饰的方法不能被继承（矛盾）。
1.9.3 修饰符
一、static修饰符
1、static修饰符可以用来修饰类的成员变量、成员方法和代码块，用static修饰的成员变量表示静态变量和静态方法，可以直接通过类名来访问；用static修饰的程序代码表示静态代码块，当Java虚似机加载类时，就会执行该代码块；被static所修饰的成员变量和成员方法表明归某个类所有，它不依赖于类的特定实例，被类的所有实例对象共享。
2、成员变量：定义在类里面、方法外面的变量, 分两种：
a. 实例变量。
b. 静态变量；形式和实例变量类似，在实例变量前面加static关键字；
3、Java虚拟机在加载类的过程中为static变量分配内存，实例变量在加载完类后创建对象时分配内存。
4、static 代码块
在Java虚拟机中加载类时会执行这些静态代码块。如果类中包含多个静态代码块，那么Java虚拟机将按照它们在类中出现的顺序依次执行它们，每个静态代码块只会被执行一次。
5、静态方法
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
二、final修饰符
. 用final修饰的变量是常量，使用前必须初始化；
. 用final修饰的类不能被继承，没有子类；
. 用final修饰的方法不能被子类的方法覆盖；
用final修饰的变量表示常量，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
.final修饰引用类型，对象地址不能改，对象的成员变量可以修改。
三、访问控制（Access control）
• default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
• private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
• public : 对所有类可见。使用对象：类、接口、变量、方法
• protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

四.、abstract修饰符
1、用abstract修饰的类表示抽象类，抽象类不能实例化，即不允许创建抽象类本身的实例。没有用abstract修饰的类称为具体类，具体类可以被实例化。
2、用abstract修饰的方法表示抽象方法，抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。
3、抽象方法不能被声明成 final 和 static。
五、构造代码块
1、构造代码块随着构造器的执行而执行，并且先于构造器执行，晚于静态代码块。
1.9.4 内部类
一、内部类分为：1、成员内部类 2、静态内部类3、局部内部类 4、匿名内部类
1、成员（实例）内部类:
（1）成员内部类中不能有static的声明属性或者方法
（2）成员内部类可以由public protected default private修饰
（3）成员内部类是依赖于外部类的对象而存在的
（4）外部类.内部类 var = new 外部类().内部类();
注意：
（1）在创建实例内部类的实例时，外部类的实例必须已经存在。
（2）实例内部类的实例自动持有外部类的实例的引用。在内部类中，可以直接访问外部类的所有成员。
（3）外部类实例与内部类实例之间是一对多的关系，一个内部类实例只会引用一个外部类实例，而一个外部类实例对应零个或多个内部类实例。在外部类中不能直接访问内部类的成员，必须通过内部类的实例去访问。
（4）实例内部类中不能定义静态成员，而只能定义实例成员。
（5）如果实例内部类B与外部类A包含同名的成员，那么在类B中， this.v表示类B的成员， A.this.v表示类A的成员。
2、静态内部类是成员内部类的一种（用static修饰）
（1）静态内部类：静态内部类中访问不到外部类的非静态成员（变量和方法），静态内部类的对象不需要依赖于外部类的对象。
（2）静态内部类可以直接访问外部类的静态成员（变量及方法），如果访问外部类的非静态成员（方法及变量），就必须通过外部类的实例对象去访问。
（3）在静态内部类中可以定义静态成员变量和非静态成员变量。
（4）可以通过完整的类名直接访问静态内部类的静态成员。
3、局部内部类：(相当于一个方法中的局部变量)
（1）局部内部类不能用public private等修饰符修饰
（2）写在方法当中,而且只能在方法当中使用
（3）可以访问外层类的普通成员变量和静态成员变量以及普通方法和静态方法,也可以访问该内部类所在方法当中的局部变量,但是要访问的这个局部变量必须是final修饰，但是在jdk8开始，可以交给jvm默认final修饰。
4、匿名内部类:(和局部内部类很相似)
（1）匿名内部类也是用的最多的内部类
（2）可以写成成员变量的形式,也可以写在方法当中,一般写在方法当中较多。
（3） 匿名内部类里可以访问外部类的普通属性和方法,以及静态属性和方法，如果要访问这个内部类所在方法中的局部变量,那么要求这个局部变量必须是final修饰的。
（4） 匿名内部类里面没有构造函数,因为这个类没有名字,所以在其他地方不能用。
5、几种内部类的区别：
（1）创建
a. 声明的位置:
静态内部类：类的内部，方法的外部，用static关键字修饰；
成员内部类：类的内部，方法的外部，不用static关键字修饰；
局部内部类：方法的内部；
匿名内部类：既可以在类的内部，方法的外部，也可以在方法的内部；
b. 实例化方式:
静态内部类：new Outer.Inner(); //在外部类外创建；
new Inner(); //在外部类内内部类外创建
成员内部类：new Outer().new Inner(); //在外部类外创建；
this.new Inner(); //在外部类内内部类外创建
局部内部类：new Inner(); //只能在方法内部创建；
匿名内部类：new 类名() {};
（2）访问
a. 外部类访问内部类：
静态内部类：通过完整的类名直接访问静态内部类的静态成员;
成员内部类：通过内部类的实例去访问内部类的成员;
局部内部类：不能访问；
匿名内部类：不能访问；
b. 内部类访问外部类：
静态内部类：直接访问外部类的静态成员；
成员内部类：可以直接访问外部类的所有成员;
如果实例内部类B与外部类A包含同名的成员，那么在类B中， this.v表示类B的成员，
A.this.v表示类A的成员。
局部内部类：可以直接访问外部类的所有成员, 访问所在方法中的final类型的参数和变量；
匿名内部类：可以直接访问外部类的所有成员, 访问所在方法中的final类型的参数和变量。
1.9.4 = = 和 equals 方法的比较
一：在引用类型中
1、两者都用于比较，返回值都是Boolean类型的值；
2、= =是运算符，equals是Object类中的方法。
3、= =和equals在默认情况下都是比较两个对象的地址。
4、当重写了Object类中的equals方法，则会按照重写的规则进行比较。
二：在基本数据类型中
1、= =比较的是“值”否相等。
2、equals方法不能作用于基本数据类型的变量。
1.9.4 自动装箱和自动拆箱
1、基本数据类型可以和包装器类型进行转换。
2、自动装箱，jvm将基本数据类型自动转换为包装器类
3、自动拆箱，jvm将包装器类型自动转换为基本数据类型
4、java中的整数包装器类，在内存中有一个缓存区域存取了-128到127这256个整数，会直接从缓存区中取值，如果不在该区域，则会在堆中创建新的对象用来存取该值。
1.10 接口
一、接口特性
接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
接口中的成员变量默认都是public, static, final类型，必须被显式初始化。
接口可以继承接口
二、接口与类的区别：
接口不能实例化对象，所以接口中也没有构造器。
接口中所有的方法必须是抽象方法。
接口不能包含实例变量，除了 static 和 final 变量。
接口支持多实现。
三、抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。
   四、接口的多继承
   在Java中，类的多继承是不合法，但接口允许多继承。
   在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。 如下所示：public interface Hockey extends Sports, Event。
   五、jdk8的新特性
   1、接口中可以定义普通方法，但必须由public、default修饰
   2、在多实现时，如果被多实现的接口有重名的方法，则必须在实现接口的时候重写该方法。
   1.11 包(package)
   1、Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。