回顾Java基础

Java基础

JDK、JRE、JVM的区别

JDK是Java程序开发包,通过它可以编写Java程序
JRE是运行Java的环境集合，没有它无法运行Java程序
JVM是Java虚拟机用于运行Java字节码文件(.class)，是Java的核心

为什么Java能够实现跨平台

JVM只认识字节码文件，针对不同的操作系统有不同的JVM实现

常用数字类型的区别

整型和单精度占用4个字节，长整型和双精度占用8个字节
整型的取值范围是:-21亿~+21亿

以下程序的执行结果?

package com.xiaopeng.pre;

import org.junit.Test;

public class Practice {
     
    @Test
        public void a(){
     
            float d1=456327196;
            float d2=d1+1;
            if(d1==d2){
     
                System.out.println("d1==d2");
            }else{
     
                System.out.println("d1!=d2");
            }
        }
}

运行结果:

原因:float类型在内存中的存储方式为科学计数法,只保留小数后面的七位，d1和d2的值均为:4.5632719E7

编写随机生成50~150之间的随机整数

package com.xiaopeng.pre;

import org.junit.Test;

import java.util.Random;

public class Practice {
     
    @Test
        public void a(){
     
            int min=50,max=150;
            System.out.println(new Random().nextInt(max-min)+min);
        }
}

编写输出1~1000内所有的质数

package com.xiaopeng.pre;

import org.junit.Test;

public class Practice {
     
    @Test
    public void a(){
     
        for(int i=2;i<=1000;++i){
     
            boolean f=true;
            for(int j=2;j<i;j++){
     
                if(i%j==0){
     
                        f=false;break;
                }
            }
            if(f) System.out.print(i+" ");
        }
    }
}

面向对象的三大特征

封装,继承,多态
-封装:
1.实现开发者和使用者的分工
2.减少代码耦合(面向接口编程)
3.可以自由修改类的内部结构
-继承:
1.类不支持多继承，一个类只能有一个父类，父类是子类的抽象化，
子类是父类的具体化
2.接口支持多继承，一个接口可以继承多个接口
-多态:
对于接口给出了抽象方法后,由子类实现,且子类实现的方式多样化.
比如父类引用指向子类，父类对象调用子类方法,实现向上转型.

接口类和抽象类的异同点

-同:
1.都是上层的抽象
2.不能被实例化
3.都可以包含抽象方法
-异:
1.抽象类可以包含方法实现,接口类方法只能由子类实现.
2.继承类只能继承一个抽象类,实现类能够实现多个接口类.
3.抽象程度:接口类>抽象类>实现类

静态变量和实例变量的区别

语法:静态变量前要加static关键字，实例不用
隶属:静态变量属于类,实例变量属于对象的属性
运行:静态变量在JVM加载类时创建,实例变量在实例化对象时创建

以下程序类的执行顺序?

package com.xiaopeng.pre;

import org.junit.Test;

public class Practice {
     
    @Test
    public void a() {
     
        new Small();
    }
}
class Big {
     
    static {
     
        System.out.println("父类静态");
    }

    {
     
        System.out.println("父类非静态");
    }

    public Big() {
     
        System.out.println("父类无参构造");
    }
}
class Small extends Big{
     
    static {
     
        System.out.println("子类静态");
    }
}

运行结果:

原因:静态、父类优先,非静态优先于构造块

Error和Exception的区别和联系

-Error：
1.不可控制,无法预期,如内存溢出、虚拟机错误
2.经常用来表示系统错误或底层资源的错误
3.只能通过中断程序的运行来解决
-Exception:
1.可控,可预期
2.表示一个由程序员导致的错误
3.利用try,catch进行捕捉来解决
-同:二者共同实现了Throwable接口
-异:Exception还有许多子类,如RuntimeException

以下程序运行结果?

package com.xiaopeng.pre;

import org.junit.Test;

public class Practice {
     
    @Test
    public void a() {
     
        String a1="ab";
        String a2="ab";
        String a3="ab"+"cd";
        String a4="abcd";
        String a5=a2+"cd";
        String a6=new String("ab");
        System.out.println(a1==a2);
        System.out.println(a3==a4);
        System.out.println(a4==a5);
        System.out.println(a4.equals(a5));
        System.out.println(a1==a6);
    }
}

运行结果:

原因:a1和a2指向常量池中相同地址,a3和a4指向常量池中相同地址.
a4和a5指向常量池中不同的地址,a4和a5指向的地址的值相同,a6并不存放在常量池里,所以a1和a6的地址信息不同

String,StringBuider,StringBuffer的区别

-String:
1.把数据存放于常量池中,用final来修饰,所以线程安全.
2.把数据存放于常量池中,执行速度慢,不适合多字符串拼接
-StringBuffer:
1.执行速度中等,线程安全
2.适合多线程处理
-StringBuider:
1.执行速度最高,线程不安全
2.适合单线程处理

List,Set的区别

