Java基础知识总结-2

最新推荐文章于 2022-04-07 21:54:54 发布

笔上烽烟

最新推荐文章于 2022-04-07 21:54:54 发布

阅读量86

点赞数

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_38856939/article/details/111452944

版权

Java基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

这里基于Java的基础知识列举一些题目，这些题目比较考验基本功是否扎实。同样这些有可能作为职场面试题出现，所有大家可以好好看看。

文章目录

- 面向对象

面向对象

问题1：以下代码，是否相互构成重载？

public class BasicTest {
	public void test(String[] msg){
		System.out.println("含字符串数组参数的test方法");
	}
	public void test(String book){
		System.out.println("单个字符串参数的test方法");
	}
	public void test(String... books){
		System.out.println("形参长度可变的test方法");
	}
}

问题2：以下代码，结果是什么？

public class BasicTest {
	public static void main(String[] args) {
		BasicTest to = new BasicTest();
	    to.test();
	    to.test("aa");
	    to.test("aa" , "bb");
	    to.test(new String[]{"aa"});	
	}	
	public void test(String msg){
		System.out.println("单个字符串参数的test方法");
	}
	public void test(String... msg){
		System.out.println("形参长度可变的test方法");
	}
}

public class BasicTest {
	public static void main(String[] args) {
		BasicTest to = new BasicTest();
	    to.test();
	    to.test("aa");
	    to.test("aa" , "bb");
	    to.test(new String[]{"aa"});
	}
	
	public void test(String[] msg){
		System.out.println("含字符串数组参数的test方法");
	}
	public void test(String msg){
		System.out.println("单个字符串参数的test方法");
	}
}

public class TransferTest {
    public static void main(String args[]) {
        TransferTest test = new TransferTest();
        test.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
    }
}

class Value {
	int i = 15;
}

问题3：以下的所有方法是否构成重写？

public class BasicTest extends Super{
	
    public String method(int i) {
    	System.out.println("Subclass");
    	return null;
    }
    public Object eat(int ii) {
        System.out.println("Subclass eat");
        return null;
    }
    public short free(int ii) {
        System.out.println("Subclass free");
        return 2;
    }
    private void own(int ii) {
        System.out.println("Subclass own");
    }
    void add() {
		System.out.println("Subclass add");
	}
    public static void strLen() {
		System.out.println("Subclass strLen");
	} 
}

class Super{
	public void method(int ii) {
        System.out.println("Super");
    }
	public String eat(int ii) {
        System.out.println("Super eat");
        return null;
    }
	public int free(int ii) {
        System.out.println("Super free");
        return 2;
    }
	private void own(int ii) {
        System.out.println("Super own");
    }
	public void add() {
		System.out.println("Super add");
	}
	public static void strLen() {
		System.out.println("Super strLen");
	}
}

问题4：如果一个类中声明了n个构造器，则最多有几个构造器中使用了 “this(形参列表)”

问题5：以下代码，打印结果是什么？

public class BasicTest{
	String str = "hello";
	Integer i = 1000;
	public static void main(String[] args) {
		Sub1 s = new Sub1();
		s.add(1, 2, 3);
		System.out.println(s.count);
		Base1 b = s;
		b.add(1,2,3);
		System.out.println(b.count);
		BasicTest bt = new BasicTest();
		System.out.println(bt.str == s.str);
		System.out.println(bt.i == s.i);
	}
}

class Base1 {
	int count = 10;
	
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
}

class Sub1 extends Base1 {
	int count = 20;
	String str = "hello";
	Integer i = 1000;
	
	public void add(int a, int[] arr) {
		System.out.println("sub_1");
	}
	public void add(int a, int b, int c) {
		System.out.println("sub_2");
	}
}

问题6：简单题

抽象类和接口是否可以实例化？

抽象类和接口是否有构造器？

abstract关键字可以修改变量、代码块、构造器吗？

JDk8开始，接口中可以定义哪些成员？（除了抽象方法和常量值）

答案

问题1：以下代码，是否相互构成重载？

public class BasicTest {
	public void test(String[] msg){
		System.out.println("含字符串数组参数的test方法");
	}
	public void test(String book){
		System.out.println("单个字符串参数的test方法");
	}
	public void test(String... books){
		System.out.println("形参长度可变的test方法");
	}
}
//可变形参
//JDK5.0以前：采用数组形参来定义方法，传入多个同一类型变量
//JDK5.0以后：采用可变个数形参来定义方法，传入多个同一类型变量
//所以这里代码提示编译错误，jdk认为方法1和方法3是同一方法。

问题2：以下代码，结果是什么？

public class BasicTest {

	public static void main(String[] args) {
		BasicTest to = new BasicTest();
	    to.test();
	    to.test("aa");
	    to.test("aa" , "bb");
	    to.test(new String[]{"aa"});
		
	}	
	public void test(String book){	//优先级高
		System.out.println("单个字符串参数的test方法");
	}
	public void test(String... books){
		System.out.println("形参长度可变的test方法");
	}
}
打印结果：
形参长度可变的test方法
单个字符串参数的test方法
形参长度可变的test方法
形参长度可变的test方法

public class BasicTest {
	public static void main(String[] args) {
		BasicTest to = new BasicTest();
	    //下面两次调用将执行第三个test方法
	    to.test();
	    to.test("aa");
	    to.test("aa" , "bb");
	    //下面将执行第一个test方法
	    to.test(new String[]{"aa"});
	}
	
	public void test(String[] msg){
		System.out.println("含字符串数组参数的test方法");
	}
	public void test(String book){	//优先级高
		System.out.println("单个字符串参数的test方法");
	}
}
编译错误，不存在test()方法以及test("aa" , "bb")

