欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-06-10 17:50:09
由JVM来负责Java程序在该系统中的运行,不同的操作系统需要安装不同的JVM,这样Java程序只需要跟JVM打交道,底层的操作由JVM去执行。 JRE(Java Runtime Environment)即Java运行时环境,主要负责运行Java程序。 JDK(Java Development Ki ......

由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结尾的文件,我们称之为源文件,把在源文件里面所编写的代码叫做源代码。但是这个.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文件(字节码文件)


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

通过上图来看,程序是这样执行的:

  1. 将studenttest01.class文件加载到方法区
  2. 将student.class文件加载到方法区
  3. main方法压栈
  4. 在堆里面创建一个student的对象
  5. 栈里面的s指向堆里面student对象的内存地址0x0101
  6. 给对象的成员变量进行赋值
  7. 方法弹栈
  8. 程序执行结束

如果堆里面的对象没有被指向,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(默认),可以限定其他类对该类、属性和方法的使用权限。

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

 

 

 

异常主要分为:error、一般性异常、runtimeexception

  • error:如果程序出现了error,那么将无法恢复,只能重新启动程序,最典型的error的异常是:outofmemoryerror
  • 一般性异常:出现了这种异常必须在程序里面显示的处理,否则程序无法编译通过
  • runtimeexception:此种异常可以不用显示的处理,例如被0除异常,java没有要求我们一定要处理。

关于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是专门用来接收命令行参数的。

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

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


    }

}