常见的java编程题

① 几道java题目，求好心人给下答案，感激不尽

1、public static void main(String[] args)

2、public finall static

3、3

4、抽象类

5、implements

6、类：一个包含属性、方法，使用class关键字定义

对象：创建对象必须使用new关键字，对象其实在内存中存储的是类的引用地址。

7、try是可能发生异常的内容；

catch是发生异常后要处理的代码；

finally是始终执行的，比如关闭资源等。

8、

publicclassDemo{
	//小明今年12岁，他母亲比他大20岁。编程计算多少年后他母亲的年龄是小明的2倍。
	publicstaticvoidmain(String[]args){
		System.out.println(getYeah());
	}
	publicstaticintgetYeah(){
		intxmAge=12,mqAge=20,yeah=0;
		while(true){
			if(mqAge/2==xmAge){
				returnyeah;
			}
			mqAge++;
			yeah++;
		}
	}
}

9、

publicclassDemo{
	
	publicstaticvoidmain(String[]args){
		newThread(newPiao()).start();
		newThread(newPiao()).start();
		newThread(newPiao()).start();
		newThread(newPiao()).start();
	}
}
classPiaoimplementsRunnable{
	privatestaticintpiao=1;
	publicvoidrun(){
		while(true){
			synchronized(Piao.class){
				if(piao>100){
					System.exit(0);
				}
				System.out.println(Thread.currentThread().getName()+"出票："+piao+"号");
				piao++;
			}
		}
	}
}

② JAVA编程的几个简单题目

第一个：
import java.util.Scanner;
import java.util.*;
public class Validate
{
private int n;
/*count_6、count_7、count_8 用来记录收敛那个数字的个数，在这里我记录只要他出现了10次我就认为他收敛与他了
* 还没想到更好的办法，如果不设置这个，就会出现栈溢出，递归不出来了！不过可以看到结果输出结果确实是对的
*/
private int count_6;
private int count_7;
private int count_8;
private Stack<Integer> stack= new Stack<Integer>();//栈用来存放素因子
public void scan()
{
Scanner scan = new Scanner(System.in);
try{
n = scan.nextInt();
}catch(NumberFormatException ne){
System.out.println(ne.getMessage());
}
}

public boolean isPrime(int n)
{
if(n>2 && 0 == n%2)//是大于2偶数
{
return false;

}else{

for(int i=3; i<n; i +=2)
{
if(0 == n%i)
return false;
}
return true;
}
}

public void analyze(int n)
{
if(isPrime(n))
{
stack.push(n);
return;
}
if(0 == n%2){
stack.push(2);
n = n/2;
analyze(n);
}else{

for(int i=3; i<n; i +=2)
{
if(isPrime(i)&& 0 == n%i)
{
stack.push(i);
n = n/i;
analyze(n);
}
}

}
}

public void mySort()
{
check(n);
}
public void check(int m)
{
if(isPrime(m)){
m++;
}
else{
analyze(m);
m = 0;
while(!stack.empty())
{
int k = stack.pop().intValue();
m += k;
}
stack.clear();
m++;
}
if(m == 6 || m == 7 || m == 8)
{
if(6 == m)
{
count_6++;
System.out.println("m = " + m);
}else if(7 == m){
count_7++;
System.out.println("m = " + m);
}else if(8 == m){
count_8++;
System.out.println("m = " + m);
}
}
if(count_6 > 10 || count_7 > 10 || count_8 > 10)
{
return;
}
check(m);
}

public static void main(String[] args)
{
Validate v = new Validate();
v.scan();
v.mySort();
}
}

第二个：
import java.util.Scanner;

class MyException extends Exception
{
public MyException(String msg)
{
super(msg);
}
}

