Summary_JavaSE面试试题

最新推荐文章于 2021-02-25 22:06:04 发布

家有喜娟儿

最新推荐文章于 2021-02-25 22:06:04 发布

阅读量253

点赞数

分类专栏： Java 面试 Java SE 面试文章标签： Java 面试

本文链接：https://blog.csdn.net/chengtengfei352/article/details/104051155

版权

Java 面试同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

Java SE 面试

1 篇文章 0 订阅

订阅专栏

01、Java 8 新增了Lambda 表达式

    /**
     * Java 8 新增了Lambda 表达式语法,目的为了方便集合的遍历
     * 注意:
     *      数组不可以使用此方式遍历
     *
     * 集合可分:
     *      单列集合 list set
     *      双列集合 map
     *
     */
    @Test
    public void expressionLambda(){

        //单列集合
        List<String> aList = Arrays.asList("张三", "李四", "王五");

        aList.forEach((temp)->System.out.println(temp));
        //结果
            //张三
            //李四
            //王五

        //双列集合
        Map<String,Object> aMap=new HashMap<>();
        aMap.put("name","张三");
        aMap.put("age",22);
        aMap.put("gender","男");

        aMap.forEach((key,value)->System.out.println("key="+key+";"+"value="+value));
        //结果
            //key=gender;value=男
            //key=name;value=张三
            //key=age;value=22
    }

02、比较"equal()"方法和"=="的区别

    /**
     * 比较"equal()"方法和"=="的区别
     *      equal() 比较字面值
     *      ==      除了比较字面值外,还比较对象在内存的地址
     *
     *      数据类型包含
     *          基本数据类型(byte/short/int/long/float/double/char/boolean)
     *          引用数据类型
     *
     */
    @Test
    public void compareEqual(){

        //字符串间比较
        String stra="abc";
        String strb="abc";

        System.out.println(stra.equals(strb));
        System.out.println(stra==strb);
        //结果
            //true
            //true //针对此结果 "abc" 存放在堆内存中,而"stra"和"strb"都在栈内存中,所以地址一样

        //对象间的比较
        String strc=new String("abc");
        String strd=new String("abc");

        System.out.println(strc.equals(strd));
        System.out.println(strc==strd);
        //结果
            //true
            //false //针对此结果 "abc" 存放在堆内存中,并且是通过new 关键字创建的对象,"strc"和"strd"都在栈内存中,存储"abc"的地址,所以"sba"和"sbb"地址不一样
    }

03、比较包装类整形数字是否相等

    /**
     * 比较包装类整形数字是否相等
     *
     *     知识点:
     *          1个字节占8位,共有256种排列组合,范围是:-128~127 即表示,在这个范围内,则使用同一个内存空间,如果超出这个范围的话,则需要重新开辟新的内存空间
     *
     *
     */
    @Test
    public void compareInteger(){

        //定义包装类变量
        Integer i=127;
        Integer j=127;
        Integer m=128;
        Integer n=128;
        Integer l=-128;
        Integer k=-128;

        System.out.println(i==j);
        System.out.println(m==n);
        System.out.println(l==k);
        //结果
            //true
            //false
            //true
    }

04、如何跳出for循环

    /**
     * 如何跳出for循环
     *     使用关键字break 跳出for循环,对于嵌套for循环,因为break 只可以跳出本层for循环,无法跳出全部的for循环,所以还需要添加标志flag
     *
     *
     */
    @Test
    public void jumpOutOfCirculation(){

        flag: //定义标志

        for(int m=0;m<200;m++){
            for(int i=0;i<100;i++){
                System.out.println(i);
                break flag; //标志
            }
        }
    }

05、Native 关键字的作用

    /**
     * Native 关键字的作用
     *     native 代表java访问其他语言编写的代码
     *
     *
     */
    @Test
    public void effectOfKeywordByNative(){

    }