-List(常用类ArrayList,LinkedList):
1.允许出现重复
2.允许为空
3.允许有序
-Set(常用类:HashSet,LinkedHashSet,TreeSet)
1.不允许重复
2.不允许为空
3.不允许有序
-ArrayList:
1.基于动态数组(在内存中所有数据存储是连续紧挨着的)
2.连续读取遍历
3.适用于大数据量读取的场景
-LinkedList:
1.基于链表(每一个元素都是松散的,元素与元素之间采用指针方式连接)
2.指针遍历
3.适用于频繁新增和插入的写操作
-HashSet:
1.不能保证顺序(以哈希值作为排序的依据)
2.基于HashMap
3.基于Hash表实现
-TreeSet:
1.按照预期规则排序
2.基于TreeMap
3.基于二叉树实现

编程实现对List排序

package com.xiaopeng.pre;

import org.junit.Test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Practice {
     
    @Test
    public void a() {
     
        List<Employee> emps=new ArrayList<Employee>();
        emps.add(new Employee("李四",25,2000f));
        emps.add(new Employee("王五",27,4000f));
        emps.add(new Employee("赵六",24,3000f));
        Collections.sort(emps, new Comparator<Employee>() {
     
            public int compare(Employee o1, Employee o2) {
     
                return (int)(o1.getSalary()-o2.getSalary());
            }
        });
        System.out.println(emps);
    }
}

运行结果:

原因:采用Comparator接口进行自定义排序(该接口对所有List结构均适用),根据薪水排序,返回值>0则升序,返回值<0则降序.

编程实现对TreeSet排序

package com.xiaopeng.pre;

import org.junit.Test;

import java.util.Comparator;

import java.util.TreeSet;

public class Practice {
     
    @Test
    public void a() {
     
        TreeSet<Employee> emps=new TreeSet<Employee>(new Comparator<Employee>() {
     
            public int compare(Employee o1, Employee o2) {
     
                return (int)(o2.getSalary()-o1.getSalary());
            }
        });
        emps.add(new Employee("李四",25,2000f));
        emps.add(new Employee("王五",27,4000f));
        emps.add(new Employee("赵六",24,3000f));
        System.out.println(emps);
    }
}

运行结果:

原因:采用Comparator接口进行自定义排序(该接口对所有Set结构均适用),根据薪水排序,返回值>0则升序,返回值<0则降序.

Object类hashCode()和equals()的区别

-hashCode():
内存地址经过哈希运算后返回一个整型数据,速度快
-equals():
考虑多种因素后判断两个对象地址是否相同,速度慢

Java IO中有几种类型的流

-字节流:
输入流:InputStream,FileInputStream,BufferedInputStream
输出流:OutputStream,FileOutputStream,BufferedOutputStream
-字符流:
输入流:Reader,FileReader,InputStreamReader,BufferedReader
输出流:Writer,FileWriter,OutputStreamWriter,BufferedWriter

利用IO实现文件复制

package com.xiaopeng.pre;

import org.junit.Test;

import java.io.*;

public class Practice {
     
    @Test
    public void a() {
     
        File source=new File("E:/a.rar");
        File goal=new File("E:/a/a.rar");
        InputStream input=null;
        OutputStream output=null;
        try {
     
            input=new FileInputStream(source);
            output=new FileOutputStream(goal);
            byte hc_area[]=new byte[1024];
            int byteRead;
            while((byteRead=input.read(hc_area))!=-1){
     
                output.write(hc_area,0,byteRead);
            }
        }catch (Exception e){
     
            e.printStackTrace();
        }finally {
     
            try {
     
                input.close();
                output.close();
            }catch (Exception e){
     
                e.printStackTrace();
            }
        }
    }
}

运行结果:实现了将E:/a.rar复制到"E:/a/a.rar.

JVM的内存组成

-共享区:
1.方法区(Method Area)：存放静态变量、常量
2.堆(Heap):存放在程序运行时所创建的对象实例
-私有区:
1.程序计数器(PC):当前线程所执行的字节码指令的行号指示器
2.虚拟机栈(VM Stack):每一次Java方法的调用,都会在调用栈上维护一个独立的栈帧
3.本地方法栈(Native Method Stack):用于调用底层方法

JVM的垃圾回收机制

-垃圾回收器GC:
1.用于回收不再使用的内存
2.负责分配内存、确保引用、回收内存
3.回收依据是某对象无任何引用
4.通过有向图识别哪些对象可保留，哪些对象进行垃圾回收
-垃圾回收算法:
1.引用计数算法
2.跟踪回收算法
3.压缩回收算法
4.复制回收算法
5.按代回收算法

Java存在内存泄漏的几种情况

-静态集合类
-数据库连接,io连接,没有关闭的情况下
-监听器监听指定的类和对象并响应其产生的行为的过程中
-作用域,一个变量只在起作用的区域使用，避免资源浪费

对象的浅复制和深复制

-浅复制:只对对象及变量值进行复制,引用对象地址不变
-深复制:在浅复制基础上,引用对象地址也进行复制