public class MyExceptionTest {

public int scan()
{
int a = 0;
Scanner scan = new Scanner(System.in);
try{
a = scan.nextInt();
}catch(NumberFormatException ne){
System.out.println(ne.getMessage());
}
return a;
}

public int cal(int a, int b) throws MyException
{
if(b==0) throw new MyException("自定义异常： 输入的第二个数为0");
else if(a/b<1) throw new MyException("自定义异常： 相除的结果小于1");
else return a/b;

}
public static void main(String[] args) {

MyExceptionTest me = new MyExceptionTest();
System.out.print("请输入第一个数:");
int a = me.scan();
System.out.print("请输入第二个数:");
int b = me.scan();
try{
System.out.println("相除的结果:" + me.cal(a, b));
}catch(MyException e){
System.out.println(e.getMessage());
}
}

}

第三个：
import java.util.*;
import java.util.Map.Entry;

public class CountCharacter {

private static Map<String, Integer> map = new LinkedHashMap<String, Integer>();

private static final int ONE = 1 ; //没有出现过,则设置其出现一次;

private String content = null;

public void scan()
{
Scanner scan = new Scanner(System.in);
content = scan.nextLine();
}

public void count()
{
String [] text = content.split(" ");
for(int i=0; i<text.length; i++)
{
if (!map.containsKey(text[i])) {
map.put(text[i], ONE);
} else {
int value = map.get(text[i]);
map.put(text[i], value + 1);
}
}
}
public <K, V extends Number> Map<String, V> sortMap(Map<String, V> map) {
class MyMap<M, N> {
private M key;
private N value;
private M getKey() {
return key;
}
private void setKey(M key) {
this.key = key;
}
private N getValue() {
return value;
}
private void setValue(N value) {
this.value = value;
}
}

List<MyMap<String, V>> list = new ArrayList<MyMap<String, V>>();
for (Iterator<String> i = map.keySet().iterator(); i.hasNext(); ) {
MyMap<String, V> my = new MyMap<String, V>();
String key = i.next();
my.setKey(key);
my.setValue(map.get(key));
list.add(my);
}

Collections.sort(list, new Comparator<MyMap<String, V>>() {
public int compare(MyMap<String, V> o1, MyMap<String, V> o2) {
if(o1.getValue().equals(o2.getValue())) {
return o1.getKey().compareTo(o2.getKey());
}else{
return (int)(o2.getValue().doubleValue() - o1.getValue().doubleValue());
}
}
});

Map<String, V> sortMap = new LinkedHashMap<String, V>();
for(int i = 0, k = list.size(); i < k; i++) {
MyMap<String, V> my = list.get(i);
sortMap.put(my.getKey(), my.getValue());
}
return sortMap;
}

public static void main(String[] args) {
CountCharacter cc = new CountCharacter();
cc.scan();
cc.count();
Map<String, Integer> sortMap = cc.sortMap(cc.map);

Iterator<Entry<String, Integer>> it = sortMap.entrySet().iterator();
Map.Entry<String,Integer> entry = null;
int i=0;
while(it.hasNext()&& i<10) {//去前面10个
i++;
entry = (Entry<String,Integer>) it.next();
System.out.println(entry.getKey() + " --> " + entry.getValue());
}
}

}

第四个：
import java.util.Scanner;
public class IntegerShape{
public static void main(String[] args){
double a = 0;
int b = 0;
Scanner in = null;
do{
try{
System.out.print("请输入一个的数：");
in=new Scanner(System.in);
a=in.nextFloat();
break;
}catch(Exception ne){
System.out.println("输入数据错误!");
}
}while(true);
do{
try{
System.out.print("请输入显示的行数:");
in=new Scanner(System.in);
b=in.nextInt();
break;
}catch(Exception ne){
System.out.println("输入数据错误!");
}
}while(true);
for(int i=b;i>0;i--)
{
System.out.println(a);
a=a/2;
}
}
}
第五个：
import java.util.Scanner;
import java.util.Vector;

