Java模拟

1.java实现接口必须实现所有方法吗？
必须在实现接口的类中实现所有方法，直到并且除非该类被声明为抽象类

2.final可以修饰：类 变量 方法

final修饰的类不能被继承

final修饰的方法不能被重写

final修饰的变量是一个常量。只能背赋值一次

3.通过使用关键字implements声明自己使用一个或多个接口。

4.接口中的方法被默认的访问权限是 public。

5.输出以ed结尾的单词

public class Demo {
    public static void main(String[] args) {
        String strings[]={"started","starting","ended","ending"};
        for (int i=0;i<strings.length;i++){
            if(strings[i].endsWith("ed")){
                System.out.println(strings[i]);

            }
        }
    }
}

6.使用关键字boolean来定义逻辑变量。

7.编程求解100-1000之间的所有素数，并以10个一行输出。

public class Main01 {
    public static boolean isPrime(int m){
        boolean flag=true;
        for (int i=2;i<=(int)Math.sqrt(m);i++){
            if (m%i==0){
                flag=false;
                break;
            }
        }
        return flag;
    }
    public static void main(String[] args){
        int count=0;
        for (int i=100;i<=1000;i++){
            if (isPrime(i)){
                System.out.format("%5d",i);
                count++;
                if(count%10==0){
                    System.out.println();
                }
            }
        }
        System.out.format("\n%5d",count);
    }
}

注：1.%5d是将数字按宽度为5，采用右对齐方式输出，若数据位数不到5位，则左边补空格
2.format，格式转换。

8.getMax方法用于若干整数的较大值。

public class App1 {
    public static void main(String[] args) {
        System.out.println(getMax(12,-10,25,45,-89,12,23,34,-9,12));
        System.out.println(getMax(145,-289,12,53));
    }
    public static int getMax(int...args){
        int max=Interger.MIN_VALUE;
        for(int x:args){
            if(max<x){
                max=x;
            }
        }
        return max;
    }
}

9.异常处理中使用finally作为异常的统一出口。

10.一个try代码后面必须跟着若干个catch代码段一场或者一个finally代码段。

11.Statement 接口中的excuteQuery(String sql)方法返回值的数据类型是boolean.

12，将一个对象写入一个数据文件，再读出该对象并显示出来。

