关于java学习中的一些易错点(基础篇)

由JVM来负责Java程序在该系统中的运行，不同的操作系统需要安装不同的JVM，这样Java程序只需要跟JVM打交道，底层的操作由JVM去执行。

JRE（Java Runtime Environment）即Java运行时环境，主要负责运行Java程序。

JDK（Java Development Kit）即Java开发工具包，主要用来开发Java程序。

安装完JDK后，JDK的安装路径下会有一些文件夹，那这些文件夹里面的文件都是做什么的呢？

bin目录：该目录用于存放一些可执行程序。

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));
 
    }
 
}