Java复习题

1. javac 命令的作用

• 将Java代码源文件编译成.class字节码文件

2. 2.java为什么可以跨平台；

• 首先编写Java源文件，通过Java编译器生成后缀为.class的字节码文件,这文件不和特定的操作系统相关，然后通过JVM解释执行.所以Java也叫解释型语言.Java跨平台的重点就在JVM上,由于.class字节码文件不和特定的操作系统相关需要解释执行.那么只要能解释执行.class文件就可以执行Java程序.所以曾经的SUN公司在不同的操作系统上开发出不同的JVM用于解释执行Java程序.以此实现Java 的跨平台.

3. 变量（标示符）的命名规则；

• 以字母下划线美元符号开头大小写敏感长度无限制
• 类名首字母大写，采用驼峰命名法
• 不得只用关键字

4. 基本数据类型有哪些（扩展：各类型的范围）；
   
5. 编写冒泡排序法；

/**
 * 冒泡排序
 *
 * ①. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
 * ②. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
 * ③. 针对所有的元素重复以上的步骤，除了最后一个。
 * ④. 持续每次对越来越少的元素重复上面的步骤①~③，直到没有任何一对数字需要比较。
 * @param arr  待排序数组
 */public static void bubbleSort(int[] arr){
 for (int i = arr.length; i > 0; i--) {      //外层循环移动游标
 for(int j = 0; j < i && (j+1) < i; j++){    //内层循环遍历游标及之后(或之前)的元素
 if(arr[j] > arr[j+1]){
 int temp = arr[j];
 arr[j] = arr[j+1];
 arr[j+1] = temp;
 System.out.println("Sorting: " + Arrays.toString(arr));
 }
 }
 }}

6. switch语句switch后面括号中的可以填写的数据类型有哪些；

• switch表达式后面的数据类型只能是byte,short，char，int四种整形类型，枚举类型和java.lang.String类型（从java 7才允许），不能是boolean类型。
• 试完Byte,Short,Character,Integer后发现都可以正确打印，于是便说switch也支持byte，short，char，int的包装类。这种说法不完全正确，之所以switch能够支持他们的包装类，是因为自动拆箱（从JDK1.5开始支持自动拆箱和自动装箱，自动拆箱就是自动将引用数据类型转化为基本数据类型，自动装箱就是自动将基本数据类型转化为引用数据类型）的原因

7. 需求：编写一个5分制的打分系统，5分为优、4分为良、3分为及格、其他为不及格（使用switch语句）；

public static void main(String[] args) {
        System.out.println("请输入打分");
        Scanner in = new Scanner(System.in);
        int a = in.nextInt();
        switch (a){
            case  5 :
                System.out.println("优");break;
            case  4 :
                System.out.println("良");break;
            case  3 :
                System.out.println("及格");break;

            default: System.out.println("不及格");
            }
			}

8. 需求：使用递归算法计算1到100相加之和。

public static int sum(int a){
        int sum = 0;
        if (a==1)
            return 1;
        else return a+sum(a-1);

    }

9. 数组的声明方式有哪几种，并举例说明，初始化方式有几种并举例说明；

		//第一种   例:
        String[] test1 = new String[6];
        test1[0] = "数组0";
        test1[1] = "数组1";
		 //第二种 例:
        String[] test2 = {"数组0","数组1","数组2","...."};
		//第三种 例:
        String[] test3 = new String[]{"数组0","数组1","数组2","...."};

10. 需求：找出一个int类型数组中的最大数、最小数、重复次数最多的任意一个数；

public static void FindEle(int n[]){
        Arrays.sort(n);
        int m = 0;
        // 保存结果map，n的元素为key，出现次数为value
        Map nums = new HashMap();
        // 首先中间数出现次数为0
        nums.put(m, 0);
    // 循环，当某个数已经在map里时，将次数加一
        for (int i = 0; i < n.length; i++) {
            if (m == n[i]) {
                int v = (Integer) nums.get(m);
                v++;
                nums.put(m, v);
            } else {
                nums.put(n[i], 1);
            }
            m = n[i];
        }
        // 遍历得到最多次数的数
        Iterator iterator = nums.keySet().iterator();
        int maxNumber = 0;
        int maxValue = 0;
        while (iterator.hasNext()) {
            int key = (Integer) iterator.next();
            int value = (Integer) nums.get(key);
            if (value > maxNumber) {
                maxNumber = value;
                maxValue = key;
            }
        }
        System.out.println("出现次数最多的数为：" + maxValue + ",出现次数为：" + maxNumber);
    }

