【Java面试题十】一套完整的java面试题

最新推荐文章于 2025-04-11 14:13:42 发布

mind_programmonkey

最新推荐文章于 2025-04-11 14:13:42 发布

阅读量871

点赞数 1

文章标签： java 面试题

本文链接：https://blog.csdn.net/Mind_programmonkey/article/details/79685023

版权

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

16 篇文章

订阅专栏

Java面试题

14 篇文章

订阅专栏

一、阅读代码题：

public static void main(String[] args) {
		int i=128;//(int)占4个字节 00000000  00000000  00000000 1000 0000  128
		short s=28;//(short)占2个字节 000000000 0001 1000  28
		byte b=(byte)i;//(byte)占1个字节1000 0000  -128  java规定-0（10000000）为-128。
		int x=b+s;//-100 
		System.out.println(x);
	}

答案：-100

public static void main(String[] args) {
		int i=128;
		List list=new ArrayList<>();
		list.add(new Object());//java.lang.Object@4e25154f
		list.add("hi");//hi
		list.add(i);//128
		System.out.println(list.get(1));
	}

答案：hi

public class Test5 {
	int id;
	String name;
	void display() {
		System.out.println(id+" "+name);
	}
	public static void main(String[] args) {
		Test5 t1=new Test5();
		Test5 t2=new Test5();
		t1.display();
		t2.display();
	}
}

答案：

0 null

class Vehicle{
	 Vehicle() { //父类构造方法
		System.out.println("Vehicle is created");
	}
}
class Test5 extends Vehicle{
	Test5() {//子类构造方法
		System.out.println("constructor is invoked");
	}
	int speed;
	Test5(int speed){//子类有参构造方法
		this.speed=speed;
		System.out.println(speed);
	}
	//普通的初始化块
	{
		System.out.println("instance initializer block invoked");
	}
	public static void main(String[] args) {
		Vehicle b1=new Vehicle();//    Vehicle is created
		Test5 b=new Test5(128);//Vehicle is created    instance initializer block invoked 128
		Test5 b2=new Test5(256);//Vehicle is created    instance initializer block invoked 256
	}
}

答案：

Vehicle is created

instance initializer block invoked

128

Vehicle is created

instance initializer block invoked

256

public  class Test6{
	public static void main(String[] args) {
		new Test6().doSomething();
	}
	public void doSomething() {
		int i=5;
		Thread t=new Thread(new Runnable() {
			public void run() {
				for(int j=0;j<i;j++) {
					System.out.print(" " +j);
				}
			}
		});
		t.start();
	}
}

答案： 0 1 2 3 4

public  class Test6{
	public static void main(String[] args) {
		Integer i=127,j=127;
		Integer a=128,b=128;
		Integer m=new Integer(127);
		Integer n=new Integer(127);
		System.out.println(i==j);
		System.out.println(a==b);
		System.out.println(m==n);
	}

/*常量池在java中用于保存编译期已经确定的，它包括了关于类，方法，接口中的常量，也包括字符串常量。例如

String s = "Java" 这种声明的方式。产生的这种"常量"就会被放到常量池，常量池是JVM的一块特殊的内存空间。

使用Java常量池技术，是为了方便快捷地创建某些对象，当你需要一个对象时候，就去这个池子里面找，找不到就在池子里面创建一个。

但是必须注意如果对象是用new 创建的。那么不管是什么对像，它是不会放到池子里的，而是向堆申请新的空间存储。

java中基本类型的包装类的大部分都实现了常量池技术，这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。

另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池。超过了就要申请空间创建对象了

”==“ 我们知道比较的是引用的地址(其实java不要允许用户直接对内存进行操作的的)

public  class Test6{
	public static void main(String[] args) {
		/*
		 * objList.remove(0);//asList()返回的是arrays中私有的终极ArrayList类型，它有set,get，contains方法，但没有增加和删除元素的方法，所以大小固定,会报错  
		   objList.add(0);//由于asList返回的list的实现类中无add方法，所以会报错 
		 */
		String[] s= {"a","b","c"};
		List<String> list=Arrays.asList(s);//将数组转成list
		list.add("d");
		System.out.println(list.size());
	}
}

答案:运行时异常

public static void main(String[] args) {
		BigDecimal a=new BigDecimal(2);
		BigDecimal b=new BigDecimal("3");
		a.multiply(b);//乘
		System.out.println(a);
	}

答案：2

