Java笔试题汇总--试题

1.
abstract class Name {
private String name;
public abstract boolean isStupidName(String name) {}
}
大侠们，这有何错误?
答案: 错。abstract method必须以分号结尾，且不带花括号。

 

2.
public class Something {
void doSomething () {
private String s = "";
int l = s.length();
}
}
有错吗?
答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。

 

3.
abstract class Something {
private abstract String doSomething ();
}
这好像没什么错吧?
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract
method封锁起来呢? (同理，abstract method前不能加final)。

 

4.
public class Something {
public int addOne(final int x) {
return ++x;
}
}
这个比较明显。
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。

 

5.
public class Something {
public static void main(String[] args) {
Other o = new Other();
new Something().addOne(o);
}
public void addOne(final Other o) {
o.i++;
}
}
class Other {
public int i;
}
和上面的很相似，都是关于final的问题，这有错吗?
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other();)，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。

 

6.
class Something {
int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
有什么错呢? 看不出来啊。
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。

 

7.
class Something {
final int i;
public void doSomething() {
System.out.println("i = " + i);
}
}
和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?
答案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改为"final int i = 0;"。

 

8.
public class Something {
public static void main(String[] args) {
Something s = new Something();
System.out.println("s.doSomething() returns " + doSomething());
}
public String doSomething() {
return "Do something ...";
}
}
看上去很完美。
答案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是static的。static method不能直接call non-static methods。可改成"System.out.println("s.doSomething() returns " + s.doSomething());"。同理，static method不能访问non-static instant variable。

 

9.
此处，Something类的文件名叫OtherThing.java
class Something {
private static void main(String[] something_to_do) {
System.out.println("Do something ...");
}
}
这个好像很明显。
答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。

 

10．
interface A{
int x = 0;
}
class B{
int x =1;
}
class C extends B implements A {
public void pX(){
System.out.println(x);
}
public static void main(String[] args) {
new C().pX();
}
}
答案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含为 public static final.所以可以通过A.x来明确。

 

11.
interface Playable {
void play();
}
interface Bounceable {
void play();
}
interface Rollable extends Playable, Bounceable {
Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
private String name;
public String getName() {
return name;
}
public Ball(String name) {
this.name = name;
}
public void play() {
ball = new Ball("Football");
System.out.println(ball.getName());
}
}
这个错误不容易发现。
答案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多个interfaces，所以这里没错。问题出在interface Rollable里的"Ball ball = new Ball("PingPang");"。任何在interface里声明的interface variable (接口变量，也可称成员变量)，默认为public static final。也就是说"Ball ball = new Ball("PingPang");"实际上是"public static final Ball ball = new Ball("PingPang");"。在Ball类的Play()方法中，"ball = new Ball("Football");"改变了ball的reference，而这里的ball来自Rollable interface，Rollable interface里的ball是public static final的，final的object是不能被改变reference的。因此编译器将在"ball = new Ball("Football");"这里显示有错。

 

=====================

JAVA代码查错
1.
abstract class Name { 
  private String name;
  public abstract boolean isStupidName(String name) { }
}
大侠们，这有何错误?
答案: 错。abstract method必须以分号结尾，且不带花括号。
2.
public class Something { 
  void doSomething () { 
      private String s = "";
      int l = s.length();
  }
}
有错吗?
答案: 错。局部变量前不能放置任何访问修饰符 (private，public，和protected)。final可以用来修饰局部变量
(final如同abstract和strictfp，都是非访问修饰符，strictfp只能修饰class和method而非variable)。
3.
abstract class Something { 
  private abstract String doSomething ();
}
这好像没什么错吧?
答案: 错。abstract的methods不能以private修饰。abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstract
method封锁起来呢? (同理，abstract method前不能加final)。
4.
public class Something { 
  public int addOne(final int x) { 
      return ++x;
  }
}
这个比较明显。
答案: 错。int x被修饰成final，意味着x不能在addOne method中被修改。
5.
public class Something { 
  public static void main(String[] args) { 
      Other o = new Other();
      new Something().addOne(o);
  }
  public void addOne(final Other o) { 
      o.i++;
  }
}
class Other { 
  public int i;
}
和上面的很相似，都是关于final的问题，这有错吗?
答案: 正确。在addOne method中，参数o被修饰成final。如果在addOne method里我们修改了o的reference
(比如: o = new Other()，那么如同上例这题也是错的。但这里修改的是o的member vairable
(成员变量)，而o的reference并没有改变。
6.
class Something { 
   int i;
   public void doSomething() { 
       System.out.println("i = " + i);
    }
} 
有什么错呢? 看不出来啊。
答案: 正确。输出的是"i = 0"。int i属於instant variable (实例变量，或叫成员变量)。instant variable有default value。int的default value是0。
7.
class Something { 
   final int i;
   public void doSomething() { 
       System.out.println("i = " + i);
    }
}
和上面一题只有一个地方不同，就是多了一个final。这难道就错了吗?
答 案: 错。final int i是个final的instant variable (实例变量，或叫成员变量)。final的 instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。可以修改 为"final int i = 0;"。
8.
public class Something { 
    public static void main(String[] args) { 
       Something s = new Something();
       System.out.println("s.doSomething() returns " + doSomething());
    }
   public String doSomething() { 
       return "Do something ...";
    }
}
看上去很完美。
答 案: 错。看上去在main里call doSomething没有什么问题，毕竟两个methods都在同一个class里。但仔细看，main是 static的。static method不能直接call non-static methods。可改 成"System.out.println("s.doSomething() returns " + s.doSomething());"。同 理，static method不能访问non-static instant variable。
9.
此处，Something类的文件名叫OtherThing.java
class Something { 
   private static void main(String[] something_to_do) {        
       System.out.println("Do something ...";
    }
}
这个好像很明显。
答案: 正确。从来没有人说过Java的Class名字必须和其文件名相同。但public class的名字必须和文件名相同。
10．
interface  A{ 
  int x = 0;
}
class B{ 
  int x =1;
}
class C extends B implements A { 
  public void pX(){ 
     System.out.println(x);
  }
  public static void main(String[] args) { 
     new C().pX();
  }
}
答 案：错误。在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util 和java.sql两个包时直接声明Date一样）。对于父类的变量,可以用super.x来明确，而接口的属性默认隐含 为 public static final.所以可以通过A.x来明确。
11.
interface Playable { 
   void play();
}
interface Bounceable { 
   void play();
}
interface Rollable extends Playable, Bounceable { 
   Ball ball = new Ball("PingPang";
}
class Ball implements Rollable { 
   private String name;
   public String getName() { 
       return name;
    }
   public Ball(String name) { 
       this.name = name;        
    }
  public void play() { 
       ball = new Ball("Football";
       System.out.println(ball.getName());
    }
}
这个错误不容易发现。
答 案: 错。"interface Rollable extends Playable, Bounceable"没有问题。interface可继承多 个interfaces，所以这里没错。问题出在interface Rollable里 的"Ball ball = new Ball("PingPang";"。任何在interface里声明的 interface variable (接口变量，也可称成员变量)，默认为public static final。也就是 说"Ball ball = new Ball("PingPang";"实际上 是"public static final Ball ball = new Ball("PingPang";"。在Ball类的Play()方法 中，"ball = new Ball("Football";"改变了ball的reference，而这里的ball来自 Rollable interface，Rollable interface里的ball是public static final的，final的 object是不能被改变reference的。因此编译器将在"ball = new Ball("Football";"这里显示有错。

JAVA编程题
1．现在输入n个数字，以逗号，分开；然后可选择升或者降序排序；按提交键就在另一页面显示按什么排序，结果为，提供reset
import java.util.*;
public class bycomma{ 
public static String[] splitStringByComma(String source){ 
  if(source==null||source.trim().equals("")
   return null;
  StringTokenizer commaToker = new StringTokenizer(source,",";
  String[] result = new String[commaToker.countTokens()];
  int i=0;
  while(commaToker.hasMoreTokens()){ 
   result[i] = commaToker.nextToken();
   i++;
  }
  return result;
}
public static void main(String args[]){ 
String[] s = splitStringByComma("5,8,7,4,3,9,1";
int[] ii = new int[s.length];
for(int i = 0;i<s.length;i++){ 
ii[i] =Integer.parseInt(s[i]);
}
   Arrays.sort(ii);
   //asc
   for(int i=0;i<s.length;i++){ 
   System.out.println(ii[i]);
    }
   //desc
   for(int i=(s.length-1);i>=0;i--){ 
   System.out.println(ii[i]);
    }
}
}
2．金额转换，阿拉伯数字的金额转换成中国传统的形式如：（￥1011）－>（一千零一拾一元整）输出。
package test.format;
import java.text.NumberFormat;
import java.util.HashMap;
public class SimpleMoneyFormat { 
 public static final String EMPTY = "";
 public static final String ZERO = "零";
 public static final String ONE = "壹";
 public static final String TWO = "贰";
 public static final String THREE = "叁";
 public static final String FOUR = "肆";
 public static final String FIVE = "伍";
 public static final String SIX = "陆";
 public static final String SEVEN = "柒";
 public static final String EIGHT = "捌";
 public static final String NINE = "玖";
 public static final String TEN = "拾";
 public static final String HUNDRED = "佰";
 public static final String THOUSAND = "仟";
 public static final String TEN_THOUSAND = "万";
 public static final String HUNDRED_MILLION = "亿";
 public static final String YUAN = "元";
 public static final String JIAO = "角";
 public static final String FEN = "分";
 public static final String DOT = ".";

 private static SimpleMoneyFormat formatter = null;
 private HashMap chineseNumberMap = new HashMap();
 private HashMap chineseMoneyPattern = new HashMap();
 private NumberFormat numberFormat = NumberFormat.getInstance();

 private SimpleMoneyFormat() { 
   numberFormat.setMaximumFractionDigits(4);
   numberFormat.setMinimumFractionDigits(2);
   numberFormat.setGroupingUsed(false);

   chineseNumberMap.put("0", ZERO);
   chineseNumberMap.put("1", ONE);
   chineseNumberMap.put("2", TWO);
   chineseNumberMap.put("3", THREE);
   chineseNumberMap.put("4", FOUR);
   chineseNumberMap.put("5", FIVE);
   chineseNumberMap.put("6", SIX);
   chineseNumberMap.put("7", SEVEN);
   chineseNumberMap.put("8", EIGHT);
   chineseNumberMap.put("9", NINE);
   chineseNumberMap.put(DOT, DOT);

   chineseMoneyPattern.put("1", TEN);
   chineseMoneyPattern.put("2", HUNDRED);
   chineseMoneyPattern.put("3", THOUSAND);
   chineseMoneyPattern.put("4", TEN_THOUSAND);
   chineseMoneyPattern.put("5", TEN);
   chineseMoneyPattern.put("6", HUNDRED);
   chineseMoneyPattern.put("7", THOUSAND);
   chineseMoneyPattern.put("8", HUNDRED_MILLION);
  }

 public static SimpleMoneyFormat getInstance() { 
   if (formatter == null)
     formatter = new SimpleMoneyFormat();
   return formatter;
  }

 public String format(String moneyStr) { 
   checkPrecision(moneyStr);
   String result;
   result = convertToChineseNumber(moneyStr);
   result = addUnitsToChineseMoneyString(result);
   return result;
  }

 public String format(double moneyDouble) { 
   return format(numberFormat.format(moneyDouble));
  }

 public String format(int moneyInt) { 
   return format(numberFormat.format(moneyInt));
  }

 public String format(long moneyLong) { 
   return format(numberFormat.format(moneyLong));
  }

 public String format(Number moneyNum) { 
   return format(numberFormat.format(moneyNum));
  }

 private String convertToChineseNumber(String moneyStr) { 
   String result;
   StringBuffer cMoneyStringBuffer = new StringBuffer();
   for (int i = 0; i < moneyStr.length(); i++) { 
     cMoneyStringBuffer.append(chineseNumberMap.get(moneyStr.substring(i, i + 1)));
    }
   //拾佰仟万亿等都是汉字里面才有的单位，加上它们
   int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
   int moneyPatternCursor = 1;
   for (int i = indexOfDot - 1; i > 0; i--) { 
     cMoneyStringBuffer.insert(i, chineseMoneyPattern.get(EMPTY + moneyPatternCursor));
     moneyPatternCursor = moneyPatternCursor == 8 ? 1 : moneyPatternCursor + 1;
    }

   String fractionPart = cMoneyStringBuffer.substring(cMoneyStringBuffer.indexOf(".");
   cMoneyStringBuffer.delete(cMoneyStringBuffer.indexOf(".", cMoneyStringBuffer.length());
   while (cMoneyStringBuffer.indexOf("零拾" != -1) { 
     cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零拾", cMoneyStringBuffer.indexOf("零拾" + 2, ZERO);
    }
   while (cMoneyStringBuffer.indexOf("零佰" != -1) { 
     cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零佰", cMoneyStringBuffer.indexOf("零佰" + 2, ZERO);
    }
   while (cMoneyStringBuffer.indexOf("零仟" != -1) { 
     cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零仟", cMoneyStringBuffer.indexOf("零仟" + 2, ZERO);
    }
   while (cMoneyStringBuffer.indexOf("零万" != -1) { 
     cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零万", cMoneyStringBuffer.indexOf("零万" + 2, TEN_THOUSAND);
    }
   while (cMoneyStringBuffer.indexOf("零亿" != -1) { 
     cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零亿", cMoneyStringBuffer.indexOf("零亿" + 2, HUNDRED_MILLION);
    }
   while (cMoneyStringBuffer.indexOf("零零" != -1) { 
     cMoneyStringBuffer.replace(cMoneyStringBuffer.indexOf("零零", cMoneyStringBuffer.indexOf("零零" + 2, ZERO);
    }
   if (cMoneyStringBuffer.lastIndexOf(ZERO) == cMoneyStringBuffer.length() - 1)
     cMoneyStringBuffer.delete(cMoneyStringBuffer.length() - 1, cMoneyStringBuffer.length());
   cMoneyStringBuffer.append(fractionPart);

   result = cMoneyStringBuffer.toString();
   return result;
  }

 private String addUnitsToChineseMoneyString(String moneyStr) { 
   String result;
   StringBuffer cMoneyStringBuffer = new StringBuffer(moneyStr);
   int indexOfDot = cMoneyStringBuffer.indexOf(DOT);
   cMoneyStringBuffer.replace(indexOfDot, indexOfDot + 1, YUAN);

 

 

 

1. 以下三条输出语句分别输出什么？[C易]
char str1[]       = "abc";
char str2[]       = "abc";
const char str3[] = "abc"; 
const char str4[] = "abc"; 
const char* str5  = "abc";
const char* str6  = "abc";
cout << boolalpha << ( str1==str2  << endl; // 输出什么？
cout << boolalpha << ( str3==str4  << endl; // 输出什么？
cout << boolalpha << ( str5==str6  << endl; // 输出什么？

13. 非C++内建型别 A 和 B，在哪几种情况下B能隐式转化为A？[C++中等]
答：
a. class B : public A { …… } // B公有继承自A，可以是间接继承的
b. class B { operator A( ; } // B实现了隐式转化为A的转化
c. class A { A( const B& ; } // A实现了non-explicit的参数为B（可以有其他带默认值的参数）构造函数
d. A& operator= ( const A& ; // 赋值操作，虽不是正宗的隐式类型转换，但也可以勉强算一个

12. 以下代码中的两个sizeof用法有问题吗？[C易]
void UpperCase( char str[]  // 将 str 中的小写字母转换成大写字母
{ 
   for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i 
       if( 'a'<=str[i] && str[i]<='z' 
           str[i] -= ('a'-'A' ;
}
char str[] = "aBcDe";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str ;
cout << str << endl;

7. 以下代码有什么问题？[C难]
void char2Hex( char c  // 将字符以16进制表示
{ 
   char ch = c/0x10 + '0'; if( ch > '9'  ch += ('A'-'9'-1);
   char cl = c%0x10 + '0'; if( cl > '9'  cl += ('A'-'9'-1);
   cout << ch << cl << ' ';
}
char str[] = "I love 中国";
for( size_t i=0; i<strlen(str); ++i 
   char2Hex( str[i] ;
cout << endl;

4. 以下代码有什么问题？[C++易]
struct Test
{ 
   Test( int  { }
   Test() { }
   void fun() { }
};
void main( void 
{ 
   Test a(1);
   a.fun();
   Test b();
   b.fun();
}

5. 以下代码有什么问题？[C++易]
cout << (true?1:"1" << endl;

8. 以下代码能够编译通过吗，为什么？[C++易]
unsigned int const size1 = 2;
char str1[ size1 ];
unsigned int temp = 0;
cin >> temp;
unsigned int const size2 = temp;
char str2[ size2 ];

9. 以下代码中的输出语句输出0吗，为什么？[C++易]
struct CLS
{ 
   int m_i;
   CLS( int i  : m_i(i) { }
   CLS()
   { 
       CLS(0);
    }
};
CLS obj;
cout << obj.m_i << endl;

10. C++中的空类，默认产生哪些类成员函数？[C++易]
答：
class Empty
{ 
public:
   Empty();                          // 缺省构造函数
   Empty( const Empty& ;            // 拷贝构造函数
   ~Empty();                         // 析构函数
   Empty& operator=( const Empty& ; // 赋值运算符
   Empty* operator&();               // 取址运算符
   const Empty* operator&() const;   // 取址运算符 const
};

3. 以下两条输出语句分别输出什么？[C++难]
float a = 1.0f;
cout << (int)a << endl;
cout << (int&a << endl;
cout << boolalpha << ( (int)a == (int&a  << endl; // 输出什么？
float b = 0.0f;
cout << (int)b << endl;
cout << (int&b << endl;
cout << boolalpha << ( (int)b == (int&b  << endl; // 输出什么？

2. 以下反向遍历array数组的方法有什么错误？[STL易]
vector array;
array.push_back( 1 ;
array.push_back( 2 ;
array.push_back( 3 ;
for( vector::size_type i=array.size()-1; i>=0; --i  // 反向遍历array数组
{ 
   cout << array[i] << endl;
}

6. 以下代码有什么问题？[STL易]
typedef vector IntArray;
IntArray array;
array.push_back( 1 ;
array.push_back( 2 ;
array.push_back( 2 ;
array.push_back( 3 ;
// 删除array数组中所有的2
for( IntArray::iterator itor=array.begin(); itor!=array.end(); ++itor 
{ 
   if( 2 == *itor  array.erase( itor ;
}

11. 写一个函数，完成内存之间的拷贝。[考虑问题是否全面]
答：
void* mymemcpy( void *dest, const void *src, size_t count 
{ 
   char* pdest = static_cast<char*>( dest ;
   const char* psrc = static_cast<const char*>( src ;
   if( pdest>psrc && pdest<psrc+cout  能考虑到这种情况就行了
   { 
       for( size_t i=count-1; i!=-1; --i 
               pdest[i] = psrc[i];
    }
   else
   { 
       for( size_t i=0; i<count; ++i 
           pdest[i] = psrc[i];
    }
   return dest;
}
int main( void 
{ 
   char str[] = "0123456789";
   mymemcpy( str+1, str+0, 9 ;
   cout << str << endl;

   system( "Pause" ;
   return 0;
}

 

===============================

 

l    JBS
1.列举出 10个JAVA语言的优势
a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用
2.列举出JAVA中10个面向对象编程的术语
a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型
3.列举出JAVA中6个比较常用的包
Java.lang;java.util;java.io;java.sql;java.awt;java.net;java.applet;javax.swing
4.JAVA中的标识符有什么作用和特点
作用：标识符用作给变量、类和方法命名
特点：可以以字母、下划线“_”和”$”符开头
首字符外，可以跟上字母、下划线“_”和”$”符或数字
Java是大小写敏感的，标识符也不例外
5.JAVA中的关键字有什么特点,列举出至少20个关键字
Java中一些赋以特定的含义、并用做专门用途的单词称为关键字（keyword）
所有Java关键字都是小写的，TURE、FALSE、NULL等都不是Java关键字 ；
goto和const 虽然从未被使用，但也作为Java关键字保留；
?          中一共有51个关键字Java
abstract assert boolean break byte continue
case catch char class const double
default do extends else final float
for goto long if implements import
native new null instanceof int interface
package private protected public return short
static strictfp super switch synchronized this
while void throw throws transient try
volatile         

        6.JAVA中数据类型如何分类？

可分为简单数据类型和引用数据类型:
简单数据类型：数值型（byte,short,int,long,float double)，字符型(char)，布尔型(boolean);
引用数据类型：类，接口，数组.
7.JAVA中运算符的分类及举例
?          分割符：,，;，[]，()
?          算术运算符: +，―，*，/，%，++，――
?          关系运算符: >， <，>=， <=，==，!=
?          布尔逻辑运算符: !，& , | , ^ , &&，||
?          位运算符: &，|，^，~ ， >>， < <，>>>
?          赋值运算符: = 扩展赋值运算符:+=，―=，*=，/=
?          字符串连接运算符: +
?          造型操作符：()

8.super,this关键字的作用及用法
?          在Java类中使用super来引用父类的成分
–        可用于访问父类中定义的属性super
–        可用于调用父类中定义的成员方法super
–        可用于在子类构造器中调用父类的构造器super
–        的追溯不仅于直接父类super
?          中为解决变量的命名冲突和不确定性问题，引入关键字“this”代表其所在方法的当前对象。Java
–        构造器中指该构造器所创建的新对象
–        方法中指调用该方法的对象
?          关键字的用法this
–        在类本身的方法或构造器中引用该类的实例变量和方法
–        将当前对象作为参数传递给其它方法或构造器
–        用来调用其他的重载的构造器

9.什么是JAVA中的表达式？有什么作用？
?          表达式是运算符和操作数的结合，它是任何一门编程语言的关键组成部分
?          表达式允许程序员进行数学计算、值的比较、逻辑操作以及在Java中进行对象的操作。
?          一些表达式的例子：
–        X
–        X+10
–        Y=x+10
–        Arr[10]
–        student.geName()

10.做表列出JAVA中所有修饰符和他们的适用范围(能不能修饰构造器，属性，自由块等)
  class 属性 方法 构建器 自由块 内部类
public Y Y Y Y  Y
protected    Y Y Y  Y
(Default) Y Y Y Y Y Y
private  Y Y Y  Y
final Y Y Y    Y
abstract Y  Y    Y
static    Y  Y Y


11.写一个方法，用一个for循环打印九九乘法表
    /**
    *一个for循环打印九九乘法表
    */
    publicvoid nineNineMultiTable()
    {
      for (int i = 1,j = 1; j <= 9; i++) {
          System.out.print(i+"*"+j+"="+i*j+" ");
          if(i==j)
          {
              i=0;
              j++;
              System.out.println();
          }
      }
    }
12.给定一个java.util.Date对象，如何转化为”2007-3-22 20:23:22”格式的字符串
/**
    *将某个日期以固定格式转化成字符串
    *@paramdate
    *@returnstr
    */
    public String dateToStr(java.util.Date date)
    {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      String str = sdf.format(date);
      return str;
    }
13.写一个方法，能够判断任意一个整数是否素数
/**
    *判断任意一个整数是否素数
    *@paramn
    *@returnboolean
    */
    publicboolean isPrimes(int n)
    {
      for (int i = 2; i <= Math.sqrt(n); i++) {
          if(n%i==0)
          {
              returnfalse;
          }
      }
      returntrue;
    }
14.写一个方法，输入任意一个整数，返回它的阶乘
/**
    *获得任意一个整数的阶乘
    *@paramn
    *@returnn!
    */
    publicint factorial(int n)
    {
      //递归
      if(n==1)
      {
          return 1;
      }
      return n*factorial(n-1);
      //非递归
//    int multi = 1;
//    for (int i = 2; i <= n; i++) {
//        multi*=i;
//    }
//    return multi;
    }
15.写一个方法，用二分查找法判断任意整数在任意整数数组里面是否存在，若存在就返回它在数组中的索引位置，不存在返回-1
/**
    *二分查找特定整数在整型数组中的位置(递归)
    *@paramdataset
    *@paramdata
    *@parambeginIndex
    *@paramendIndex
    *@returnindex
    */
    publicint binarySearch(int[] dataset,int data,int beginIndex,int endIndex)
    {
      int midIndex = (beginIndex+endIndex)/2;
      if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)return -1;
      if(data <dataset[midIndex])
      {
          return binarySearch(dataset,data,beginIndex,midIndex-1);
      }elseif(data>dataset[midIndex])
      {
          return binarySearch(dataset,data,midIndex+1,endIndex);
      }else
      {
          return midIndex;
      }
    }
   
    /**
    *二分查找特定整数在整型数组中的位置(非递归)
    *@paramdataset
    *@paramdata
    *@returnindex
    */
    publicint binarySearch(int[] dataset ,int data)
    {
      int beginIndex = 0; 
      int endIndex = dataset.length - 1; 
      int midIndex = -1;
      if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex)return -1;
      while(beginIndex <= endIndex) {
          midIndex = (beginIndex+endIndex)/2;
          if(data <dataset[midIndex]) { 
          endIndex = midIndex-1; 
          } elseif(data>dataset[midIndex]) { 
          beginIndex = midIndex+1; 
          }else
          {
          return midIndex;
          }
      }
      return -1;
    }
16.做一个饲养员给动物喂食物的例子体现JAVA中的面向对象思想,接口（抽象类）的用处
package com.softeem.demo;

/**
*@authorleno
*动物的接口
*/
interface Animal
{
    publicvoid eat(Food food);
}
/**
*@authorleno
*一种动物类:猫
*/
class Cat implements Animal
{
    publicvoid eat(Food food)
    {
      System.out.println("小猫吃"+food.getName());
    }
}
/**
*@authorleno
*一种动物类:狗
*/
class Dog implements Animal
{
    publicvoid eat(Food food)
    {
      System.out.println("小狗啃"+food.getName());
    }
}

/**
*@authorleno
*食物抽象类
*/
abstractclass Food
{
    protected String name;
    public String getName() {
      returnname;
    }

    publicvoid setName(String name) {
      this.name = name;
    }
}

/**
*@authorleno
*一种食物类:鱼
*/
class Fish extends Food
{
    public Fish(String name) {
      this.name = name;
    }
}
/**
*@authorleno
*一种食物类:骨头
*/
class Bone extends Food
{ 
    public Bone(String name) {
      this.name = name;
    }
}

/**
*@authorleno
*饲养员类
*
*/
class Feeder
{
    /**
    *饲养员给某种动物喂某种食物
    *@paramanimal
    *@paramfood
    */
    publicvoid feed(Animal animal,Food food)
    {
      animal.eat(food);
    }
}

/**
*@authorleno
*测试饲养员给动物喂食物
*/
publicclass TestFeeder {

    publicstaticvoid main(String[] args) {
      Feeder feeder=new Feeder();
      Animal animal=new Dog();
      Food food=new Bone("肉骨头");
      feeder.feed(animal,food); //给狗喂肉骨头
      animal=new Cat();
      food=new Fish("鱼");
      feeder.feed(animal,food); //给猫喂鱼


    }
}
17.描述JAVA中异常处理的机制
?          程序的执行过程中如出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统，这个过程称为抛出(throw)异常。Java
?          当Java运行时系统接收到异常对象时，会寻找能处理这一异常的代码并把当前异常对象交给其处理，这一过程称为捕获(catch)异常。
?          如果Java运行时系统找不到可以捕获异常的方法，则运行时系统将终止，相应的Java程序也将退出。
?          程序员通常只能处理违例(Exception)，而对错误(Error)无能为力。