11. 什么是对象，什么是类。

• 所谓对象就是真实世界中的实体，对象与实体是一一对应的，也就是说现实世界中每一个实体都是一个对象，它是一种具体的概念。
  类是具备某些共同特征的实体的集合，它是一种抽象的概念，用程序设计的语言来说，类是一种抽象的数据类型，它是对所具有相同特征实体的抽象。
  类与对象的关系：
  类是对象的集合，对象是类的实例;对象是通过new className产生的，用来调用类的方法;类的构造方法 .。
  用一个例子给你说明一下他们的关系：
  比如“人类”就是一个类，那么具体的某个人“张三”就是“人类”这个类的对象，而“名字、年龄”等信息就是对象的属性，人的动作比如“吃饭、穿衣”等就是对象的方法。总之类就是有相同特征的事物的集合，而对象就是类的一个具体实例。同时类有多态和继承，例如“人类”可以分为“男人、女人”，“老人、小孩”那么“男人、女人”就是“人类”的子类等等。一楼的说“轿车”是一个实例化，我觉得有点不妥，“轿车”应该是“车”的一个子类，例如“车牌号是***的轿车”才是一个对象。方法是被对象调用的比如“张三.穿衣（）”

12. java的面相对象你如何理解（请用自己理解的方式说明）；

• 面向过程：强调的是功能行为。（强调过程、动作）
  面向对象：将功能封装进对象，强调了具备了功能的对象。（强调对象、事物）
  面向对象是基于面向过程的。将复杂的事情变简单了。
  面向过程–>面向对象：执行者–>指挥者
  将过程、功能封装进对象里面。
  面向对象三大特征：封装、继承、多态。（找对象，建立对象，使用对象，维护对象的关系。）
  老者境界：（万物皆对象！！！）

13. 请逐一说明全局变量、局部变量、成员变量、实例变量、静态变量；

• 局部变量的定义：定义在方法中的变量都是局部变量(main方法也是方法，所以定义在main方法中的变量也是局部变量)。
  生存时间：局部变量的生存时间和方法的生存时间一致，调用该方法声明该局部变量并初始化的时，该局部变量被创建并分配内存空间；直到该方法调用结束局部变量也就结束了；
  是否需要初始化：局部变量在使用前必须进行初始化，系统默认不会对局部变量进行初始化数据操作，如果局部变量在使用前没有进行初始化则会在编译器报错；如果局部变量进行了声明没有进行初始化， 但是也一直没有被使用的话编译也是不会报错的；（局部变量使用前必须初始化话）
  创建位置： 局部变量是创建在栈内存中的；
• 2.1 非静态全局变量：

非静态全局变量的定义：非静态全局变量都是定在类中，是类的成员变量或者说是成员属性属于类的一部分（或 者说是对象的一部分）；
生存时间：非静态全局变量加载在堆内存中，随着声明初始化而创建，随着对象消亡而消亡；
是否需要初始化：全局变量都是不需要被强制初始化的，系统都会默认根据其数据类型进行默认赋值；但是建议 在声明时都进行初始化操作；
创建位置：创建在堆内存中，因为非静态的全局变量数对象的成员变量是对象的一部分；

2.2静态全局变量：

静态全局变量的定义：静态的类成员变量；
生存时间：静态全局变量随着类的字节码文件加载而加载产生，随着字节码文件的消失而消失，生存时间比类的 对象还要长；
是否初始化：凡是全局变量都是可以不要初始化的，静态变量也是一样，系统会自动根据其数据类型进行赋默认值，但是建议变量在声明时都进行初始化；
创建位置：静态变量时存在于对内存中的，所以静态全局变量也是存在于堆内存中的。

• 实例变量声明在一个类中，但在方法、构造方法和语句块之外；
  当一个对象被实例化之后，每个实例变量的值就跟着确定；
  实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
  实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
  实例变量可以声明在使用前或者使用后；
  访问修饰符可以修饰实例变量；
  实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
  实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。

14. 面相对象的三大特征是什么，逐一进行解释并举例说明；