06、&&和&运算符的区别

    /**
     * &&和&运算符的区别
     *     &&:逻辑与或短路与
     *        语法规则:条件1 && 条件2,当条件1与条件2同时为true,则最终结果为true,否则为false;
     *        语法特点:当条件1结果为false时,不会继续判断条件2是否为true;
     *
     *      &:逻辑与或短路与
     *        语法规则:条件1 & 条件2;
     *        语法特点:条件1和条件2都会执行;
     *
     *     实际开发中,会使用逻辑与,因为&&比& 效率高
     */
    @Test
    public void compareLogicalOperators(){
        //定义变量
        int i=1;
        int j=2;

        boolean flag1 = (++i > 10) && (++j > 2);
        System.out.println("i="+i);
        System.out.println("j="+j);
        //结果
            //i=2
            //j=2

        //定义变量
        int m=1;
        int n=2;

        boolean flag2 = (++m > 10) & (++n > 2);
        System.out.println("m="+m);
        System.out.println("n="+n);
        //结果
            //m=2
            //n=3
    }

07、显式类型转换和隐式类型转换

    /**
     * 研究显式类型转换和隐式类型转换
     *
     */
    @Test
    public void typeConversion(){
        //定义变量
        int i=10;//int类型在java中占据4个字节
        long j=100000000000000L;//long类型在java中占据8个字节

        //将j赋值给i
        i=(int)j;
        System.out.println("i="+i);
        //结果
            //i=276447232 针对此结果,对于强制类型转换,可能会出现溢出,即丢失精度(溢出不是错,但数据结果错误,应当避免)

        //定义变量
        int m=100000;//int类型在java中占据4个字节
        long n=m;//long类型在java中占据8个字节

        System.out.println("n="+n);
        //结果
            //n=100000 针对此结果,对于隐式类型转换不会出现溢出
    }

08、JVM/JRE/JDK 的区别

    /**
     * JVM/JRE/JDK 的区别
     *
     *    JVM 是java虚拟机,可运行字节码文件,将字节码文件解释成具体的平台上的指令执行,用于保证java的跨平台特性
     *    JRE 是java的运行环境,提供了运行java应用程序所必需的软件环境,包含java虚拟机和丰富的类库(libraries)
     *    JDK 是java的开发工具,包含了java运行环境的所有内容外,还包含了编写java程序所必需的编译器和调试工具
     *
     */
    @Test
    public void compareNounForJVMJREJDK(){


    }

09、比较 静态变量/静态代码块/静态方法/构造方法 的执行顺序

/**
 * @author 程飞(家有喜娟儿)
 * @description 黄鼠狼
 * @create 2020-01-20 15:00
 * @modify 2020-01-20 15:00
 * @e-mail chengtengfei35@163.com
 * @tel-ph 17331190952
 **/
public class YellowMouseWolf {

    //定义成员变量
    private static String str="我是黄鼠狼!";

    //定义静态代码块
    static {
        System.out.println(str);//此处代码不报错,说明静态成员变量比静态代码块先编译
        System.out.println("我是静态代码块!");
    }

    //定义构造方法
    public YellowMouseWolf(){
        System.out.println("我是构造方法!");
    }

}

    /**
     * 比较 静态变量/静态代码块/静态方法/构造方法 的执行顺序
     *
     *      Java程序包含:
     *          静态成员
     *              静态成员变量
     *              静态代码块
     *              静态方法
     *          实例成员
     *              实例成员变量
     *              实力成员方法
     *
     *       执行顺序是:静态变量-> 静态代码块-> 静态方法-> 构造方法
     */
    @Test
    public void compareExecutionSequence(){

        YellowMouseWolf yellowMouseWolf=new YellowMouseWolf();

        //结果
            //我是黄鼠狼!
            //我是静态代码块!
            //我是构造方法!
    }

10、单例设计模式

/**
 * @author 程飞(家有喜娟儿)
 * @description 饿汉式单例模式(狗)
 * @create 2020-01-20 15:17
 * @modify 2020-01-20 15:17
 * @e-mail chengtengfei35@163.com
 * @tel-ph 17331190952
 **/