public class MyVector {

private Vector<String> vectorStr = new Vector<String>(); //用来方单词
private Vector<Integer> vectorInt = new Vector<Integer>();//用来记录对应下标的单词的个数
private static final int ONE = 1 ; //没有出现过,则设置其出现一次;

private String content = null;

public void scan()
{
Scanner scan = new Scanner(System.in);
content = scan.nextLine();
}

public void countWord()
{
int index = -1;
String [] text = content.split(" ");
for(int i=0; i<text.length; i++)
{
if(vectorStr.contains(text[i])){ //若次单词已经存在与vector中则只要修改对应的个数
index = vectorStr.indexOf(text[i]);
int value = vectorInt.get(index)+1;
vectorInt.setElementAt(value, index);
}
else{//若不存在则添加该单词，同时要初始化对应下标的单词的个数
vectorStr.add(text[i]);
vectorInt.add(ONE);
}
}
System.out.println(vectorStr);
}

public void display()
{
for(int i=0; i<vectorStr.size(); i++)
{
System.out.println(vectorStr.get(i) + "->" + vectorInt.get(i));
}
}
public static void main(String[] args) {

MyVector mv = new MyVector();
mv.scan();
mv.countWord();
mv.display();
}
}

最后一个了不容易！考虑加点分吧！

import java.util.*;
public class Exp {

private int integer;
private boolean bool = false;
private Stack<Integer> stack = new Stack<Integer>();

public void scan()
{
System.out.print("输入一个整数：");
Scanner scan = new Scanner(System.in);
while(true){
try{
integer = scan.nextInt();
break;
}catch(Exception e){
System.out.println("输入错误!");
}
}
}

public void operation()
{

for(int i=1; i<integer; i++)
{
int sum = 0;
for(int j = i; j<=integer; j++)
{
stack.push(j);
sum += j;
if(sum == integer)
{
int k = 0, n = stack.size();
bool = true;
System.out.print(integer + " = ");
while(!stack.empty())
{
k++;
if(k<n)
{
System.out.print(stack.pop().intValue() + " + ");
}
else
{
System.out.print(stack.pop().intValue() + "\n");
}
}
stack.clear();
}else if(sum > integer){
stack.clear();
}
}
}
if(!bool)
System.out.println("该整数没有连续正整数序列！");
}
public static void main(String[] args) {
Exp e = new Exp();
e.scan();
e.operation();
}

}

以上运行过了可以！

③ 3道java编程题，求解

packageTestPerson;
/**
*(1)编写程序实现如下功能：已知Person类包含三个公共成员变量（姓名、性别、年龄）和一个构造方法，
*Student类是Person类的派生类，包含两个新的公共成员变量(学号、班号)、两个公共方法（修改年龄、显示基本信息）及一个构造方法。
*在测试类Test1中，定义一组学生对象，并初始化他们的基本信息，然后依次输出。
*/
publicclassTest1{
	publicstaticvoidmain(String[]args){
		Student[]student=newStudent[3];
		student[0]=newStudent("小李","男",12,20181101,01);
		student[1]=newStudent("小南","女",13,20001102,01);
		student[2]=newStudent("小李","男",12,20181103,01);
		
		for(Studentstu:student){
			stu.showInformation();
		}
	}
}

classPerson{
	publicStringname;
	publicStringsex;
	publicintage;
	publicPerson(Stringname,Stringsex,intage){
		super();
		this.name=name;
		this.sex=sex;
		this.age=age;
	}
}

classStudentextendsPerson{
	publiclongstudentId;
	publiclongclassId;
	publicvoidsetAge(intage){
		age=this.age;
	}
	publicvoidshowInformation(){
		System.out.println("我的姓名是"+name+","+"我的性别是"+sex+","+"我的年龄是"+age
				+"岁,"+"我的学号是"+studentId+","+"我的班号是"+classId+"班");
	}
	publicStudent(Stringname,Stringsex,intage,longstudentId,
			longclassId){
		super(name,sex,age);
		this.studentId=studentId;
		this.classId=classId;
	}
}

不可否认，我现在是有点闲，所以我就帮你写第一个吧，至于后面两个，我就不写了，看看还有没有其他人有点闲时间，看缘分吧

运行结果：

我的姓名是小李,我的性别是男,我的年龄是12岁,我的学号是20181101,我的班号是1班

我的姓名是小南,我的性别是女,我的年龄是13岁,我的学号是20001102,我的班号是1班

我的姓名是小李,我的性别是男,我的年龄是12岁,我的学号是20181103,我的班号是1班

④ Java编程题

先把题目列成公式就是2*a+3*b+4*c+5*d=20