• 继承：
  子类继承父类，继承了父类的所有属性和方法(包含私有的)，私有的不能直接访问；
  一个类如果没有使用 extends，那么它将继承 Object 类，Object 类是所有类的父类，始祖类；
  一个类可以继承多个类，但 java 中规定一个类只能直接继承一个类；可以间接继承；
  子类具有扩展的功能，扩展子类特有的属性和方法；
  继承大大提供了代码的重复利用性；
• 封装是对象的一种隐藏技术，其目的是将对象中的属性和方法组织起来。同时隐藏不想暴露的属性和方法及实现细节。
  用户或其它对象不能看到也无法修改其实现。只能通过接口去调用对象的方法，达到互相通信的目的。
  封闭的目的在于将设计者与使用者分开。使用者不必知道实现的细节，只需用设计者提供的方法来访问该对象。
• 多态：
  面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。
  多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是函数调用）
  实现多态的技术称为：动态绑定（dynamic binding），是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
  多态的作用：消除类型之间的耦合关系。
  现实中，关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

15. 接口和抽象类的区别；

• 抽象类和接口都不能直接实例化，如果要实例化，只能通过子类进行实例化。
• 抽象类要被子类继承，接口要被类实现。
• 接口所有的方法都是抽象方法，抽象类中可以可以有抽象方法也可以有实例方法。
• 接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
• 抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，
  一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
• 抽象方法只能声明，不能实现，接口是设计的结果 ，抽象类是重构的结果
• 抽象类里可以没有抽象方法
• 抽象方法要被实现，所以不能是静态的，也不能是私有的。
• 接口可继承接口，并可多实现接口，但抽象类只能单根继承。

16. 什么是构造方法，说明其特征及作用，什么是构造函数重载；

• 构造方法：创建类时用来初始化类的属性
• 构造函数重载：构造函数参数列表不同

17. 什么是方法重写，什么是方法重载；

• 重写：子类继承父类时重写父类的方法
• 重载：函数名相同，参数列表不同

18. 参数的传递：说明基本数据类型的传递和引用数据类型传递

• Java中没有指针，没有引用传递了，仅仅有值传递。但是可以通过对象的方式来实现引用传递 类似java没有多继承 但可以用多次implements 接口实现多继承的功能。

19. 内部类：编写局部内部类、静态内部类、匿名内部类

/**
a) 普通内部类可以访问外部类的所有属性和方法，包含私有的直接访问；
b) 普通内部类中不能有静态变量和静态方法；
c) 要想创建内部类的对象，需要通过创建外部类的对象来进行创建；
d) 外部类中可以通过创建内部类的对象来访问内部类中的属性和方法；
*/
public class Outer {
private String name = "jack";
public static int AGE = 20;
public void tell() {
System.out.println("Outer is tell");
}
class Inner {
public void say() {
System.out.println(name);
System.out.println(AGE);
tell();
} } }
public class Test {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();//通过外部类的对象创建内部类的对象
oi.say();
} }
/**
局部内部类；
如果在程序中只使用一个类一次，可以在一个方法里定义局部类
在方法中定义的内部类称为局部内部类。
与局部变量类似，在局部内部类前不加修饰符 public 和 private，其范围为定义它的代码块。
内部类中使用外部方法中的局部变量，该局部变量必须是最终的(final)
*/
public class Outer {
private String name = "jack";
static int COUNT = 100;
public void say() {
final String addr = "南京";
class Inner {
public void tell() {
System.out.println(name);
System.out.println(COUNT);
System.out.println(addr);//必须是最终的
} }
Inner in = new Inner();
in.tell();
} }
public class Test {
public static void main(String[] args) {
Outer out = new Outer();
out.say();
}
}
/**
静态内部类定义在类中，任何方法外，用 static 定义。
静态内部类只能访问外部类的静态成员。
生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接
生成： Outer.Inner in=new Outer.Inner()；
而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。
静态内部类不可用 private 来进行定义
*/
public class Outer {
private String name = "jack";
private static int COUNT = 100;
public static class Inner {
public static void say() {
//System.out.println(name);//只能直接访问外部静态变量和方法
System.out.println(COUNT);
}
public void tell() {
//System.out.println(name);//只能直接访问外部静态变量和方法
System.out.println(COUNT);
} } }
public class Test {
public static void main(String[] args) {
Outer.Inner.say();//可以直接访问内部类的静态变量和方法
Outer.Inner oi = new Outer.Inner();//和普通内部类的区别，可以直接创建内部类对象
oi.tell();//成员方法需要通过对象类访问
} }
/**
如果你只需要建立一个内部类的对象，那么甚至不必为该类指定一个名字。我们把这种类称作匿名内部类。
匿名类是特殊内部类，没有名字。
匿名内部类是唯一一种无构造方法类。
因匿名内部类无构造方法，所以其使用范围非常的有限。
内部类中使用外部方法中的局部变量，该局部变量必须是最终的(final)
*/
public class Outer {
public void say(){
System.out.println("Outer is say");
} }
public class Test {
public static void main(String[] args) {
final String name = "jack";
Outer out = new Outer() {
@Override
public void say() {
System.out.println("Inner is say");
System.out.println(name);//name必须是最终的
}
};
out.say();//必须是重写外部类的方法，通过调用外部类的方法，调用内部类的方法
} }