public class Dog {

    //使用 final 关键字修饰,表示后续该变量不可修改
    private static final Dog dog=new Dog();

    //构造方法私有化
    private Dog(){
        System.out.println("狗对象被创建了!");
    }

    //对外提供一个公共的获取对象的方法
    public static Dog getInstanceForDog(){
        return dog;
    }
}

/**
 * @author 程飞(家有喜娟儿)
 * @description 懒汉式单例模式(猫)
 * @create 2020-01-20 15:23
 * @modify 2020-01-20 15:23
 * @e-mail chengtengfei35@163.com
 * @tel-ph 17331190952
 **/
public class Cat {

    //未使用 final 关键字修饰,表示后续该变量可修改重新赋值
    private static Cat cat=null;

    //构造方法私有化
    private Cat(){
        System.out.println("猫对象被创建了!");
    }


    //对外提供一个公共的获取对象的方法
    public static Cat getInstanceForCat(){
        if(cat==null){                      //注意:此处如果发生在多线程中,此懒汉设计模式会出现线程安全问题
            cat=new Cat();
        }

        return cat;
    }

}

    /**
     * 单例设计模式
     *
     *     单例
     *         永远只能够创建一个对象
     *     单例书写方式
     *         饿汉式单例设计模式
     *         懒汉式单例设计模式
     *     单例设计模式语法规则
     *         类中的构造方法私有化
     *         需要对外提供一个公共的获取对象的方法
     *
     *     注意
     *         如果发生在多线程中,懒汉设计模式会出现线程安全问题
     */
    @Test
    public void designModeSingle(){
        //饿汉式单例设计模式
        Dog instanceForDog1 = Dog.getInstanceForDog();
        Dog instanceForDog2 = Dog.getInstanceForDog();
        System.out.println(instanceForDog1);
        System.out.println(instanceForDog2);
        //结果
            //狗对象被创建了!
            //cn.tedu.store.Interview.Dog@48eb9836
            //cn.tedu.store.Interview.Dog@48eb9836

        //懒汉式单例设计模式
        Cat instanceForCat1 = Cat.getInstanceForCat();
        Cat instanceForCat2 = Cat.getInstanceForCat();
        System.out.println(instanceForCat1);
        System.out.println(instanceForCat2);
        //结果
            //猫对象被创建了!
            //cn.tedu.store.Interview.Cat@6c518474
            //cn.tedu.store.Interview.Cat@6c518474
    }

11、比较 String/StringBuffer/StringBuilder

    /**
     * 比较 String/StringBuffer/StringBuilder
     *
     *     String
     *          当字符串被频繁的修改时,会在内存中不停的开辟空间,容易造成内存空间浪费的现象
     *     StringBuffer/StringBuilder
     *          当字符串被频繁的修改时,一直使用的是同一个内存空间
     *     StringBuffer
     *          在多线程中是安全的
     *     StringBuilder
     *          在多线程中会出现线程安全问题,在单线程中,StringBuilder的效率比StringBuffer的效率高
     */
    @Test
    public void compareStringStringBufferStringBuilder(){

        //定义String类型变量
        //首先在堆内存开辟空间,存储 hello,然后栈内存中存储 str1 ,地址指向 hello ;
        //继续执行,则堆内存中重新开辟空间, 存储 张三,然后栈内存存储 str1 ,指向 张三;
        //...... 以此类推......
        String str1="hello";
        str1="张三";
        str1="李四";
        str1="王五";


        //定义StringBuffer类型变量
        //首先在堆内存开辟空间,存储 hello,然后栈内存中存储 str1 ,地址指向 hello ;
        //在堆内存中继续追加字符串 张三,并没有开辟新的内存空间
        //...... 以此类推......
        StringBuffer sb1=new StringBuffer("hello");
        sb1=sb1.append("张三");
        sb1=sb1.append("李四");
        sb1=sb1.append("王五");
    }