这就是一个四元一次方程
简单点就四次循环就可以得到答案
public static void main(String[] args) {

int min=0;//不可能买负数
for (int a =min; a <=20/2; a++) {
for (int b =min; b <20/3; b++) {
for (int c = min; c <20/4; c++) {
for (int d = min; d <20/5; d++) {
if(2*a+3*b+4*c+5*d==20){
System.out.println("菊花"+a);
System.out.println("康乃馨"+b);
System.out.println("玫瑰"+c);
System.out.println("百合"+d);
}
}

}
}
}

}

⑤ 8道简单的Java编程题

第一题
private static void tuzinum(){
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
//总数
int allnum = 1;
//成年数
int chengniannum = 0;
//出生数
int chushengnum = 0;
for(int i=0;i<12;i++){
for(int j=0;j<list.size();j++){
Integer age = list.get(j);
age++;
list.set(j, age);
if(age>3){
chengniannum++;
chushengnum++;
allnum++;
list.add(1);
}
}
System.out.println("第"+i+"个月兔子对数为："+list.size());
}
}

第二题
private static void fenjie(){
int num = 90;

boolean canchu = true;
while(canchu){
int time = 0;
for(int i=2;i<num/2;i++){
if(num%i==0){
num = num/i;
System.out.println(i);

time++;
}
}
if(time == 0 ){
canchu = false;
System.out.println(num);
}
}
}

⑥ java编程十道题

1.
public class TestRandomArray
{
public static void main(String[] args)
{
int maxline = (int) (Math.random()*100);
int[] array = new int[maxline];
for(int i=0;i<maxline;i++)
{
int temp = (int) (Math.random()*100);
if(temp>=10&&temp<=99)
{
array[i] = temp;
}
else
i--;
}
for(int j=0;j<maxline;j++)
{
int max = array[0];

if(array[j]>max)
{
max=array[j];
array[j] = array[0];
array[0] = max;

}
}
for(int k=0;k<maxline;k++)
{
System.out.print(array[k]+" ");
}
}
}

2.
public class TestNumber100
{
public static void main(String[] args)
{
for(int i=1;i<100;i++)
{
if(i%3==0&&(i%5!=0)&&(i%9!=0))
System.out.println(i+" ");
else
continue;
}
}
}

3.貌似没结果
public class Test3
{
public static void main(String[] args)
{
/*for(int i=0;i<=9;i++)
{
for(int j=0;j<=9;j++)
{
int code = 10000+i*1000+j*100+23;
if((code%57)==0&&(code%67)==0&&i!=j)
{
System.out.println("x="+i+","+"y="+j);
}
else
System.out.println(i+" "+j);
}
}*/

for(int i=10023;i<=19923;i++)
if(i==0&&i==0)
System.out.println(i+" ");
}
}

4.
class Caculate {
int money;
Caculate(){
money = 10;
}
public int charge (int distance){
if (distance < 3){
money = 10;
}
if ((distance >= 3) && distance < 15)
{
money = money + 2*(distance-3);
}
if (distance > 15 )
{
money = money + 2*12 + 3*(distance - 15);
}

return money;
}
public static void main(String args[]) {

System.out.println("请输入公里数");
int distance_example=0;
Scanner key = new Scanner(System.in);
int n = key.nextInt();
distance_example = n;
Caculate pay = new Caculate();
pay.money = pay.charge(distance_example);
System.out.println("You need to pay money:"+pay.money+" distance is:"+distance_example);

}
}

5.
public class Test4
{

public static void main (String args[])
{
int n=100;
while(n<=1000)
{
int i,j,k;
i=n/100;
j=(n-i*100)/10;
k=n%10;
if((Math.pow(i, 3)+Math.pow(j, 3)+Math.pow(k, 3))==n)

System.out.print(n+String.valueOf('\t'));
n++;
}
}
}

6.
public class TestMoney
{
public static void main(String[] args)
{
int one=1,two=2,five=5;
for(int i=1;i<100;i++)
for(int j=1;j<50;j++)
for(int k=1;k<20;k++)
{
if((i*one+j*two+k*five)==100)
System.out.println(i+"个一分,"+j+"个两分,"+k+"个五分");
}

}

}