class Bike{
	final void run() {
		System.out.println("running");
	}
}
public  class Test6 extends Bike{
	void run() {
		System.out.println("running safely with 100kmh");
	}
	public static void main(String[] args) {
		Test6 honda=new Test6();
		honda.run();
	}
}

答案：编译错误，final修饰的方法不能被继承，重写

10.

class Bike2{
	int speedlimit=90;
	public void display(){
        System.out.println(this.speedlimit);
    }
     
}

class Test11 extends Bike2{
	int speedlimit=150;
	public void display(){
        System.out.println(this.speedlimit);
    }
	public static void main(String[] args) {
		Bike2 obj=new Test11();
		System.out.println(obj.speedlimit);
		obj.display();
	}
}

答案：90

150

11.

public static void main(String[] args) {
		int n;
		for(n=1;n<5;++n) {
			break;
		}
		System.out.println(n);
	}

答案：1

12.

public static void main(String[] args) {
		int n;
		for(n=1;n<5;++n) {
			continue;
		}
		System.out.println(n);
	}

答案：5

13.

public class Test11 implements Runnable {
	public void run() {
		System.out.println("running");
	}
	public static void main(String[] args) {
		Test11 c=new Test11();
		Thread t=new Thread(c);
		t.start();
	}
}

答案：注意是implements而不是extends

14.

class A{
	void msg1() {
		System.out.println("Hello");
	}
}
class B{
	void msg() {
		System.out.println("Welcome");
	}
}
public class Test15 extends A,B{
	Test15 c=new Test15();
	c.msg();
}

答案：编译错误不能继承两个父类

15.有个List<People>集合，如何实现按age进行排序输出

(1)class Person {
    private String id;
    private String name;
    private int age;
     
    public Person(String id, String name, int age) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

public class PersonSort {
    public static void main(String[] args) {
        List<Person> plist = new ArrayList<Person>(); 
        //创建3个Person对象，年龄分别是32、20、25，并将他们依次放入List中 
        Person p1 = new Person("0001","zhangsan",32);
        Person p2 = new Person("0002","lisi",20);
        Person p3 = new Person("0003","wangwu",25);
        plist.add(p1);
        plist.add(p2);
        plist.add(p3);
        System.out.println("排序前的结果："+plist);
        Collections.sort(plist, new Comparator<Person>(){
            /*
             * int compare(Person p1, Person p2) 返回一个基本类型的整型，
             * 返回负数表示：p1 小于p2，
             * 返回0 表示：p1和p2相等，
             * 返回正数表示：p1大于p2
             */
            public int compare(Person p1, Person p2) {
                //按照Person的年龄进行升序排列
                if(p1.getAge() > p2.getAge()){
                    return 1;
                }
                if(p1.getAge() == p2.getAge()){
                    return 0;
                }
                return -1;
            }
        });
        System.out.println("排序后的结果："+plist); 
    }
}

(2)

/**
 * 通过jdk1.5提供的枚举类
 * @author LvChaoZhang
 *
 */
public enum Direction {
	FRONT,BEHIND,LEFT,RIGHT;
}

16.有个List<People>集合，得到其中年龄大于28的姓名和年龄的map对象

17.如何实现同步控制

（1）同步方法：即有synchronized关键字修饰的方法

由于java的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法时，需要获得内置锁，否则就处于阻塞状态。

代码如：public synchronized void save{}

注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类

（2）同步代码块：即有synchronized关键字修饰的语句块

被该关键字修饰的语句块会自动被加上内置锁，从而实现同步。

代码如：synchronized(object){}

注：同步是一种高开销的操作，因此应该尽量减少同步的内容。

通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

（3）使用特殊域变量（volatile）实现线程同步

a.volatile关键字为域变量的访问提供了一种免锁机制，

b.使用volatile修饰域相当于告诉虚拟机该域可能会被其他线程更新，

c.因此每次使用该域就要重新计算，而不是使用寄存器中的值

d.volatile不会提供任何原子操作，它也不能用来修饰final类型的变量
（4）使用重入锁实现线程同步

在JavaSE5.0中新增了一个java.util.concurrent包来支持同步。ReentrantLock类是可重入、互斥、实现了Lock接口的锁，它与使用synchronized方法和快具有相同的基本行为和语义，并且扩展了其能力。

18.创建一个枚举类

（1）public abstract class DirectionDemo2 {
	public static final DirectionDemo2 FONT=new DirectionDemo2("前") {
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("前");
		}
		
	};
	public static final DirectionDemo2 BEHIND=new DirectionDemo2("后") {


		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("后");
		}
		
	};
	public static final DirectionDemo2 LEFT=new DirectionDemo2("左") {


		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("左");
		}
		
	};
	public static final DirectionDemo2 RIGHT=new DirectionDemo2("右") {


		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("右");
		}
		
	};
	
	private String name;
	private DirectionDemo2(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	public abstract void show();
}