12、比较 ArrayList/LinkedList

    /**
     * 比较 ArrayList/LinkedList
     *
     *     ArrayList
     *          底层是数组(Object 类型数组),因此查询数据很快,但对于数据的增删操作比较慢
     *     LinkedList
     *          底层是链表,因此查询数据很慢,但对于数据的增删操作很快
     */
    @Test
    public void compareArrayListLinkedList(){

    }

13、比较 HashMap/Hashtable

    /**
     * 比较 HashMap/Hashtable
     *
     *     HashMap和Hashtable 的底层都是 Hash表;
     *     HashMap是jdk1.5之后出现的版本,而Hashtable是jdk1.5之前出现的版本;
     *     HashMap是线程非安全的,而Hashtable是线程安全的;
     *     HashMap的key/value可以为null,而Hashtable的key/value不可以为null;
     */
    @Test
    public void compareHashMapHashtable(){

    }

14、比较 编译期异常/运行期异常

    /**
     * 比较 编译期异常/运行期异常
     *
     *     java的编译和运行过程:
     *         首先进入编译期,通过java编译器,将java源文件(.java),编译成java字节码文件(.class);
     *         然后进入运行期,先进行类加载和字节码文件校验,之后,java字节码文件经过java虚拟机解释成为具体平台的具体指令,并运行
     *
     *     编译期异常
     *         源文件编译成字节码文件时出现的异常称之为编译期异常
     *     运行期异常
     *         当程序被执行时发生的异常称之为运行期异常
     */
    @Test
    public void compareEexceptionForCompileAndRun(){

        //编译期异常
        FileNotFoundException fileNotFoundException=new FileNotFoundException();
        IOException ioException=new IOException();
        ClassNotFoundException classNotFoundException=new ClassNotFoundException();
        EOFException eofException=new EOFException();
        IllegalArgumentException argumentExceptionBian=new IllegalArgumentException();

        //运行期异常
        NullPointerException nullPointerException=new NullPointerException();//空指针异常
        ArithmeticException arithmeticException=new ArithmeticException();//除数为0异常
        ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException=new ArrayIndexOutOfBoundsException();
        StringIndexOutOfBoundsException stringIndexOutOfBoundsException=new StringIndexOutOfBoundsException();
        IllegalArgumentException argumentExceptionYun=new IllegalArgumentException();
    }

15、常见的加密算法

    /**
     * 常见的加密算法
     *
     *    DES/AES/RSA/Base64/MD5
     *
     */
    @Test
    public void encryptionAlgorithm() throws Exception {

        String[] attrs={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};

        //MD5:单向加密算法,任何明文经过加密都是变成一个长度为32位的字符串
        MessageDigest md5 = MessageDigest.getInstance("MD5");

        //明文密码
        String pwd = "123456";

        //字节的长度永远为16
        byte[] digest = md5.digest(pwd.getBytes("UTF-8"));

        //用来记录明文加密后的密文字符串
        String miWen = "";
        for(byte b:digest){
            int temp =b;
            if(temp<0){
                temp+=256;
            }
            int index1 = temp /16;
            int index2 = temp%16;
            miWen+=attrs[index1]+attrs[index2];
        }
        System.out.println("加密后的密文字符串为:"+miWen);
        //结果
            //加密后的密文字符串为:e10adc3949ba59abbe56e057f20f883e
    }

16、标识符命名规则

    /**
     * 标识符命名规则
     *
     *     可以由数字/字母/下划线(_)/$进行组合,不能够以数字作为开头
     *     合法的命名:a1、_abc(不推荐)、abc$
     */
    @Test
    public void rulesNaming(){

    }

17、java中的数据类型

    /**
     * java中的数据类型
     *
     *      基本数据类型
     *          byte/short/int/long/char/float/double/boolean
     *      引用数据类型
     *          Dog/Cat
     */
    @Test
    public void typeData(){

    }