class Person implements Serializable {
    private static final long serialVersionUID=-5170648846427846282l;
    String name =null;
    public Person(String s){
        name=s;
    }
    public String toStrting(){
        return name;
    }
}
public class Main{
    public static void main(String[] args) {
        ObjectOutputStream oos=null;
        ObjectInputStream ois=null;
        try{
            File f=new File("Person.dat");
            oos=new ObjectOutputStream(new FileOutputStream(f));
            oos.writeObject(new mypackage.Person("小王"));
            oos.close();
            ois=new ObjectInputStream(new FileInputStream(f));

            mypackage.Person d=(mypackage.Person)ois.readObject();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

13.优先级高的线程可以在它的run()方法中调用sleep() 方法来使自己放弃处理器资源，休眠一段时间。

14.构造方法是一个特殊的方法，用于对类的变量进行初始化。

15.Java中用类创建一个对象包括对象的声明和为对象分配空间 两个步骤

16.局部变量的名字和成员变量的名字相同，若想在该方法中使用成员变量，必须使用关键字this 加以区分。

1.Java语言中，构造方法不能继承。1.Supper 必须是子类构造方法中的第一条语句。子类不可以继承父类的构造方法。可以在子类中使用Super关键字。
可以使用super操作被隐藏的成员方法。{子类在继承父类的成员变量和方法时，一旦隐藏了父类某个成员变量和方法，那这些成员变量和方法就被分配给关键字 super 所拥有；

，则子类调用这些被隐藏的成员变量和方法，就需要使用关键字 super 才行}

2.构造方法不能被继承。

3.重载与方法的返回值类型无关。

4.interface定义接口。

5，如果一个类使用了某个接口，这个类必须实现这个接口的全部方法。
接口中常量默认的是public static。
接口中的方法默认的是public abstract。
一个类中使用关键字implements声明自己使用一个或多个接口。

6,7 a.上转型对象不能操作子类新增的成员变量（失掉了这部分的属性），不能调用子类新增的方法（失掉了一些行为）

b.上转型对象可以访问子类继承或隐藏的成员变量，也可以调用子类继承的方法或子类重写的实例方法

8.java应用程序主类中正确的main方法。内部类可以public。 都是标准的public static void main(String args[])

9.数组有三列，有几行还未知。

System.out.println(a[0]);//0
    System.out.println(a[1]);//0
    System.out.println(a[2]);//0
    System.out.println(a[a.length-1]);//0
    System.out.println(a.length);//3

10，try块后至少一个catch块。finally块可省。可能抛出异常的方法应放在try块中，对抛出异常的处理应放在catch块中。

11.throw在程序中抛出异常，throws在方法声明时抛出异常。

12.为了捕获一个异常，代码必须放在try块中。

13.jdbc和数据库连接，可能会产生的异常是：无法获取JDBC连接； 嵌套的异常为java.sql.SQLException：服务器时区值“”

14.类RandomAccessFile不同于其他的I/O流，该流对象是用来访问那些保存数据记录的文件的，这样你就可以用seek( )方法来访问记录，并进行读写了

15.设置线程优先级的方法是getPriority();

16.用Thread 类的子类创建线程时，必须重新定义的方法：run()

17.String jerry=“I love Tom”,s1; s1=jerry.substring(2,5)的值为lov (包左不包右）

18.this表示某个对象，所以this关键字只能出现在实例方法（非静态方法）和构造方法中。
this不能出现在类方法中（静态方法）
19.实例方法只能通过对象调用，不能通过类名调用。

20.访问控制权， public private protected.

1.Java语言中，构造方法不能继承。
2.java语言只支持单重继承，不支持多重继承。
3.子类对象可以直接赋值给父类对象，而父类对象不可以赋值给子类对象。
4.最终类，最终方法和最终变量的修饰符都用final。
5.Java程序编译后生成的字节码文件，其后缀是.class
{java文件就是这样一个未经编译的源程序，一般是给程序员看的。

class文件就是被编译器编译过的java文件，通常是给计算机看的
}
6.在一个源码文件中(.java)有可能含有多各类或者内部类,在这种情况下编译源码文件就会产生多个字节码文件(.class)
7.异常处理可以使整个系统更加安全稳定。
8.List，set继承于Collection
Map没有继承于Collection 其相对是独立的 属于Collection类型的对象可以通过构造函数将一个集合构成另一个集合
9.Set集合不允许包含相同的元素，如果试图把两个相同元素加入同一个Set集合中，则添加操作失败，add()方法返回false，
且新元素不会被加入
10.当DateInputStream对象读到文件结束处，返回-1.
11.文件缓冲流的作用是提高文件的读/写效率。提高读写速度的原因是：内部提供了一个缓冲区。
12.若所有用户线程都终止了，Java程序就会结束。
13.class是定义类的唯一关键字。
14.使用构造方法只能给非静态变量赋初值。
15.Java成员变量有默认值，可以赋初值，也可以不赋，而局部变量声明时一定需要赋值。

+++++++++++++++++++++++++题上的答案不一定是对的，看后面解析++++++++++++++++++++++++++++++++++++++

1.Java不支持多继承。
2.final类，最终类不能被继承。
3.final类，最终类不能被继承。
4.类要实现接口全部方法。
5.上转型对象可以操作子类继承，隐藏，重写的方法和成员变量。上转型对象不可以操作子类新增的方法和成员变量。
6.继承 extends。
7.接口中默认方法public。
8.字节码文件时与平台无关的Unicode码文件。
9.Java语言使用的字符集是Unicode。
10.同上。
11.同上。
12.异常，exception。
13.同上。
14.构造方法PipedOutputStream(PipedInputStream in)生成的输出流：须调用方法与另一个管道输入流连接。
PipedOutputStream的构造方法

public PipedOutputStream(PipedInputStream snk) throws IOException{ connect(snk) }
public PipedOutputStream() {}
有参构造传入PipedInputStream，创建连接到指定管道输入流的管道输出流。
无参构造，创建了未连接到管道输入流的管道输出流。

15.使用接口实现线程的优点：可再从其他类派生。
实现Runnable接口比继承Thread类所具有的优势：

（1）适合多个相同的程序代码的线程去处理同一个资源

（2）可以避免java中的单继承的限制

16.启动线程的方法是：start().
17.同上。
18.同上
19.可以用super操作被隐藏的成员方法。
20.构造方法被调用是当对象被创建时。

1.abstract类不能用new运算符创建对象。
2.Java中常量定义的修饰符是 public static final
3.一个类通过使用关键字implements声明自己使用一个或多个接口。
4.对于子类创建的一个对象，如果子类继承并重写了父类的方法，则运行时调用子类的方法。
5，同上。
6.在同一个switch语句中，case后的常量表达式的值必须互不相同。
7.同上。
8.

public class Main3 {
    public static void main(String[] args) {
        int[][] aTriangle=new int[6][];
        int i,j=6,k;
        for(i=0;i<aTriangle.length;i++){
            aTriangle[i]=new int[j];
            for (k=0;k<j;k++){
                aTriangle[i][k]=k+1;
                System.out.print(aTriangle[i][k]);
            }
            j--;
            System.out.println();
        }
    }
}

9.同上
10.异常，Exception
11.数据库查询结果使用ResultSet 接口对象保存
在JDBC操作中，数据库所有查询记录将使用ResultSet进行接收，并使用ResultSet显示内容。
12.同上。
13.当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于 新建 状态，此时它已经有了相应的内存空间和其他资源。
Thread的生命周期
线程的五种状态：

新建：当一个 Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被star()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时，便进入运行状态，run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CP∪并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

14.抽象，封装，继承，多态。
15.构造方法对类的变量进行初始化。
16.一个类通过使用new运算符和类的构造方法为声明的对象分配内存。

1，单继承。
2.对。
3.如果没有实现接口所有的抽象方法就是抽象类。
4.对。
5.java中可以定义多个主类，但是只能有一个public类
.java的文件名要和public类名相同
6.说明或声明数组时不分配内存大小，创建数组时分配内存大小。
7.出现异常和抛出异常两回事儿。
8.集合（set)不是通过键值对的方法来存储对象的。
9.集合（set)中不能包含相同对象。
10.RandomAccessFile对象是通过移动指针的方式来进行随机访问的。
RandomAccessFile对象包含一个记录指针,用以标示当前读写处的位置,RandomAccessFile类对象可以自由移动记录指针
11.文件缓冲流的作用是提高文件的读/写效率。
12.关键字synchronized能对方法，成员方法，成员变量，代码块进行修饰。
开发中常用的加锁方式就是使用synchronized关键字，可以在以下三种情景使用：

修饰static方法
修饰成员方法
修饰代码块
13.使用构造方法只能给非静态变量赋初值。
14.非静态方法可以引用静态变量，静态方法不可以引用非静态变量
15.某类的对象可以作为另一个类的成员。


1.2.3.4.5.6 同上
7.不能编译，因为String是final类型的。
String类被final关键字修饰，意味着String类不能被继承，并且它的成员方法都默认为final方法；字符串一旦创建就不能再修改
8.一个Java源文件可以由多个类组成，其中只有一个类被public修饰。
9.10.11.12同上
13.JDBC建立数据库连接时，应使用类DriveManager中的静态方法创建一个Conetion对象，这个方法是：getConection();
14.DatelnputStream与DateOutputStream的特点是：读数据时与具体的机器无关，写数据时与具体的机器有关。
15.是一个线程放弃处理器，休眠1，5秒，应调用的方法：sleep(1500)
使用sleep()方法暂停线程执行
说明：Thread.sleep()使当前线程的执行暂停一段指定时间，使得其他线程或者执行在当前计算机上的其他进程。该方法不会放弃除CPU外的其他资源
16.用Thread类的子类创建线程时，必须重新定义的方法：run()
17.实例方法能对实例变量和类变量操作。类方法只能对类变量操作。
18.package awt；的结果是说明文件的类包含在自定义的awt包中。
19.20，同上。

---

其他同上，
12. sum=0; System.in;x%2==0;
13.在处理线程同步时，要做的事情是把修改数据的方法用关键字synchronized 来修饰。

1.子类所继承父类的私有成员方法不可以在子类中访问
子类可以继承父类的所有成员，包括被private修饰的成员，子类只是无法访问、不能调用被private修饰的方法罢了。
我们还是要分清继承和访问权限的问题。
2.实现接口的类可以是抽象类。
3.构造方法不能被继承
4.抽象方法只有方法头没有方法体
5.多个类生成多个字节码文件。
6.声明不分配，创建分配。
7.异常是一种特殊的运行错误的对象。
Java异常概念

1）Java异常是Java提供的用于处理程序错误的一种机制.

2）所谓错误时指在程序运行中发生的一些异常事件

8.Arraya类主要是对数组进行操作。

9.10.11同上。

12.线程的启动是通过引用其start()方法而实现的。

13.类是一种类型，也是对象的一种模板。

14.class 是定义类的唯一关键字

15.构造方法只能给非静态变量赋初值。

1.switch(exp) exp不应该是逻辑型常量。
2.当构造一个输入流对象时，可能产生的异常FileNotFoundException.
3.java自动回收动态分配内存的是线程：垃圾收集线程。
4.一个线程在它的一个完整的生命周期中经历的状态的种类有：新建，就绪，运行，阻塞，死亡。
5.String jerry=“I Love Tom”,s1=jerry.substring(2)的值为love Tom.
6.package awt的结果是：说明文件的类在自定义的awt包中。
7.子类定义的成员变量和父类中的成员变量同名时，子类的成员变量隐藏了父类的成员变量。
8.基本数据类型在创建时系统将指定默认值。
9.集合（set）不是通过键-值对的方法来存储对象的。
10.通过File类能对文件属性进行修改。
11.当线程类多定义的run()方法执行完毕，线程的运行就会停止。
12.在类体内说明成员变量时允许赋值。
13.Thread类提供线程优先级的静态常量：MAX_PRIORITY,MIN_PRIORITY,NORM_PRIOPITY
14.在Java中，不能用static修饰顶级类,只有内部类可以为static。
15.只有成员变量才有默认值，而局部变量没有默认值，必须要赋初值。
16.Java中类是创建对象的模板。
17.Java中不同对象的实例变量将被分配不同的内存空间。
18.Java中布尔型常量不能自动转换为短整型常量。
10.当DataInputStream对象读到文件结束处，返回-1.