20. 最终类的特征；

• 有final修饰，不可派生子类

21. final 和finally 的区别；

• final关键字可以用于类，方法，变量前，用来表示该关键字修饰的类，方法，变量具有不可变的特性。
  （1）final关键字用于基本数据类型前：这时表明该关键字修饰的变量是一个常量，在定义后该变量的值就不能被修改。
  （2）final关键字用于方法声明前：这时意味着该方法时最终方法，只能被调用，不能被覆盖，但是可以被重载。
  （3）final关键字用于类名前：此时该类被称为最终类，该类不能被其他类继承。
• 当代码抛出一个异常时，就会终止方法中剩余代码的处理，并退出这个方法的执行。假如我们打开了一个文件，但在处理文件过程中发生异常，这时文件还没有被关闭，此时就会产生资源回收问题。对此，java提供了一种好的解决方案，那就是finally子句，finally子句中的语句是一定会被执行的，所以我们只要把前面说的文件关闭的语句放在finally子句中无论在读写文件中是否遇到异常退出，文件关闭语句都会执行，保证了资源的合理回收。

22. 请说明访问控制符有哪些，并说明他的作用域（可访问性）；
    
23. static关键字的解释和说明；

• 修饰成员变量
• 修饰成员方法
• 静态代码块

24. 什么是异常？异常的种类？异常的处理机制？

• 运行程序发生错误
• 检查异常和运行时异常
• try catch 和 throws

25. 区分运行时异常和检查异常的区别？

• 除了RuntimeException与其子类，以及错误（Error），其他的都是检查异常（绝对的大家族）
• 运行异常一层层向外抛出，或者交由代码块处理

26. throw和throws的区别？

• throw是语句抛出一个异常，throw (异常对象);
• throws是方法可能抛出异常的声明， public void doA(int a) throws Exception1,Exception3{…}

27. String和StringBuffer的区别？

• 白皮书

28. 需求：编写一个5位数的验证码，要求5个数字不能一样；

public static void YanZheng(){

        String str = "ABCDEFGHIJKLMNOPQRSJUVWXYZ";
        str.toLowerCase();
        String str1 = "0123456789";
        str = str + str.toLowerCase();
        str += str1;
        System.out.println(str);

        //2.生成字符中的随机一个数
        /*int R = new Random().nextInt(str.length());
        System.out.println(str.charAt(R));
        System.out.println("-----------");*/
        //3.进行5次循环
        StringBuilder sb = new StringBuilder(5);
        for(int i = 0; i < 5; i++){
            int R = new Random().nextInt(str.length());
            char ch = str.charAt(R);//获取位置
            System.out.println(str.charAt(R));
            sb.append(ch);
        }
        System.out.println("-----------------");
        System.out.println(sb);

    }

29. 说明javabean的特征；(User类：userName,password,phone,address)

• javaBean必须是一个public的类

• JavaBean有一个不带参数的构造函数，如果public类的构造函数包含参数的话，那这个类不能做为JavaBean

• JavaBean通过 getProperty获取属性，通过setProperty设置属性

30. 请说明你知道的集合有哪些？并逐一说明他们的特性和区别？（list set map分别有哪些说明他的特征）

31. collection和collections的区别；

• Collection是集合类的上级接口，继承与他有关的接口主要有List和Set

• Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全等操作

32. 线程的概念？创建线程的方法？线程的生命周期？

33. Thread 和Runable的区别？
    实现Runnable接口比继承Thread类所具有的优势：

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

• 可以避免java中的单继承的限制

• 增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

35. 编程：请使用线程循环打印出A B A B A B。。。。
    代码