18、java中三种技术架构

    /**
     * java中三种技术架构
     *
     *     J2ME 小型产品,是为了开发电子消费产品和嵌入式设备提供的解决方案,如手机
     *     J2SE java标准版,集合/多线程/面向对象等
     *     J2EE 企业版,jsp/servlet等
     */
    @Test
    public void TechnicalFramework(){

    }

19、比较 重写/重载

    /**
     * 比较 重写/重载
     *
     *      重写
     *          字类中的方法与父类中的方法相同
     *      重写
     *          同一个类中,多个方法名称一样,但是参数类型或参数个数不同
     */
    @Test
    public void compareRewriteReload(){

    }

20、内存结构

    /**
     * 内存结构
     *
     *    内存是由java虚拟机JVM管理的,其内存结构为:
     *      栈:用来存储局部变量,包含方法的参数,当数据使用完毕,所占的空间会自动释放
     *      堆:用来存储数组或对象,通过new关键字建立实例,都放在堆内存中,包含成员变量
     *      方法区:用来存储java字节码文件,包括静态成员/构造函数/常量池/线程池
     *      本地方法区:windown系统所占用
     */
    @Test
    public void structureMemory(){

    }

21、谈谈面向对象的思想

    /**
     * 谈谈面向对象的思想
     *
     *    面向对象是相对于面向过程而言的,面向过程强调的是过程,而面向对象则强调的是面向对象的封装;
     *    面向对象是java的核心思想,这个思想来源于人们的实际生活中;
     *    面向对象的三大特征:
     *       封装
     *          把描述一个对象的属性和行为封装成一个类,把具体的业务逻辑功能实现封装成一个方法,其次封装的意义还有效的保护属性通过访问修饰符私有化属性(成员变量),公有化方法
     *       继承
     *          实现代码的复用,所有的子类所共有的行为和属性抽取为一个父类,所有的子类继承该类可具备父类的属性和行为,继承具有单一性和传递性
     *       多态
     *          程序中定义的引用类型变量所指向的具体类型和调用的具体方法在程序编译阶段无法确定,而是在运行期才能确定该引用类型变量指向具体哪个对象而调用在哪个类中声明的方法
     *          多态的表现形式有强制类型转换,向上造型等,多态可分为行为多态和对象多态
     *              行为多态:同一个run( ){ }方法,不同的对象调用时会有不同的实现,猫调用时是跑,鱼调用时是游,鸟调用时是飞
     *              对象多态:同一个对象,可以被造型为不同的类型,比如同一个人对象,可以被造型为儿子,父亲,员工等
     */
    @Test
    public void orientedObject(){

    }

22、比较 成员变量/局部变量

    /**
     * 比较 成员变量/局部变量
     *
     *     成员变量
     *        放置在类中的变量,称之为成员变量,与方法是平级关系
     *     局部变量
     *        放置在方法体中的变量,称之为局部变量
     *
     *     成员变量与局部变量的区别:
     *        作用域不同,成员变量针对整个类有效,而局部变量则在某个范围内有效,如方法体或循环体中
     *        存储位置不同,成员变量随着对象的创建而存在,随着对象消失时而消失,存储在堆内存中,而局部变量是在被调用或者被执行的时候存在,存储在栈内存中
     *        初始值不同,成员变量有默认的初始值(基本数据类型有各自特有的默认值,引用数据类型的默认值是null)
     */
    @Test
    public void compareOfVariableMemberAndLocal(){

    }

23、比较 成员变量/静态变量

    /**
     * 比较 成员变量/静态变量
     *
     *     成员变量与静态变量区别:
     *        调用方式不同,静态变量也称之为类变量,可以直接通过类名调用,也可以通过对象名调用
     *        存储位置不同,静态变量存储在方法区的静态区,而成员变量存储在堆内存中
     *        生命周期不同,静态变量随着类的加载而存在,随着类的消失而消失,生命周期很长,而成员变量随着对象的创建而存在,随着对象的消失而消失
     *        与对象的相关性不同,静态变量是所有对象共享的数据,而成员变量是每个对象所特有的
     */
    @Test
    public void compareOfVariableMemberAndStatic(){

    }