7.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestJieCheng
{
public static void main (String args[])
{
int a=0,b=1;float sum=0;
System.out.print("请输入要计算的阶乘：");
try
{
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
a=Integer.parseInt(in.readLine());
}catch(IOException e){}
for(int i=1;i<=a;i++)
{
b=b*i;

}
System.out.print(a+"的阶乘是"+b);
}
}

8.
public class Test4
{

public static void main (String args[])
{
int n=100;
while(n<=1000)
{
int i,j,k;
i=n/100;
j=(n-i*100)/10;
k=n%10;
if((Math.pow(i, 3)+Math.pow(j, 3)+Math.pow(k, 3))==n)

System.out.print(n+String.valueOf('\t'));
n++;
}
}
}

9.
public class TestNumber2
{
public static void main(String[] args)
{
final int maxline = 20;
double sum = 0;
double [] denominator = new double [maxline];
double [] numerator = new double [maxline];
for(int i=2;i<denominator.length;i++)
{
denominator[0]=1;
denominator[1]=2;
denominator[i]=denominator[i-1]+denominator[i-2];
}
for(int j=2;j<numerator.length;j++)
{
numerator[0]=2;
numerator[1]=3;
numerator[j]=numerator[j-1]+numerator[j-2];
}
for(int k=0;k<maxline;k++)
{
sum+=(numerator[k])/denominator[k];

}
System.out.println(sum);
}

}

10.
import java.io.*;

public class 根据输入的三个数求一元二次方程
{
public static void main (String args[]) throws NumberFormatException, IOException
{
float a[]=new float [3];
for(int i=0;i<a.length;i++)
{
System.out.println("请输入第"+(i+1)+"个数");
BufferedReader in =new BufferedReader(new InputStreamReader(System.in));
a[i]=Float.parseFloat(in.readLine());
}
float x1=0,x2=0;
x1=(float) ((((-1)*a[1])+(Math.sqrt(a[1]*a[1]-4*a[0]*a[2])))/(2*a[0]));
x2=(float) ((((-1)*a[1])-(Math.sqrt(a[1]*a[1]-4*a[0]*a[2])))/(2*a[0]));
System.out.print(a[0]+"X2"+a[1]+"X"+a[2]+"的两个根是：");
System.out.print(x1+"和"+x2);
}
}

⑦ 5道简单的JAVA编程题（高分悬赏）

很详细的帮你写下，呵呵，所以要给分哦！
1、
（1）源程序如下：
public class One {

public static void main(String[] args) {
String name = "张三";
int age = 23;
char sex = '男';
String myclass = "某某专业2班";
System.out.println("姓名：" + name);
System.out.println("姓名：" + age);
System.out.println("姓名：" + sex);
System.out.println("姓名：" + myclass);

}

}

（2）

编写完程序的后缀名是.java，如本题，文件名就是One.java。
开始\运行\cmd，进入“命令提示符窗口”，然后用javac编译器编译.java文件，语句：javac One.java。

（3）
编译成功后，生成的文件名后缀是.class，叫做字节码文件。再用java解释器来运行改程序，语句：java One

2、编写程序，输出1到100间的所有偶数
（1）for语句
public class Two1 {

public static void main(String[] args) {
for(int i=2;i<=100;i+=2)
System.out.println(i);

}
}

（2）while语句
public class Two2 {

public static void main(String[] args) {
int i = 2;
while (i <= 100) {
System.out.println(i);
i += 2;
}
}
}

（3）do…while语句
public class Two3 {

public static void main(String[] args) {
int i = 2;
do {
System.out.println(i);
i += 2;
}while(i<=100);
}
}

3、编写程序，从10个数当中找出最大值。
（1）for循环
import java.util.*;

public class Three1 {

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number;
int max = 0;
for (int i = 0; i < 10; i++) {
System.out.print("输入第" + (i + 1) + "个数:");
number = input.nextInt();
if (max < number)
max = number;
}
System.out.println("最大值：" + max);
}
}

