java基础面试题----持续补充

文章目录

• • 1. 语法细节
  • 2. 类型转换题
  • 3. 概念题
  • 4. 根据代码，判断结果
  • 5. 集合

1. 语法细节

1. switch是否能作用在byte上，long呢，String呢？

2. java注释有几种，注释有什么用

3. & 和 && 的区别，| 和 || 的区别

4. final 的作用

4. final int a = 1; a = 10;正确吗？final Test test = new Test(“zhangsan”);test.name = “lisi”;正确吗？

5. break,continue,return的区别和作用

6. java多重嵌套循环中，如何跳出指定层循环？

7. == 和 equals 区别是什么

8. String str = "i"与String str=new String(“i”)一样吗？

    public static void main(String[] args) {
        String a = "abc";//直接将"abc"放在常量池，然后栈中a直接指向常量池"abc"
        String b = "a"+"bc";//直接将结果算出来"abc"，然后栈中b直接指向常量池"abc"
        String c = new String("abc");//new String是多余的，先在堆中开辟内存，c指向堆，堆指向常量池"abc"
        System.out.println(a.equals(b)+"     "+c.equals(a));//true true，表示a、b、c的值相同
        System.out.println(a.hashCode()+"    "+ b.hashCode()+"     "+c.hashCode());//3个hashCode值都相同，表示他们最终指向的都是同一个"abc"
        System.out.println(
                System.identityHashCode(a)+"    "+
                System.identityHashCode(b)+"    "+
                System.identityHashCode(c)
        );//356573597    356573597    1735600054,可见a和b的内存地址相同，c的内存地址不同，因为a和b直接指向常量池，而c指向堆

    }

    public static void main(String[] args) {
        String a = "abc";//直接将"abc"放在常量池，然后栈中a直接指向常量池"abc"
        String b = "a"+"bc";//直接将结果算出来"abc"，然后栈中b直接指向常量池"abc"
        String d = "abc"+"";//直接将结果算出来"abc",然后栈中d直接指向常量池"abc"
        /**
         * 变量参与运算，
         * 根据a拿到"abc"，
         * 然后StringBuilder sb = new StringBuilder();
         * 然后sb.append("abc");然后sb.addpen("")
         * sb.toString(),将StringBuilder搞成String，源码是return new String(value, 0, count);
         * 既然new了，那么现在堆中开辟空间
         * call指向堆，然后堆指向"abc"
         */
        String call = a + "";
        System.out.println(a.hashCode()+"   "+call.hashCode());//96354   96354,说明call和a的值都是常量池的"abc"
        System.out.println(
                System.identityHashCode(a)+"    "+
                System.identityHashCode(b)+"    "+
                System.identityHashCode(d)+"    "+
                System.identityHashCode(call)
        );//356573597    356573597    356573597    1735600054,a、b、d 都直接指向常量池"abc" . call指向堆，然后堆指向"abc"

    }

9. String、StringBuffer、StringBuilder的区别于联系

10. int 和 Integer 的区别

11. Java异常关键字

12. Java为什么只能单继承，但可以多实现接口

13. int value = 0;if(value||(value==0)) return true;会返回true吗？

14. 已知String继承Object类，下面两个泛型集合，可以自动向上转型么？

List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
list1 = list2;

15. 已知String继承Object类，下面两个泛型集合，可以自动向上转型么？

List<Object> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>();
List<? extends Object> list3 = null;
list3 = list1;
list3 = list2;

16. 已知A继承B类，下面代码可以正常运行吗？

List<Object> o = new ArrayList<>();
List<A> a = new ArrayList<>();
List<B> b = new ArrayList<>();
List<? extends B> list3 = null;
list3 = a;
list3 = b;
list3 = o;

17. 已知A继承B类，下面代码可以正常运行吗？

List<Object> o = new ArrayList<>();
List<A> a = new ArrayList<>();
List<B> b = new ArrayList<>();
List<? super B> list3 = null;
list3 = a;
list3 = b;
list3 = o;

18. 下面代码中，对与方法参数List<?> list的操作，最终输出结果是什么？

public class A{
	public void a(List<?> list){
		for(Object o:list){
			System.out.println(o)
		}
		list.add("abc");
		list.add(null);
		Object s = list.get(0);
		System.out.println(s)
	}
}
class B{
	public static void main(String[] args){
		A a = new A();
		a.a(new ArrayList<String>());
		a.a(new ArrayList<Integer>());
	}
}

2. 类型转换题

1. short s1=1;s1 = s1+1;有错吗？short s1=1;s1+=1;有错吗?

3. 概念题

1. java 面向对象的特征主要有几个方面？

3. 多态：一个功能的多种访问（实现）形式，例如我们一个接口，可以有多个实现类，例如List接口，我们可以用ArrayList或LinkedList的实现。虽然调的都是List的方法，但是实现不同。同时也有方法重载，同名方法，根据参数列表不同，可以有不同的实现

2. 重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分？

3. java内存分配

4. 根据代码，判断结果

1. 下面代码中，两个数是否交换成功？

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("输出交换前的两个数："+a+"---"+b);
        changeNum(a,b);
        System.out.println("输出交换后两个数"+a+"---"+b);
    }
    public static void changeNum(int num1,int num2){
        int t;
        t = num1;
        num1 = num2;
        num2 = t;
    }
}

5. 集合

1. Comparable 和 Comparator

2. Comparabel接口（内部比较器），实现更简单， Comparator接口(外部比较器)更灵活

import java.util.*;

public class Test implements Comparable<Test>{
    private Integer age;

    public Test(Integer age) {
        this.age = age;
    }

    /**
     * 返回一个int值，正数表示自己（this）比o大,0表示this=o2，负数表示this小于o2
     */
    @Override
    public int compareTo(Test o) {
        //根据年龄决定谁大
        return this.age-o.age;
    }

    @Override
    public String toString() {
        return "Test{" +
                "age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Test test = new Test(1);
        Test test1 = new Test(2);
        ArrayList<Test> tests = new ArrayList<>();
        tests.add(test1);
        tests.add(test);
        System.out.println("list集合排序前"+Arrays.toString(tests.toArray())+"\n\n");
        System.out.println("==========Comparable排序===========");

        int i = test.compareTo(test1);
        System.out.println("Comparable：test和test1谁大（正数表示test大，0表示相等，负数表示test1大）"+i);
        Collections.sort(tests);
        System.out.println("list集合排序后"+Arrays.toString(tests.toArray())+"\n\n");


        System.out.println("==========Comparator排序===========");
        Comparator<Test> comparator = new Comparator<Test>() {

            /**
             * 返回一个int值，正数表示o2>o1,0表示o1=o2，负数表示o2小于o1
             */
            @Override
            public int compare(Test o1, Test o2) {
                //根据年龄决定谁大
                return o2.age-o1.age;
            }
        };
        int compare = comparator.compare(test, test1);
        System.out.println("Comparator：test和test1谁大（正数表示test1大，0表示相等，负数表示test大）"+compare);
        Collections.sort(tests, new Comparator<Test>() {
            /**
             * 返回一个int值，正数表示o2>o1,0表示o1=o2，负数表示o2小于o1
             */
            @Override
            public int compare(Test o1, Test o2) {
                return o2.age-o1.age;
            }
        });
        System.out.println("list集合排序后"+Arrays.toString(tests.toArray()));
    }
}

1. ArrayList和LinkedList 的区别是什么？