24、匿名对象

/**
 * @author 程飞(家有喜娟儿)
 * @description 学生对象匿名类
 * @create 2020-01-21 8:10
 * @modify 2020-01-21 8:10
 * @e-mail chengtengfei35@163.com
 * @tel-ph 17331190952
 **/
public class Student {


    /**
     * 学习方法(static 方便调用)
     *
     * @param aList
     */
    public static void study(List<String> aList){
        aList.forEach((temp)->System.out.println(temp));
    }

}

    /**
     * 匿名对象
     *
     *    没有名字的对象,称之为匿名对象,是对象的一种简写形式
     *
     *    匿名对象的应用场景:
     *        可以作为实际参数在方法传递中使用
     *        只调用类中的一次方法
     */
    @Test
    public void anonymousObject(){

        //非匿名类演示
        List<String> aList=new ArrayList<>();
        aList.add("语文");
        aList.add("数学");
        aList.add("英语");
        Student.study(aList);

        //匿名类演示
        Student.study(new ArrayList<String>());
    }

25、JDBC 代码

    /**
     * JDBC 代码
     *
     *      步骤:
     *          1导入数据库所用的包
     *          2加载驱动
     *          3创建java代码与数据库的连接对象
     *          4创建statement对象
     *          5书写SQL语句,发送SQL,接受结果
     *          6关闭资源
     */
    @Test
    public void codeOfJDBC() throws Exception {
        //1、导入数据库所用的包

        //2、加载驱动
        Class.forName("com.mysql.jdbc.Driver");

        //3、创建java代码与数据库的连接对象
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/tedu_store", "root", "root");

        //4、创建statement对象
        Statement statement = connection.createStatement();

        //5、书写SQL语句,发送SQL,接受结果
        String sql = "INSERT INTO t_user(username,password) VALUES('王二麻子','123456')";
        int i = statement.executeUpdate(sql);
        //6、关闭资源
        statement.close();
        connection.close();

        System.out.println("i="+i);
        //结果
            //i=1
    }

26、比较 this/static 关键字

    /**
     * 比较 this/static 关键字
     *
     *     this关键字
     *         代表是本类对象的引用,谁调用this所在的方法,this就代表是谁
     *     static关键字
     *         用来修饰成员变量和成员方法
     *
     *     静态的特点:
     *         1、随着类的加载而加载
     *         2、优先与对象存在
     *         3、对所有的对象共享
     *         4、可以被类名直接调用
     */
    @Test
    public void compareOfKeyThisAndStatic(){

    }

27、普通类/抽象类/接口之间的相关问题

    /**
     * 普通类/抽象类/接口之间的相关问题
     *
     *     普通类
     *          普通类没有抽象的方法
     *     抽象类
     *          抽象类中可以有抽象方法,也可以没有抽象方法
     *     接口
     *          接口中所有的方法都为抽象方法(由 public abstract 修饰)
     *          接口中所有的变量都必须由 public static final 修饰
     *
     *     相关问题:
     *          1、普通类是否可以继承抽象类:可以
     *          2、普通类是否可以实现接口:可以
     *          3、抽象类是否可以继承普通类:可以
     *          4、抽象类是否可以继承抽象类:可以
     *          5、抽象类是否可以继承接口:可以
     *          6、接口是否可以继承普通类:不可以
     *          7、接口是否可以继承抽象类:不可以
     *          8、接口是否可以继承接口:可以
     *
     *      总结:
     *          接口不可以继承/实现任何类
     */
    @Test
    public void compareOfClassOrdinaryAbstractInterface(){

    }

28、多态

    /**
     * 多态
     *
     *    多态是指同一个对象在程序不同的时刻的多种运行状态
     *
     *    多态发生的条件
     *        声明类型与实际类型不一致
     *        子类重写父类的方法
     */
    @Test
    public void polymorphic(){

    }