（2）

package practice;
/**
 * 通过jdk1.5提供的枚举类
 * @author LvChaoZhang
 *
 */
public enum Direction {
	FRONT("前"){

		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("前");
		}
		
	},
	BEHIND("后") {
		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("后");
		}
	},
	LEFT("左") {
		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("左");
		}
	},
	RIGHT("右") {
		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("右");
		}
	};
	private String name;
	private Direction(String name) {
		this.name=name;
	}
	public String getName() {
		return name;
	}
	
	public abstract void show();
}

19.创建一个自定义注解类Test，包含一个value注解项

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)//注解的作用范围，就是注解是用在什么地方的
@Retention(RetentionPolicy.RUNTIME)//注解的级别，就是注解能留存到什么时候
@Documented//用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。
@Inherited//@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。 
			//注意：接口和方法上的注解不能被继承
public @interface Weekday {
    public String value();//注解可以接收的参数
}

20.mysql修改table1的A字段varchar型变成int型

解：修改字段用alter命令，如果该列中存在超过INT最大范围值（-32767到+32768）或非法INT数据，则需要事先将数据处理，否则提示相关错误。

alter table table1 alter column A int

21.mysql中int型的数字怎么转换成字符串

/* 比如将123转换为char类型 */
SELECT CAST(123 AS CHAR); 
/* 或者使用concat方法 */
SELECT CONCAT(123,'');
alter table table1 alter column A int

22.mysql删除table1的记录

（1）delete from 表名 where 条件;，这个语句带条件的删除数据，可以删除指定的数据记录。
（2）truncate table 表名;，这个语句可以快速删除表中的所有数据，是不带条件的删除。

23.简述常用的设计模式及应用场景，并编码写出一个单例模式

按照目的来分，设计模式可以分为创建型模式、结构型模式和行为型模式。
创建型模式用来处理对象的创建过程；结构型模式用来处理类或者对象的组合；行为型模式用来对类或对象怎样交互和怎样分配职责进行描述。
创建型模式用来处理对象的创建过程，主要包含以下5种设计模式：
 工厂方法模式（Factory Method Pattern）
 抽象工厂模式（Abstract Factory Pattern）
 建造者模式（Builder Pattern）
 原型模式（Prototype Pattern）
 单例模式（Singleton Pattern）
结构型模式用来处理类或者对象的组合，主要包含以下7种设计模式：
 适配器模式（Adapter Pattern）
 桥接模式（Bridge Pattern）
 组合模式（Composite Pattern）
 装饰者模式（Decorator Pattern）
 外观模式（Facade Pattern）
 享元模式（Flyweight Pattern）
 代理模式（Proxy Pattern）
行为型模式用来对类或对象怎样交互和怎样分配职责进行描述，主要包含以下11种设计模式：
 责任链模式（Chain of Responsibility Pattern）
 命令模式（Command Pattern）
 解释器模式（Interpreter Pattern）
 迭代器模式（Iterator Pattern）
 中介者模式（Mediator Pattern）
 备忘录模式（Memento Pattern）
 观察者模式（Observer Pattern）
 状态模式（State Pattern）
 策略模式（Strategy Pattern）
 模板方法模式（Template Method Pattern）
 访问者模式（Visitor Pattern）

单例模式实现1：
public class Singleton {
	// 类共享实例对象
	private static Singleton singleton = null;
	// 私有构造方法
	private Singleton() {
		System.out.println("-- this is Singleton!!!");
	}
	// 获得单例方法
	public synchronized static Singleton getInstance() {
		// 判断 共享对象是否为null ，如何为null则new一个新对象
		if (singleton == null) {
			singleton = new Singleton();
		}
		return singleton;
	}
}
单例模式实现2：
public class Singleton {
	// 类共享实例对象 实例化
	private static Singleton singleton = new Singleton();
	// 私有构造方法
	private Singleton() {
		System.out.println("-- this is Singleton!!!");
	}
	// 获得单例方法
	public static Singleton getInstance() {
		// 直接返回共享对象
		return singleton;
	}
}