public class TransferTest {
    public static void main(String args[]) {
        TransferTest test = new TransferTest();
        test.first();
    }
    public void first() {
        int i = 5;
        Value v = new Value();
        v.i = 25;
        second(v, i);
        System.out.println(v.i);
    }
    public void second(Value v, int i) {
        i = 0;
        v.i = 20;
        Value val = new Value();
        v = val;
        System.out.println(v.i + " " + i);
    }
}

class Value {
	int i = 15;
}

打印结果如下，另见堆栈内存分析图
15 0
20

堆栈内存分析图

问题3：以下的所有方法是否构成重写？

public class BasicTest extends Super{
	
    public String method(int i) {//编译错误，父类被重写的方法的返回值类型是void，则子类重写的方法返回值类型只能是void
    	System.out.println("Subclass");
    	return null;
    }
    public Object eat(int ii) {//编译错误，父类被重写的方法的返回值类型是A类型，则子类重写的方法返回值类型可以是A类或A类的子类
        System.out.println("Subclass eat");
        return null;
    }
    public short free(int ii) {//编译错误，父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法返回值类型必须是相同的基本数据类型
        System.out.println("Subclass free");
        return 2;
    }
    private void own(int ii) {//不是重写，子类不能重写父类中声明为private权限的方法
        System.out.println("Subclass own");
    }
    void add() {//编译错误，子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
		System.out.println("Subclass add");
	}
    public static void strLen() {//不是重写，static方法是属于类的，子类无法覆盖父类的方法
		System.out.println("Subclass strLen");
	}  
}

class Super{
	public void method(int ii) {
        System.out.println("Super");
    }
	public String eat(int ii) {
        System.out.println("Super eat");
        return null;
    }
	public int free(int ii) {
        System.out.println("Super free");
        return 2;
    }
	private void own(int ii) {
        System.out.println("Super own");
    }
	public void add() {
		System.out.println("Super add");
	}
	public static void strLen() {
		System.out.println("Super strLen");
	}
}

问题4：如果一个类中声明了n个构造器，则最多有几个构造器中使用了 "this(形参列表)"

最多有 n - 1个构造器中使用了 "this(形参列表)，因为至少有一个使用了super(形参列表)
问题5：以下代码，打印结果是什么？

public class BasicTest{
	String str = "hello";
	Integer i1 = 10;
	Integer i2 = 1000;
	public static void main(String[] args) {
		Sub1 s = new Sub1();
		s.add(1, 2, 3);
		System.out.println(s.count);
		Base1 b = s;
		b.add(1,2,3);
		System.out.println(b.count);//对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边）
		BasicTest bt = new BasicTest();
		System.out.println(bt.str == s.str);//string常量保存在方法区内，两个变量的值指向同一空间
		System.out.println(bt.i1 == s.i1);
		System.out.println(bt.i2 == s.i2);//Integer内部定义了IntegerCache结构，IntegerCache中定义了Integer[]，保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在-128~127范围内时，可以直接使用数组中的元素，不用再去new了。
	}
}

class Base1 {
	int count = 10;
	public void add(int a, int... arr) {
		System.out.println("base1");
	}
}

class Sub1 extends Base1 {
	int count = 20;
	String str = "hello";
	Integer i1 = 10;
	Integer i2 = 1000;

	public void add(int a, int[] arr) {//与父类构成重写
		System.out.println("sub_1");
	}
	public void add(int a, int b, int c) {//优先级高于可变形参
		System.out.println("sub_2");
	}
}
结果：
sub_2
20
sub_1
10
true
true
false

问题6：简单题
- 抽象类和接口是否可以实例化？
  
  都不可以
- 抽象类和接口是否有构造器？
  
  接口没有，但抽象类有构造器。虽然抽象类自己不能实例化，但继承的子类需要调用（涉及：子类对象实例化的全过程）
- abstract关键字可以修改变量、代码块、构造器吗？
  
  不可以
- JDk8开始，接口中可以定义哪些成员？（除了抽象方法和常量值）
  
  还有静态方法和默认方法。静态方法只能通过接口直接调用静态方法。默认方法可以通过实现类对象来调用。

nt a, int b, int c) {//优先级高于可变形参
System.out.println(“sub_2”);
}
}
结果：
sub_2
20
sub_1
10
true
true
false


* **问题6：简单题**

  * **抽象类和接口是否可以实例化？**

    都不可以

  * **抽象类和接口是否有构造器？**

    接口没有，但抽象类有构造器。虽然抽象类自己不能实例化，但继承的子类需要调用（涉及：子类对象实例化的全过程）

  * **abstract关键字可以修改变量、代码块、构造器吗？**

    不可以

  * **JDk8开始，接口中可以定义哪些成员？（除了抽象方法和常量值）**

    还有**静态方法**和**默认方法**。**静态方法只能通过接口直接调用静态方法。默认方法可以通过实现类对象来调用。**

笔上烽烟

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java基础知识总结-2

这里基于Java的基础知识列举一些题目，这些题目比较考验基本功是否扎实。同样这些有可能作为职场面试题出现，所有大家可以好好看看。文章目录面向对象问题1：以下代码，是否相互构成重载？问题2：以下代码，结果是什么？问题3：以下的所有方法是否构成重写？问题4：如果一个类中声明了n个构造器，则最多有几个构造器中使用了 "this(形参列表)"问题5：以下代码，打印结果是什么？问题6：简单题抽象类和接口是否可以实例化？抽象类和接口是否有构造器？abstract关键字可以修改变量、代码块、构造器吗？JDk8开始，.
复制链接

扫一扫