29、四种访问修饰符的访问权限

    /**
     * 四种访问修饰符的访问权限
     *
     *    public是公共的
     *          被public所修饰的成员(变量和方法)可以在任何类中都能被访问到
     *    protected是受保护的,受到该类所在的包所保护
     *          被protected修饰的成员(变量和方法)会被位于同一包中的所有类访问到
     *          被protected修饰的成员(变量和方法)也能被该类的所有子类继承下来(注意:这里是指同一个package或者不同的package中的子类都能访问)
     *    private是私有的
     *          被private所修饰的成员(变量和方法)只能在当前类中被访问到,它的作用域最小
     */
    @Test
    public void modifierAccess(){

    }

30、Properties 类

#mysql
driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/jdbc
username=root
password=root

    /**
     * Properties 类
     *
     *     主要作用是为了操作.properties 配置文件
     *
     *
     */
    @Test
    public void classProperties() throws IOException {

        //创建一个Properties对象
        Properties properties=new Properties();
        //将props对象与jdbc.properties文件关联
        InputStream resourceAsStream = JavaSeInterview.class.getClassLoader().getResourceAsStream("jdbc.properties");
        properties.load(resourceAsStream);
        //读取jdbc.properties文件中的数据
        String driver=properties.getProperty("driver");
        System.out.println("driver="+driver);
    }

31、final 关键字

    /**
     * final 关键字
     *
     *       final是一个修饰符,可以修饰类/变量/方法
     *          final 修饰类时:当以类被final修饰时,这个类不可以被其他类继承
     *          final 修饰变量:变量就变成为一个常量
     *          final 修饰方法:此法发不可以被字类重写
     */
    @Test
    public void keyFinal(){

    }

32、Arrays/Math/Random 常用的工具类

    /**
     * Arrays/Math/Random 常用的工具类
     *
     *      Arrays工具类主要操作数组,如方法 sort(参数) asList() 注意:通过asList() 方法操作后返回的结果是固定的长度,后期不可以往该集合中再添加数据
     *      Math  工具类主要操作跟数学有关,如方法 abs(参数) pow(2,3)
     *      Random工具类主要用来操作随机数
     *
     *
     *
     */
    @Test
    public void classCommonlyUtil(){

    }

33、instanceOf关键字

    /**
     * instanceOf关键字
     *
     *     作用是
     *          判断对象是否属于某个类型
     *     语法是
     *          对象名 instanceOf 子类(实现)名,返回值是boolean类型
     *
     *
     */
    @Test
    public void compareOfInstanceOf(){
        ArrayList<String> arrayList=new ArrayList<>();

        boolean flag = arrayList instanceof List;
        System.out.println("flag="+flag);
        //结果
            //flag=true
    }

34、多线程相关问题

/**
 * @author 程飞(家有喜娟儿)
 * @description 继承Thread类的线程
 * @create 2020-01-21 12:01
 * @modify 2020-01-21 12:01
 * @e-mail chengtengfei35@163.com
 * @tel-ph 17331190952
 *
 *         说明:
 *              1、创建一个继承于Thread类的子类
 *              2、重写Thread类中的run():将此线程要执行的操作声明在run()
 *              3、创建Thread的子类的对象
 *              4、调用此对象的start():①启动线程 ②调用当前线程的run()方法
 *
 **/
public class MyThread1 extends Thread{

    private int ticket=10;//这里的变量会压入局部变量表 因为并没有用static声明

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(this.ticket>0){
                System.out.println("sell,ticket="+this.ticket--);
            }
        }
    }
}

/**
 * @author 程飞(家有喜娟儿)
 * @description 实现Runnable接口的线程
 * @create 2020-01-21 12:02
 * @modify 2020-01-21 12:02
 * @e-mail chengtengfei35@163.com
 * @tel-ph 17331190952
 *
 *         1、创建一个实现Runnable接口的类
 *         2、实现Runnable接口中的抽象方法:run():将创建的线程要执行的操作声明在此方法中
 *         3、创建Runnable接口实现类的对象
 *         4、将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
 *         5、调用Thread类中的start():① 启动线程  ② 调用线程的run() --->调用Runnable接口实现类的run()
 **/