（2）while语句
import java.util.*;

public class Three2 {

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number;
int max = 0;
int i = 0;
while (i < 10) {
System.out.print("输入第" + (i + 1) + "个数:");
number = input.nextInt();
if (max < number)
max = number;
i++;
}
System.out.println("最大值：" + max);
}
}

（3）do…while语句
import java.util.*;

public class Three3 {

public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number;
int max = 0;
int i = 0;
do {
System.out.print("输入第" + (i + 1) + "个数:");
number = input.nextInt();
if (max < number)
max = number;
i++;
}while(i<10);
System.out.println("最大值：" + max);
}
}

4、编写程序，计算从1到100之间的奇数之和。
（1）for循环

public class Four1 {

public static void main(String[] args) {
int sum=0;
for(int i = 1;i<=100;i+=2){
sum+=i;
}
System.out.println("1~100间奇数和：" + sum);
}
}

（2）while语句
public class Four2 {

public static void main(String[] args) {
int sum = 0;
int i = 1;
while (i <= 100) {
sum += i;
i += 2;
}
System.out.println("1~100间奇数和：" + sum);
}
}

（3）do…while语句
public class Four3 {

public static void main(String[] args) {
int sum = 0;
int i = 1;
do {
sum += i;
i += 2;
} while (i <= 100);
System.out.println("1~100间奇数和：" + sum);
}
}

5、
（1）什么是类的继承？什么是父类？什么是子类？举例说明。
继承:是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B，就把这个A称为"B的子类"，而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法，而不需要再次编写相同的代码。在令子类继承父类的同时，可以重新定义某些属性，并重写某些方法，即覆盖父类的原有属性和方法，使其获得与父类不同的功能。另外，为子类追加新的属性和方法也是常见的做法。继承需要关键字extends。举例：
class A{}
class B extends A{}
//成员我就不写了，本例中，A是父类，B是子类。

（2）编写一个继承的程序。
class Person {
public String name;
public int age;
public char sex;

public Person(String n, int a, char s) {
name = n;
age = a;
sex = s;
}

public void output1() {
System.out.println("姓名：" + name + "\n年龄:" + age + "\n性别:" + sex);
}
}

class StudentPerson extends Person {
String school, department, subject, myclass;

public StudentPerson(String sc, String d, String su, String m, String n,
int a, char s) {
super(n, a, s);
school = sc;
department = d;
subject = su;
myclass = m;
}

public void output2() {
super.output1();
System.out.println("学校：" + school + "\n系别:" + department + "\n专业:"
+ subject + "\n班级:" + myclass);
}
}

public class Five2 {

public static void main(String[] args) {
StudentPerson StudentPersonDemo = new StudentPerson("某某大学", "某某系别",
" 某专业", "某某班级", " 张三", 23, '男');
StudentPersonDemo.output2();
}
}

⑧ Java编程常见面试题目,要求正确答案

第一，谈谈final, finally, finalize的区别。

final?修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载finally?再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。

finalize?方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

第二，Anonymous Inner Class (匿名内部类) 是否可以extends(继承)其它类，是否可以implements(实现)interface(接口)?

匿名的内部类是没有名字的内部类。不能extends(继承) 其它类，但一个内部类可以作为一个接口，由另一个内部类实现。

第三，Static Nested Class 和 Inner Class的不同，说得越多越好(面试题有的很笼统)。

Nested Class （一般是C++的说法），Inner Class (一般是JAVA的说法)。Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用上。具体可见http: //www.frontfree.net/articles/services/view.ASP?id=704&page=1

注： 静态内部类（Inner Class）意味着1创建一个static内部类的对象，不需要一个外部类对象，2不能从一个static内部类的一个对象访问一个外部类对象

第四，&和&&的区别。

&是位运算符。&&是布尔逻辑运算符。

第五，HashMap和Hashtable的区别。

都属于Map接口的类，实现了将惟一键映射到特定的值上。

HashMap 类没有分类或者排序。它允许一个 null 键和多个 null 值。

Hashtable 类似于 HashMap，但是不允许 null 键和 null 值。它也比 HashMap 慢，因为它是同步的。

