由JVM来负责Java程序在该系统中的运行，不同的操作系统需要安装不同的JVM，这样Java程序只需要跟JVM打交道，底层的操作由JVM去执行。
JRE（Java Runtime Environment）即Java运行时环境，主要负责运行Java程序。
JDK（Java Development Kit）即Java开发工具包，主要用来开发Java程序。
安装完JDK后，JDK的安装路径下会有一些文件夹，那这些文件夹里面的文件都是做什么的呢？
bin目录：该目录用于存放一些可执行程序。
db目录：db目录是一个小型的数据库。
jre目录：这个就是之前提到的那个jre，此目录是Java运行时环境的根目录。
include目录：由于JDK是通过C和C++实现的，因此在启动时需要引入一些C语言的头文件，该目录就是用于存放这些头文件的。
lib目录：lib是library的缩写，里面存放了 Java 类库或库文件，是开发工具使用的归档包文件。
src.zip文件：src.zip为src文件夹的压缩文件，src中放置的是JDK核心类的源代码，通过该文件可以查看Java基础类的源代码。
Java的加载与执行
对于Java程序员来说，主要做的事情就是编写以.java结尾的文件，我们称之为源文件，把在源文件里面所编写的代码叫做源代码。但是这个.java结尾的文件是不能直接运行的，需要使用javac.exe命令编译成以.class结尾的文件（例如：javac HelloWorld.java），这个文件夹叫做字节码文件。要想运行这个字节码文件的话，需要使用java.exe命令（例如：java HelloWorld），之后会启动JVM，JVM中的类装载器会去电脑硬盘里面寻找这个class文件，然后将它翻译成2进制文件交由操作系统去运行。
Java程序的编译
这个阶段Java编译器将我们编写的java源文件加载，然后去检查源码里面的语法，如果出现了语法错误会进行提示，这个阶段提示的错误我们称之为编译错误。如果遇到了编译错误，是不会生成.class文件的，遇到编译错误时，需要我们根据错误提示的信息去分析和解决。
Java程序的运行
这个阶段由类装载器寻找class文件并装载到jvm里面，然后翻译成2进制文件交由操作系统去运行，这个时期如果出现了错误，我们称之为运行期错误。
//如果不加L的话，会把2147483648看成int类型，即默认会将整数的字面值看成是int类型
long l3 = 2147483648L;
这里面存在自动类型转换，会自动将int类型转换成long类型，即自动将int类型的888转换成为了long类型。
long l1 = 888;
byte b1 = 3;
byte b2 = 4;
byte b3 = b1 + b2;
第三行代码有问题，编译错误。因为b1和b2在做运算的时候会先转成int类型，所以b1 + b2的结果是int类型，int类型是不能直接赋值给byte类型的（大容量转小容量），这里需要进行强制类型转换。
int x = 4; int y = (x++)+(++x)+(x*10); System.out.println("x = " + x + ",y = " + y);
第一个括号里面的x++的值是4，第二个括号里面的++x的值是6，第三个括号里面的x*10的值是60
int i = 0; i = i++; System.out.println(i);
先用一个临时的变量temp保存变量自增前的值，然后变量自增，最后自增表达式会把temp的值作为整个表达式的值返回，也就是把temp的值返回给了i，由于temp保存的是i自增前的值，所以i的值不会变。
int a = 10; int b = 12; System.out.println("a+b=" + (a+b)); //"a+b=22" System.out.println("a+b=" + a + b); //"a+b=1012"
请实现两个整数变量的交换(不能使用第三方变量)
int a = 20; int b = 10; a = a ^ b; b = a ^ b; a = a ^ b;
//break还可以控制结束嵌套循环 outerFor:for(int i=5;i>0;i--){ innerFor:for(int j=0;j<i;j++){ if(j==2){ break outerFor; } System.out.print(j); } System.out.println(); }
//continue也可以像break那样加上循环的名字： outerFor:for(int i=5;i>0;i--){ innerFor:for(int j=0;j<i;j++){ if(j==2){ continue outerFor; } System.out.print(j); } System.out.println(); }
方法重载发生的条件
- 发生在同一个类中.
- 方法名相同
- 参数列表不同(类型，个数，顺序)
System.out.println()这个方法构成重载
在JVM当中有一块内存空间，就是栈区，专门为方法准备的。方法执行所需要的内存空间都在栈当中分配。
- 方法调用之后给该方法分配内存，在JVM的“栈区”当中分配空间，
- 方法调用分配空间的过程就是：压栈（push）的过程。
- 方法执行结束之后，给这个方法分配的所有空间全部释放，此时发生弹栈（pop）的动作
public static void main(String[] args){ int i = 1024; m1(i); System.out.println("monkey1024"); } public static void m1(int i){ m2(i); } public static void m2(int i){ m3(i); } public static void m3(int i){ System.out.println("m3方法中的i=" + i); } public static void m4(){ }
上图是方法执行过程图
- 将main方法压栈
- 因为main方法里面调用了m1方法，所以将m1方法压栈
- m1方法调用m2方法，将m2方法压栈
- m2方法调用m3方法，将m3方法压栈
- m3方法执行结束后，开始弹栈
因为m4方法没有被调用，所以不会进行压栈操作。
面向对象 三大特征 封装 继承 多态
在Java语言里面，最基本的单位是类（class），类是由成员变量和方法组成的，类=成员变量+方法
成员变量：在类的内部，方法的外部定义的变量叫做成员变量。
局部变量：在方法内部定义的变量叫做局部变量。
在JVM内存里面主要分布有以下三个区域：
- 栈：存放基础数据和自定义对象的引用
- 堆：主要存储创建的对象，即new出来的对象。
- 方法区：加载存放class文件（字节码文件）
通过上图来看，程序是这样执行的：
- 将StudentTest01.class文件加载到方法区
- 将Student.class文件加载到方法区
- main方法压栈
- 在堆里面创建一个Student的对象
- 栈里面的s指向堆里面Student对象的内存地址0x0101
- 给对象的成员变量进行赋值
- 方法弹栈
- 程序执行结束
如果堆里面的对象没有被指向，Java里面有个垃圾回收器会将对象进行回收。开发时不需要手动设置为null，垃圾回收器会自动回收。
手动的编写了一个带有参数的构造方法，那么系统将不会为我们提供默认的无参构造方法了。
如果我们还想使用无参构造方法，就必须自己写出。建议自己写出无参构造方法
this是java里面的一个关键字，是一种引用类型，在堆(heap)中的每个java对象上都有一个this指向自己。
1.可以区分成员变量和局部变量。
2.可以调用构造方法
语法：this(实参);
注意：如果要是使用this调用构造方法的话，那么this必须出现在构造方法的第一行。
static可以修饰变量，被static修饰的变量叫做静态变量，程序运行时静态变量存放在方法区里面，因此，静态变量在类加载阶段赋值，并且只赋值一次。
static可以修饰方法，被static修饰的方法叫做静态方法，不用创建对象就能能直接访问该方法，即使用类名.静态方法名的方式。静态方法不能访问非静态的数据，静态方法不能使用this。
static可以定义静态语句块，静态语句块在类加载阶段执行，并且只执行一次，并且是自上而下的顺序执行，在构造方法之前执行。
static修饰的变量、方法、代码块都是隶属于类(class)级别的,跟对象无关。某一类物体如果可以被多个其他物体所共享，那么可以将这类物体使用static修饰。
- 局部代码块，在方法中出现，限定变量生命周期，及早释放，提高内存利用率
- 构造代码块，在类中方法外出现；多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行
- 静态代码块， 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。一般用于加载驱动。
class Teacher { static { System.out.println("Teacher 静态代码块"); } { System.out.println("Teacher 构造代码块"); } public Teacher() { System.out.println("Teacher 构造方法"); } } public class TeacherTest { static { System.out.println("TeacherTest静态代码块"); } public static void main(String[] args) { System.out.println("main方法"); Teacher t1 = new Teacher(); Teacher t2 = new Teacher(); } }
TeacherTest静态代码块
main方法
Teacher 静态代码块
Teacher 构造代码块
Teacher 构造方法
Teacher 构造代码块
Teacher 构造方法
在java语言里面只支持单继承，即一个类只能有一个父类，子类可以继承父类中的非private修饰的成员方法和成员变量，构造方法不能被继承，
如果一个类没有显示的继承其他类，那么这个类会默认继承Object类，Object是SUN公司提供的java中的根类。
Java不支持多继承，但是支持多层继承，即子类—>父类—>爷爷类….—>祖先类—>Object类，子类可以访问其先辈类里面的非private修饰的成员方法和成员变量。
重写，也叫做覆盖，当父类中的方法无法满足子类需求时，子类可以将父类的方法进行重写编写来满足需求。比如孩子继承了父亲的房子，可以将房子重新装修。
- 两个类必须是继承关系
- 必须具有相同的方法名，相同的返回值类型，相同的参数列表.
- 重写的方法不能比被重写的方法拥有更低的访问权限。
- 重写的方法不能比被重写的方法抛出更宽泛的异常。(关于异常后面的章节再讲。)
- 私有的方法不能被重写。
- 构造方法无法被重写，因为构造方法无法被继承。
- 静态的方法不存在重写。
- 重写指的是成员方法，和成员变量无关。
super代表的是当前子类对象中的父类型特征。
什么时候使用super？
- 子类和父类中都有某个数据，例如，子类和父类中都有name这个属性。如果要再子类中访问父类中的name属性，需要使用super。例1
- 子类重写了父类的某个方法（假设这个方法名叫m1），如果在子类中需要调用父类中的m1方法时，需要使用super。例1
- 子类调用父类中的构造方法时，需要使用super。
注意：super不能用在静态方法中。
注意：一个构造方法第一行如果没有this(…);也没有显示的去调用super(…);系统会默认调用super();如果已经有this了，那么就不会调用super了，super(…);的调用只能放在构造方法的第一行，只是调用了父类中的构造方法，但是并不会创建父类的对象。
class Fu{ public int num = 125; public Fu(){ System.out.println("fu"); } } class Zi extends Fu{ public int num = 256; public Zi(){ System.out.println("zi"); } public void show(){ int num = 512; System.out.println(num); System.out.println(this.num); System.out.println(super.num); } } public class Test { public static void main(String[] args) { Zi z = new Zi(); z.show(); } }
fu
zi
512
256
125
public class Test2_Extends { public static void main(String[] args) { Zi z = new Zi(); } } class Fu { static { System.out.println("静态代码块Fu"); } { System.out.println("构造代码块Fu"); } public Fu() { System.out.println("构造方法Fu"); } } class Zi extends Fu { static { System.out.println("静态代码块Zi"); } { System.out.println("构造代码块Zi"); } public Zi() { System.out.println("构造方法Zi"); } }
静态代码块Fu
静态代码块Zi
构造代码块Fu
构造方法Fu
构造代码块Zi
构造方法Zi
分析：
1.系统将Fu.class和Zi.class分别加载到方法区的内存里面，静态代码会随着.class文件一块加载到方法区里面，所以先打印出了静态代码块中的内容。
2.构造代码块优先于构造方法执行，父类初始化之前，所以打印出父类中的构造代码块和构造方法中的内容。
只要全部符合下面这三种情况，就是多态
- 有继承
- 有方法重写
- 有父类引用指向子类对象
成员变量不存在重写
public class AnimalTest01{ public static void main(String[] args){ Animal a1 = new Cat();//父类引用指向子类对象 大转小，Cat里面有的方法在而a1中没有中无法调用 //如果要是想执行Cat里面的move方法该怎么办？ //只能强制类型转换,需要加强制类型转换符 Cat c1 = (Cat)a1; c1.move(); Animal a2 = new Dog(); //向上转型. //强制类型转换 //Cat c2 = (Cat)a2; //会报错 java.lang.ClassCastException } }
//进行强制类型转换时，需要先使用instanceof进行判断，避免ClassCastException
if(a2 instanceof Cat){
//强制类型转换
Cat c2 = (Cat)a2;
}
final的中文意思是最终，既然是最终就是已经结束了，无法再改变了。在Java里面final关键字同样也有着类似的功能。
- final修饰的类无法被继承。
- final修饰的方法无法被重写。
- final修饰的局部变量，一旦赋值，不可再改变。
- final修饰的成员变量必须初始化值。
- final修饰的引用类型，该引用不可再重新指向其他的java对象。但是fianl修饰的引用，该引用指向的对象的属性值是可以修改的。
在java里面可以使用关键字abstract修饰一个类，这样的类被称为抽象类，abstract修饰的方法叫做抽象方法。抽象类或抽象方法一般也是看不懂的，因为里面可能根本就没有代码。
抽象类的特点
- 抽象类无法被实例化，无法创建抽象类的对象。
- 虽然抽象类没有办法实例化，但是抽象类也有构造方法，该构造方法是给子类创建对象用的。这也算是多态的一种。
- 抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中。
- 抽象类中的子类可以是抽象类，如果不是抽象类的话必须对抽象类中的抽象方法进行重写。
- 抽象类和抽象方法不能被final修饰
public abstract class A{ //构造方法 A(){ System.out.println("A...."); } //抽象方法 public abstract void m1(); public static void main(String[] args){ //抽象类无法创建对象. //A a = new A(); //多态 A a = new B(); } } class B extends A{ public void m1(){ } B(){ super(); //父类的构造方法虽然调用了，但是并没有创建父类对象。 System.out.println("B...."); } }
在java语言里面使用interface来声明一个接口，接口其实是一个特殊的抽象类，在接口里面的方法全部都是抽象的。
- 接口中只能出现常量和抽象方法
- 接口里面没有构造方法，无法创建接口的对象
- 接口和接口之间支持多继承，即一个接口可以有多个父接口
- 一个类可以实现多个接口，即一个类可以有多个父接口
- 一个类如果实现了接口，那么这个类需要重写接口中所有的抽象方法（建议），如果不重写则这个类需要声明为抽象类（不建议）
public interface A{ //常量(必须用public static final修饰) public static final double PI = 3.14; //public static final是可以省略的. //double PI = 3.14; //抽象方法(接口中所有的抽象方法都是public abstract) public abstract void m1(); //public abstract是可以省略的. void m2(); } interface B{ void m1(); } interface C{ void m2(); } interface D{ void m3(); } interface E extends B,C,D{ void m4(); } //implements是实现的意思，是一个关键字. //implements和extends意义相同。 class MyClass implements B,C{ public void m1(){} public void m2(){} }
== 两边如果是引用类型，则比较内存地址，地址相同则是true,反之则false.
Object中的equals方法比较的是两个引用的内存地址。但是在现实的业务逻辑当中，不应该比较内存地址，应该比较地址里面的内容，所以需要对equals方法进行重写。
注意：在使用自己创建的类进行equals比较时，一定要先重写equals方法
finalize方法
finalize方法不需要程序员去调用，由系统自动调用。java对象如果没有更多的引用指向它，则该java对象成为垃圾数据，等待垃圾回收器的回收，垃圾回收器在回收这个java对象之前会自动调用该对象的finalize方法。finalize方法是该对象马上就要被回收了，例如：需要释放资源，则可以在该方法中释放。
java访问级别修饰符主要包括：private 、protected、public和default（默认），可以限定其他类对该类、属性和方法的使用权限。
异常主要分为：Error、一般性异常、RuntimeException
- Error：如果程序出现了Error，那么将无法恢复，只能重新启动程序，最典型的Error的异常是：OutOfMemoryError
- 一般性异常：出现了这种异常必须在程序里面显示的处理，否则程序无法编译通过
- RuntimeException：此种异常可以不用显示的处理，例如被0除异常，java没有要求我们一定要处理。
try { FileInputStream fis = new FileInputStream("d:/monkey1024.txt"); //捕捉FileNotFoundException异常 } catch (FileNotFoundException e) {//jvm会创建FileNotFoundException的对象，然后将e指向这个对象 //如果try里面的代码没有报错，则不会执行catch里面的代码 e.printStackTrace();//打印出异常信息 String msg = e.getMessage(); System.out.println(msg); }
被finally控制的语句体一定会执行，除非在执行finally语句体之前JVM退出(比如System.exit(0))，一般用于关闭资源
即使在方法里面执行了return，finally中的代码也会执行
public class FinallyTest02 { public static void main(String[] args){ int i = m1(); System.out.println(i); } public static int m1(){ int i = 10; try{ return i; }finally{ System.out.println("finally中的语句"); } } }
只有当finally语句执行之前，JVM退出了，finally才不会执行：
public class FinallyTest03 { public static void main(String[] args){ int i = m1(); System.out.println(i); } public static int m1(){ int i = 10; try{ return i; //这里没有catch，所以不用在后面写return了 }finally{ i++; System.out.println("finally中的i=" + i); } } }
程序在执行到return i时，会先将i赋给一个临时变量，return的是这个临时变量：int temp = i;return temp;
，然后再执行finally中的语句，打印出了11，之后再执行main方法中的语句，打印出10。
- final
- final可以修饰类,不能被继承
- 修饰方法,不能被重写
- 修饰变量,只能赋值一次
- finally是try语句中的一个语句体,不能单独使用,语句体中的语句一定会执行
- finalize是Object中的一个方法,当没有引用指向这个对象时，由对象的垃圾回收器在回收之前调用此方法。
如何自定义异常？
可以看下其他Exception里面的源码进行参考。
如果自定义异常是RuntimeException类型的，那就直接继承RuntimeException即可
否则就继承Exception。
继承之后一般提供两个构造方法，如下自定义名为IllegalNameException的异常
public class IllegalNameException extends Exception{ //编译时异常 //public class IllegalNameException extends RuntimeException{ //运行时异常 //定义异常一般提供两个构造方法 public IllegalNameException(){} public IllegalNameException(String msg){ super(msg); } }
public class UserService { //注册的方法 public void register(String name) throws IllegalNameException{ if(name.length()<6){ //需要在这里面一个抛出非法注册名的异常，不过java里面没有类似的 //手动抛出异常 //注意是throw不是throws //使用throw在方法体内抛出异常 throw new IllegalNameException(); } //如果代码能执行到此处，证明用户名是合法的. System.out.println("注册成功！"); } }
throw和throws的区别
throws
用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throw
用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
main方法中的String[] args是专门用来接收命令行参数的。
public class Login { public static void main(String[] args){ if(args.length != 2){ System.out.println("请输入用户名和密码，中间以空格隔开"); return ; } String username = args[0]; String password = args[1]; if("admin".equals(username) && "monkey1024".equals(password)){ System.out.println("登录成功，欢迎["+username+"]回来！"); }else{ System.out.println("登录失败，用户名["+username+"]不存在或者密码错误！"); } } }
在java语言里面，数组一旦创建好之后，长度是不可变的，倘若数组的长度不够使用了，装不下数据之后需要对数组进行扩容，那该如何扩容呢？可以再重新创建一个长度更大的数组，然后将之前的旧数组拷贝到新的数组里面，通过这种方式来进行扩容。
arrayCopy( arr1, 2, arr2, 5, 10);
意思是;将arr1数组里从索引为2的元素开始, 复制到数组arr2里的索引为5的位置, 复制的元素个数为10个.
举例:
Int[] arr1 ={1,2,3,4,5};
arrayCopy(arr1, 3, arr1, 2, 2);
意思是:将arr1从数字4开始 拷贝到arr1的数字3的位置, 拷贝2个数, 也就是说将4和5 拷贝到数字3的位置,相当于删除数字3.
在java.util包里面有个Arrays类，里面提供了排序和二分法查找的方法，程序员直接调用就行，而且这些方法都是静态的，所以在使用时不用创建对象。
public class ArrayTest08 { public static void main(String[] args) { int[] a = {6,8,11,3,15,23,16,1}; int[] b = {6,8,11,3,15,23,16,1}; System.out.println(Arrays.equals(a, b)); Arrays.sort(a);//排序 for(int i=0; i<a.length; i++){ if(i == a.length-1){ System.out.print(a[i]); }else{ System.out.print(a[i] + ","); } } System.out.println(); int result = Arrays.binarySearch(a, 8);//二分法查找 System.out.println(result); System.out.println(); System.out.println(Arrays.toString(a)); } }