public class MyThread2 implements Runnable{
    private int ticket=10;//这里的变量会压入局部变量表 因为并没有用static声明

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(this.ticket>0){
                System.out.println("sell,ticket="+this.ticket--);
            }
        }
    }
}

    /**
     * 多线程相关问题
     *
     *      什么是进程
     *          正在执行的程序
     *      什么是线程
     *          进程内部的一条执行路径或一个控制单元
     *      实现线程的方式
     *          1、让普通类继承Thread类
     *          2、让普通类实现Runnable接口,使用Runnable接口实现多线程可以避免单继承的局限性
     *      run()方法与start()方法的区别
     *          run()方法存放线程需要执行的代码块
     *          start()方法用于启动线程
     *      如何保证线程安全
     *          将多个线程执操作的共享对象用锁锁起来
     */
    @Test
    public void problemMultithreading(){
        //继承Thread类的线程
        MyThread1 myThread11=new MyThread1();
        MyThread1 myThread12=new MyThread1();
        MyThread1 myThread13=new MyThread1();

        myThread11.start();
        myThread12.start();
        myThread13.start();

        //实现Runnable接口的线程
        MyThread2 myThread2=new MyThread2();

        new Thread(myThread2).start();
        new Thread(myThread2).start();
        new Thread(myThread2).start();
    }

35、比较 字节流/字符流

    /**
     * 比较 字节流/字符流
     *
     *      常见的字节流
     *          输入字节流 FileInputStream  BufferedInputStream  ObjectInputStream
     *          输出字节流 FileOutputStream BufferedOutputStream ObjectOutputStream
     *      常见的字符流
     *          输入字符流 FileReader BufferedReader
     *          输出字符流 FileWirter BufferedWirter
     *
     *      字节流/字符流的区别
     *          当读取纯文本文件(只有文字字符),使用字符流比较方便
     *          当读取图片/视频/音频时需要使用字节流
     */
    @Test
    public void compareOfStreamByteAndCharacter(){

    }

36、序列化

    /**
     * 序列化
     *
     *    对象最开始是不可以保存到硬盘上的,如果需要将对象保存在硬盘中时,需要让该对象实现序列化
     *    实现序列化的方法
     *       让对象实现序列化Serializable接口
     *       生成序列号
     */
    @Test
    public void serializable(){

    }

37、反射

    /**
     * 反射
     *
     *    Class是反射的根基,Class对象代表着是某一个类编译后的字节码文件
     *    创建类对象的三种方式
     *       Class.forName("类的全路径名")
     *       类名.class
     *       对象名.getClass()
     */
    @Test
    public void reflex(){

    }

38、XML 文件

    /**
     * XML 文件
     *
     *     主要作用
     *         用来做配置文件(springMVC、Spring、Mybatis、Hibernate、Struts2等)
     *
     *     约束文件
     *         dtd
     *         xsd
     *
     *     解析方式
     *         dom 解析(占用内存,前后反复遍历)
     *         sax 解析(节省内存,只能向后遍历数据)
     */
    @Test
    public void fileForXML(){

    }

39、网路编程

    /**
     * 网路编程
     *
     *    网路编程的协议(可控制网路的带宽,可限制浏览数据)
     *       TCP 协议
     *              三次握手(第1次:我问你在么?  第2次:你回答在 第3次:我反馈我知道你在)
     *       UDP 协议
     *              将数据源和目的封装成为数据包,不需要建立连接
     *       HTTP协议
     *              超文本传输协议
     */
    @Test
    public void programmingNetwork(){

    }

家有喜娟儿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Summary_JavaSE面试试题

01、Java 8 新增了Lambda 表达式 /** * Java 8 新增了Lambda 表达式语法,目的为了方便集合的遍历 * 注意: * 数组不可以使用此方式遍历 * * 集合可分: * 单列集合 list set * 双列集合 map * */ @T...
复制链接

扫一扫