第六，Collection 和 Collections的区别。

Collections是个java.util下的类，它包含有各种有关集合操作的静态方法。
Collection是个java.util下的接口，它是各种集合结构的父接口。

第七，什么时候用assert。

断言是一个包含布尔表达式的语句，在执行这个语句时假定该表达式为 true。如果表达式计算为 false，那么系统会报告一个 AssertionError。它用于调试目的：

assert(a > 0); // throws an AssertionError if a <= 0

断言可以有两种形式：

assert Expression1 ;
assert Expression1 : Expression2 ;

Expression1 应该总是产生一个布尔值。
Expression2 可以是得出一个值的任意表达式。这个值用于生成显示更多调试信息的 String 消息。
断言在默认情况下是禁用的。要在编译时启用断言，需要使用 source 1.4 标记：

Javac -source 1.4 Test.java

要在运行时启用断言，可使用 -enableassertions 或者 -ea 标记。
要在运行时选择禁用断言，可使用 -da 或者 -disableassertions 标记。
要系统类中启用断言，可使用 -esa 或者 -dsa 标记。还可以在包的基础上启用或者禁用断言。

可以在预计正常情况下不会到达的任何位置上放置断言。断言可以用于验证传递给私有方法的参数。不过，断言不应该用于验证传递给公有方法的参数，因为不管是否启用了断言，公有方法都必须检查其参数。不过，既可以在公有方法中，也可以在非公有方法中利用断言测试后置条件。另外，断言不应该以任何方式改变程序的状态。

第八，GC是什么? 为什么要有GC? (基础)。

GC是垃圾收集器。Java 程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：

System.gc()
Runtime.getRuntime().gc()

第九，String s = new String("xyz");创建了几个String Object?

两个对象，一个是“xyx”,一个是指向“xyx”的引用对象s。

第十，Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

Math.round(11.5)返回（long）12，Math.round(-11.5)返回（long）-11;

第十一，short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

short s1 = 1; s1 = s1 + 1;有错，s1是short型，s1+1是int型,不能显式转化为short型。可修改为s1 =(short)(s1 + 1) 。short s1 = 1; s1 += 1正确。

第十二，sleep() 和 wait() 有什么区别? 搞线程的最爱

sleep()方法是使线程停止一段时间的方法。在sleep 时间间隔期满后，线程不一定立即恢复执行。这是因为在那个时刻，其它线程可能正在运行而且没有被调度为放弃执行，除非(a)“醒来”的线程具有更高的优先级，(b)正在运行的线程因为其它原因而阻塞。

wait()是线程交互时，如果线程对一个同步对象x 发出一个wait()调用，该线程会暂停执行，被调对象进入等待状态，直到被唤醒或等待时间到。

第十三，Java有没有goto?

Goto?java中的保留字，现在没有在java中使用。

第十四，数组有没有length()这个方法? String有没有length()这个方法？

数组没有length()这个方法，有length的属性。
String有有length()这个方法。

第十五，Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。Overloaded的方法是可以改变返回值的类型。

第十六，Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别?

Set里的元素是不能重复的，那么用iterator()方法来区分重复与否。equals()是判读两个Set是否相等。

equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。

第十七，给我一个你最常见到的runtime exception。

ArithmeticException, ArrayStoreException, BufferOverflowException, BufferUnderflowException, CannotRedoException, CannotUndoException, ClassCastException, CMMException, , DOMException, EmptyStackException, IllegalArgumentException, IllegalMonitorStateException, IllegalPathStateException, IllegalStateException,
ImagingOpException, IndexOutOfBoundsException, MissingResourceException, NegativeArraySizeException, NoSuchElementException, NullPointerException, ProfileDataException, ProviderException, RasterFormatException, SecurityException, SystemException, UndeclaredThrowableException, UnmodifiableSetException, UnsupportedOperationException

第十八，error和exception有什么区别?

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。

exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

第十九，List, Set, Map是否继承自Collection接口?

List，Set是

Map不是。

第二十，abstract class和interface有什么区别?

声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。不能有抽象构造函数或抽象静态方法。Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

