本文共 10888 字，大约阅读时间需要 36 分钟。

一、阅读代码题：

1

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

2.

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

3.

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

0 null

4.

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

Vehicle is created

instance initializer block invoked

128

Vehicle is created

instance initializer block invoked

256

5.

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

答案： 0 1 2 3 4

6.

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不要允许用户直接对内存进行操作的的)

7.

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
   
     list=Arrays.asList(s);//将数组转成list		list.add("d");		System.out.println(list.size());	}}
   

答案:运行时异常 

8.

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

答案：2

9.

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
   
     plist = new ArrayList
    
     ();         //创建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
     
      (){            /*             * 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类型的变量 

在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();}

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

/* 比如将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;	}}

转载地址：https://codingchaozhang.blog.csdn.net/article/details/79685023 如侵犯您的版权，请留言回复原文章的地址，我们会给您删除此文章，给您带来不便请您谅解！