接口（interface）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对象上调用接口的方法。由于有抽象类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

第二十一，abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?

都不能

第二十二，接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类(concrete class)?

接口可以继承接口。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

第二十三，启动一个线程是用run()还是start()?

启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。run()方法可以产生必须退出的标志来停止一个线程。

第二十四，构造器Constructor是否可被override?

构造器Constructor不能被继承，因此不能重写Overriding，但可以被重载Overloading。

第二十五，是否可以继承String类?

String类是final类故不可以继承。

第二十六，当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

不能，一个对象的一个synchronized方法只能由一个线程访问。

第二十七，try {}里有一个return语句，那么紧跟在这个try后的finally {}里的code会不会被执行，什么时候被执行，在return前还是后?

会执行，在return前执行。

第二十八，编程题: 用最有效率的方法算出2乘以8等于几?

有C背景的程序员特别喜欢问这种问题。

2 << 3

第二十九，两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?

不对，有相同的hash code。

第三十，当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递?

是值传递。Java 编程语言只由值传递参数。当一个对象实例作为一个参数被传递到方法中时，参数的值就是对该对象的引用。对象的内容可以在被调用的方法中改变，但对象的引用是永远不会改变的。

第三十一，swtich是否能作用在byte上，是否能作用在long上，是否能作用在String上?

switch（expr1）中，expr1是一个整数表达式。因此传递给 switch 和 case 语句的参数应该是 int、 short、 char 或者 byte。long,string 都不能作用于swtich。

第三十二，编程题: 写一个Singleton出来。

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

一般Singleton模式通常有几种种形式:

第一种形式: 定义一个类，它的构造函数为private的，它有一个static的private的该类变量，在类初始化时实例话，通过一个public的getInstance方法获取对它的引用,继而调用其中的方法。

public class Singleton {
private Singleton(){}
//在自己内部定义自己一个实例，是不是很奇怪？
//注意这是private 只供内部调用
private static Singleton instance = new Singleton();
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}

第二种形式:

public class Singleton {
private static Singleton instance = null;
public static synchronized Singleton getInstance() {
//这个方法比上面有所改进，不用每次都进行生成对象，只是第一次
//使用时生成实例，提高了效率！
if (instance==null)
instance＝new Singleton();
return instance; }
}

其他形式:

定义一个类，它的构造函数为private的，所有方法为static的。

一般认为第一种形式要更加安全些

第三十三 Hashtable和HashMap

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许

还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

⑨ 有关java编程题目

按照题目要求编写的圆,圆锥和测试类的Java程序如下

Test.java文件内容如下

class Circle{

private double r;

private String color;

public Circle(double r){

this.r=r;

}

public double area(){

return Math.PI*r*r;

}

public double perimeter(){

return Math.PI*2*r;

}

public double getR(){

return this.r;

}

public void setR(double r){

this.r=r;

}

public String getColor(){

return this.color;

}

public void setColor(String color){

this.color=color;

}

public String toString(){

return "圆的半径为"+r+",颜色为"+color;

}

}

class Cone{

private Circle c;

private double h;

private String color;

public Cone(Circle c,double h){

this.c=c;

this.h=h;

}

public double volume(){

return 1.0/3*c.area()*h;

}

public Circle getCircle(){

return this.c;

}

public void setCircle(Circle c){

this.c=c;

}

public double getH(){

return this.h;

}

public void setH(double h){

this.h=h;

}

public String getColor(){

return this.color;

}

public void setColor(String color){

this.color=color;

}

public String toString(){

return "圆锥的底面积为"+c.area()+",高为"+h+",颜色为"+color;

}

}

public class Test{

public static void main(String[] args){

Circle circle1=new Circle(2.5);

circle1.setColor("红色");

System.out.println(circle1.toString());

System.out.println("圆的面积为"+circle1.area());

System.out.println("圆的周长为"+circle1.perimeter());

Cone circlar1=new Cone(circle1,2.7);

circlar1.setColor("蓝色");

System.out.println(circlar1.toString());

System.out.println("圆锥的体积为"+circlar1.volume());

}

}