java复习

Java基础

1.1. Java对象、类、全局变量、局部变量

     一个类new一个对象，new一个对象相当于调用这个类的构造方法。一个类创造一个对象，通过这个对象可以调用该类的方法和成员变量。

     全局变量在整个类里面都可以被使用，局部变量只能在定义的方法里面使用，出了这个方法之后这个变量就不被认可。

1.2. 继承、多态

继承：继承的目的：代码重复使用。通过继承，子类可以使用父类的方法，重写父类方法。
多态：必须有继承、重写。

父类引用指向子类对象。使用多态的好处是，当你想改变子类时候，只需要修改父类new的对象即可，其调用的方法没有改变。。。。。不是太明白！！！

注意!!!

当父类new一个子类对象时候，调用的是子类重写父类的方法，子类私有方法无法访问。称之为父类引用指向子类对象。

当new一个子类对象的时候，调用的是子类的方法，以及私有方法。

1.3. 重写、重载

Ø  Overwrite：子类方法名以及返回值和父类相同，方法实现的内容不同。

Ø  Override：同一个类中可以出现多个名称相同的方法，但这些方法参数和返回类型不同。好处：调用一个方法根据参数不一样，分别调用对应的方法，使得调用更加灵活。比如：传入Integer类型的参数、传入Double类型的参数等等。

1.4. 集合（collection接口【list、set】、Map)

ü  在UML图中，子类继承父类需要使用实心的线表示，子类实现接口类需要用虚线表示。

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│└Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap

Collection 是最基本的集合接口，一个Collection代表一组 Object，即 Collection

的元素（Elements）

Map 提供 key到 value 的映射

List继承collection接口，继承其iterator方法，常用的有Arraylist、linkedList，其中ArrayLists存储形式是数组，因此其读取数据非常便捷，但是其增加删除数据需要移动大量的数据，所以说其增加删除数据不便捷。

LinkedList数据存储形式是链表形式，链表增加删除数据只需要改变指针的指向即可完成，所以增加删除数据方便。链表查询时候需要从头遍历，因此查询速度比较慢。

Map:

HashMap:数据存储方式是键值对形式存储的。当要在map里面添加数据时候，首先需要根据数据查询到其存储的hashcode值，然后将数据存储在hashCode编码对应的位置上面。Map和Set不能存储的数据不能重复。List数据可以重复。Map运行一个值是空。

Map有四种遍历方式：

Map map= new HashMap（）；

   Iterator it = map.entrySet.Iterator();

   While(it.hasNext) {

        Set en = It.next();

   }//有点忘记set如何遍历了。。。

Map map= new HashMap（）；

   Entry entry =Map.Entry<String,Integer>;

   Iterator it = entry .Iterator();

   While(it.hasNext) {

        Entry en = It.next();

       String key = en.getKey();

       Integer value = en.getValue();

   }

Map map= new HashMap（）；

   For(Map m : map) {

m.......

   }

Hashtable是怎么实现线程安全的？

集合常用方法：

1）集合 List的遍历方法有：

Ø  Iterator、 Enumeration、For、Get、set

2）Collection的通用方法有：

Ø  Iterator()、Add()、Clear()、remove()

3）ArrayList、Vector、LinkedList的存储性能和特性HashMap和Hashtable的区别？

Ø  ArrayListVector:以数组的方式存储，增、删慢，查、改快

Ø  ArrayList:线程不安全，速度快

Ø  Vector:线程安全，速度慢(synchoronized)

Ø  LikedList:以单链表的方式存储，增、删快，查、改慢

Ø  HashMap与 Hashtable都实现Map 接口,HashTable 线程安全，HashMap 线程不安全。

4）Collection和Collections的区别？

Ø  Collection是集合的根接口，其下有set及 list。

Ø  Collections是集合的算法。

5）Set里的元素是不能重复的，那么用什么方法来区分重复与否呢?是用==还是equals()它们有何区别?用contains来区分是否有重复的对象？还是都不用？

Ø  在比较时先调用 hashCode方法，如果不相同，证明不相等。

Ø  如果相同，再调用equals方法，如果 equals方法相同，证明相等，不相同，证明不相等。

Ø  ==:主要用在基本数据类型及引用

Ø  Equals:主要是对象或对象引用的比较。

Ø  Contains：集合中是否包含某一个元素用 contains来判断。

6）线程同步的方法？

         Hashtable的put、remove、get

         Vector的相关方法。

1.5. 内存解析

内存分为三大块：栈、堆、数据区。

New出的对象存储在堆内存。

局部变量以及基本数据类型数据存放在栈内存。

静态变量存放在数据区。

1.6. 抽象类、接口、final

Ø  抽象类可以定义实现的方法，接口只能定义不能实现的方法；

Ø  抽象类只能被继承，子类可以实现多个接口；

Ø  抽象类成员变量可以有private、protected类型，接口只能是public abstract类型；

Ø  final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？是引用不能变。

Ø  抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。

Ø  抽象类可以有构造方法；接口没有构造方法；

Ø  抽象类可以有普通成员变量；接口只能有抽象成员变量（public finalint a = 0;)；

Ø  抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

Ø  抽象类中可以包含静态方法；接口中不能包含；

Ø  抽象类和接口都可以包含静态成员变量，但是接口修饰的成员变量修饰符为public staticfinal类型，抽象类中静态成员变量访问类型为任意的。

Ø  抽象类的方法可以是static的，因为它需要被子类继承实现；

1)Final有什么用处？？？

         方法不可以overriding

类不能被继承

         2)final、finally、finalize区别？

                   final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继

承。

finally 是异常处理语句结构的一部分，表示总是执行。

finalize 是Object 类的一个方法， 在垃圾收集器执行的时候会调用被回收对象的

此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

1.7. 多线程、进程和线程区别、线程池？？？

进程：程序执行通道。一个程序默认有一个主线程也就是main（）。进程分配的有资源，进程无资源，多个线程共享进程的资源。一个线程就是一个执行通道。多线程的好处：可以同时执行多个任务相互不干扰。多线程坏处：容易造成资源不同步，死锁。

Java有几种方法实现线程：继承Thread类；实现Runnable接口、线程池实现多线程。

线程：进程内的并发，没有自己内存空间，共享进程的，线程间的通信成本较低。

Java中的线程四种状态：运行、就绪、挂起、结束。

同步的实现方式：synchronized和wait、notify

1.7.1.Stop（）和suspend（）为什么不推荐使用？

Suspend（）方法使用会导致占用资源，容易引起死锁。调用suspend（）的时候目标线程会停下来，但会仍然持有在这之前拥有的锁定。此时其他任何线程都不能访问锁定的资源，除非被挂起的线程恢复运行。                 

Stop（）不安全，因为它会解除由线程获取的所有锁定。

 

1.7.2.Sleep（）和wait()区别？

Sleep（）是休眠给定的时间，当这个时间达到之后，线程会再次醒来。

Wait（）是等待时间，等待多久不清楚，等待另外一个线程把它唤醒。

1.8. IO

IO流：字节流、字符流

字节流：按字节为单位的输入输出流。InputStream、OutPutStream

字符流：按字符为单位的输入输出流。Reader、Writer

1.9. Arrays

Arrays是集合的公共方法

Arrays.fills()方法是给指定集合填充值；

Arrays.equals()方法比较两个数组是否相同；

Arrays.sort()对数组进行排序；

Arrays.toString()将数组转换成String类型表示；

1.10.  Java反射机制，包以及核心类

通过类(Class 对象)，可以得出当前类的 fields、method、construtor、interface 、

superClass、modified 等，同是可以通过类实例化一个实例、设置属性、唤醒方法。

Spring 中一切都是反射、struts、hibernate 都是通过类的反射进行开发的。

                 java.lang.Class

                 java.lang.refrection.Method

                 java.lang.refrection.Field

                 java.lang.refrection.Constructor

                   java.lang.refrection.Modifier

                 java.lang.refrection.Interface

         1）得到class的过程：

         对象.getClass()

类.class 或Integer.type(int) Integer.class(java.lang.Integer)

Class.forName();

1）如何唤起类中的一个方法？

产生一个 Class 数组，说明方法的参数

通过 Class 对象及方法参数得到Method

通过method.invoke(实例,参数值数组)唤醒方法

1.11.  Java垃圾回收机制&java事件委托机制

Java垃圾回收机制，Java内部通过一个对象计数器，实现对Java对象的内存会收管理，当一个对象的计数器为0时候，则此对象为Java垃圾回收的对象。垃圾回收调用Gc（）就立即回收，而是在一定的时候才会自动回收。

java 事件委托机制的概念,一个源产生一个事件并将它送到一个或多个监听器那里。 在

这种方案中，监听器简单的等待，直到它收到一个事件。一旦事件被接受，监听器将处

理这个事件，然后返回。

1.12.  Java的值传递、引用传递

1.13.  "=="和equals方法究竟有什么区别？

比较变量所对应的内存中所存储的数值是否相同；

equals方法是用于比较两个独立对象的内容是否相同；

1.14.  静态变量和实例变量的区别？

静态变量：变量前加static修饰

实例变量：不加修饰；

静态变量是属于类的变量，程序启动时，就已经给静态变量分配内存，并且程序里面只能有一个名字相同的静态变量。而实例变量是属于对象的某个属性，需要创建实例对象，这个时候才会分配内存，同一个名字的实例对象可以创造多次，并且分配多个内存。

Eg:

public classStaticTest {

Public static int varStatic;

Public int var;

Public StaticTest() {

varStatic++;

Var++;

}

}

该例子中，每次创建一个对象的时候，实例变量都创建一次，并且分配内存，且每次添加的1是对应的每次创建的新的实例对象添加的。而静态变量是程序加载的时候已经分配内存，创建对象的时候，对静态变量的操作的自加1.

1.15.  是否可以从static方法内部调用另外一个非static方法？为什么？

Ø  非static方法和对象是相关联的，只能通过对象调用此类方法；

Ø  Static方法调用时候不需要创建对象可以直接调用；

1.16.  Integer和int的区别

Ø  Int属于基本类型

Ø  Java为基本原始类型提供了封装类，Integer就是int基本类型的封装类

Ø  Int默认值为0；Integer默认类型为null；

Ø  Integer可以区分未赋值和赋值为0的情况；int不能区分

Ø  Integer 是封装类，具有方法及属性。与其同类的有 Long,Double.Float

Ø  Int 是基本数据类型，不是对象，占一个内存空间，没有方法。与其同类的有

long,char,doble

Integer那么强大，为什么还要用int呢？？？

基本数据类型：int、char、double、float、Boolean、short、byte、long

1.17.  作用域public，private，protected，以及不写时的区别

作用域    当前类同一package子孙类其他package

public    √    √         √      √

protected  √    √         √     ×

friendly   √    √         ×     ×

private    √    ×         ×     ×

1.18.  构造器Constructor是否可被override?

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

构造器是什么？？？构造器就是构造方法。

1.19.  Clone？为什么要用clone方法？Clone方法有什么作用？

1.20.  面向对象特征

封装、抽象、继承、多态

Ø  封装是保证软件部件具有优良的模块性的基础，封装的目标就是要实现软件部件的“高内聚、低耦合”；对象是封装的基本单位；面向对象的封装就是把描述一个对象的属性和行为的代码封装在一个“模块”中，也就是一个类中，属性用变量定义，行为用方法进行定义，方法可以直接访问同一个对象中的属性。

Ø  抽象就是找出一些事物的相似和共性之处，然后将这些事物归为一个类，这个类只考虑这些事物的相似和共性之处，并且会忽略与当前主题和目标无关的那些方面，将注意力集中在与当前目标有关的方面。

Ø  继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

Ø  在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

1.21.  什么是内部类？内部类的作用？StaticNested Class?

Ø  内部类是在一个类的内部定义的类，内部类中不能定义静态变量（因为把静态变量定义在内部类里面没有任何意义），内部类可以直接访问外部类的成员变量，内部类可以放在外部类的里面，也可以放在外部类的外面。

Ø  内部类在外部类的外面的时候，如果要创建内部类的实例对象，需要先创建外部类的实例对象，然后使用外部类的实例对象去创建内部类的实例对象。

Ø  在方法内部定义的内部类前面不能有访问类型修饰符，就好像方法中定义的局部变量一样，但这种内部类的前面可以使用final或abstract修饰符。

 

1.22.  String和StringBuffer、Stringbuilder区别？

Ø  String是不可变对象，final类型的

Ø  StringBuffer是可变的，每次操作的字符串不需要重新创建一个对象。

Ø  java.lang.String 类是 final 类型的，因此不可以继承这个类、不能修改这个类。为

了提高效率节省空间，我们应该用 StringBuffer 类

1.23.  error和exception有什么区别?

Ø  error表示运行时程序出现错误，无法挽回，比如说：内存泄露。

Ø  Exception表示程序设计出现的异常，需要抛出异常

Ø  运行时代码异常需要捕捉异常，try{}catch{}必须捕捉的异常。

Ø  调用方法抛出的异常，在方法上直接throws，因此不需要捕捉异常。

Ø  异常是指java程序运行时（非编译）所发生的非正常情况或错误

什么是异常？异常分类？不同的分类怎么处理异常？

n  Try:执行部分，产生异常

n  Catch:捕捉异常

n  Finally:不管有没有异常都执行

n  Throws:在方法声明处声明要抛出的异常，调用者必须对其进行处理。

n  Throw:抛出一个异常

n  在 try中可以抛出异常，一般与声明的异常相同。

n  自定义异常要继承于 Exception或 Exception的子类

1.23.1. Java中的异常处理机制的简单原理和应用。

异常是指java程序运行时（非编译）所发生的非正常情况或错误。

Java使用面向对象的方式来处理异常，它把程序中发生的每个异常也都分别封装到一个对象来表示的，该对象中包含有异常的信息。

Java对异常进行了分类，不同类型的异常分别用不同的Java类表示，所有异常的根类为java.lang.Throwable，Throwable下面又派生了两个子类：Error和Exception，Error表示应用程序本身无法克服和恢复的一种严重问题，程序只有死的份了，例如，说内存溢出和线程死锁等系统问题。Exception表示程序还能够克服和恢复的问题，其中又分为系统异常和普通异常，系统异常是软件本身缺陷所导致的问题，也就是软件开发人员考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但在这种问题下还可以让软件系统继续运行或者让软件死掉，例如，数组越界（ArrayIndexOutOfBoundsException），空指针异常（NullPointerException）、类转换异常（ClassCastException）；普通异常是运行环境的变化或异常所导致的问题，是用户能够克服的问题，例如，网络断线，硬盘空间不够，发生这样的异常后，程序不应该死掉。

java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常，而系统异常可以处理也可以不处理，所以，编译器不强制用try..catch处理或用throws声明，所以系统异常也称为unchecked异常。

提示答题者：就按照三个级别去思考：虚拟机必须宕机的错误，程序可以死掉

1.23.2.   运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

查看jdk文档。。。运行时异常的类都有什么？一般异常类有什么？

1.24.   内存泄露

Java中会出现内存泄露。如：int i,i2; return (i-i2); //when i 为足够大的正数,i2 为足够大的负数 。结果会造成溢位，导致错误。

1.25.  Super（）和this（）

1)        This（）：当前类的对象,super父类对象。

2)        Super（）：在子类访问父类的成员和行为,必须受类继承规则的约束，而 this 代表当前对象,当然所有的资源都可以访问.

3)        在构造函数中,如果第一行没有写super(),编译器会自动插入.但是如果父类没有不带参数的构造函数,或这个函数被私有化了(用 private 修饰).此时你必须加入对父类的实例化构造。什么意思呢？而 this就没有这个要求,因为它本身就进行实例化的构造.

1.26.  Java中如何跳出嵌套的多层循环？

Return、break方法。

1.27.  什么是java序列化？java序列化怎么实现？java序列化的作用？

序列化:

可以将一个对象保存到一个文件，所以可以通过流的方式在网络上传输，可以将文件的内容读取，转化为一个对象。

处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流

进行读写操作时所引发的问题。

序列化的实现：

将需要被序列化的类实现 Serializable接口，该接口没有需要实现的方法，

implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：FileOutputStream)来构造一个 ObjectOutputStream(对象流)对象，接着，使用ObjectOutputStream对象的 writeObject(Object obj)方法就可以将参数为 obj的对象写出(即保存其状态)，要恢复的话则用输入流。

importjava.io.*;

public class Catimplements Serializable {

        privateString name;

        publicCat () {

                this.name= "new cat";

        }

        publicString getName() {

                returnthis.name;

        }

        publicvoid setName(String name) {

                this.name= name;

        }

        publicstatic void main(String[] args){         

                Catcat = new Cat();

                try{

                        FileOutputStreamfos = new FileOutputStream("catDemo.out");

                        ObjectOutputStreamoos = new ObjectOutputStream(fos);

                        System.out.println("1> " + cat.getName());

                        cat.setName("MyCat");                       

                        oos.writeObject(cat);

                        oos.close();                       

                }catch (Exception ex) {  ex.printStackTrace();   }

                try{

                        FileInputStream fis= new FileInputStream("catDemo.out");

                        ObjectInputStreamois = new ObjectInputStream(fis);

                        cat = (Cat)ois.readObject();

                        System.out.println("2> " + cat.getName());

                        ois.close();

                }catch (Exception ex) {

                        ex.printStackTrace();

                }

        }

}//writeObject和readObject本身就是线程安全的，传输过程中是不允许被并发访问的。所以对象能一个一个接连不断的传过来

 

1.28.  内部类的实现方式？内部类有什么作用？？？

packagetestJava.super_this;

 

publicclass OuterClass {

      private class InterClass {

             public InterClass() {

                    System.out.println("InterClassCreate");

             }

      }

 

      public OuterClass() {

             InterClass ic = new InterClass();

             System.out.println("OuterClassCreate");

      }

 

      public static void main(String[] args) {

             OuterClass oc = new OuterClass();

      }

}

 

1.29.  在collection框架中，比较实现的comparable接口和comparator接口区别？

1.30.  如何将数字转换成字符？

1+“”

1.1+“”

 

1）如何去小数点前两位，并四舍五入。

double d=1256.22d;

d=d/100;

System.out.println(Math.round(d)*100);

 

2）如何取得年月日，小时分秒？

Calendar c=Calendar.getInstance();

c.set(Calendar.YEAR,2004);

c.set(Calendar.MONTH,0);

c.set(Calendar.DAY_OF_MONTH,31);

System.out.println(c.get(Calendar.YEAR)+"

"+(c.get(Calendar.MONTH)+1)+""+c.get(Calendar.DAY_OF_MONTH));

 

3）如何取得从  1970年到现在的毫秒数

Java.util.Date dat=new Date();

long now=dat.getTime();

 

4）如何获取某个日期是当月的最后一天？

当前日期加一天，若当前日期与结果的月份不相同，就是最后一天。

取下一个月的第一天，下一个月的第一天-1

public static void main(String[] args) {

              Calendarc=Calendar.getInstance();

              c.set(Calendar.YEAR,2004);

              c.set(Calendar.MONTH,0);

              c.set(Calendar.DAY_OF_MONTH,30);

              Calendarc1=(Calendar)c.clone();

              System.out.println(c.get(Calendar.YEAR)+""+(c.get(Calendar.MONTH)+1)+""+c.get(Calendar.DAY_OF_MONTH));

                            c.add(Calendar.DAY_OF_MONTH,1);

              if(c.get(Calendar.MONTH)!=c1.get(Calendar.MONTH)){

                     System.out.println("是最后一天");

              } else {

                     System.out.println("不是取后一天");

              }

       }

 

5）如何格式化日期？

Importjava.text. SimpleDateFormat;

SimpleDateFormatsdf=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

Datedat=new Date();

//把日期转化为字符串

Stringstr=sdf.format(dat);

System.out.println(str);

//将字符串转化为日期

Java.util.Date d1=sdf.parse(“yyyy-mm-dd”);

 

1.31.  常用的类，包，接口，请各举 5个

常用的类： BufferedReader BufferedWriter FileReader FileWirterString

Integer

常用的包： java.lang java.awt java.io java.util java.sql javax.xml

javax.sevletjavax.ejb. java.net javax.faces

常用的接口： List Map Document NodeList EjbObjectEjbHome SessionBean、EntityBean

 

1.32.   & 和 && 的区别？

&:与 :左边若为 false右边还执行。

&&:短路与：左边若为false右边不执行。

1.33.  heap 和和  stack有什么区别？

1.34.  assert是什么？什么时候用到？

assertion (断言)在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。在实现中，assertion就是在程序中的一条语句，它对一个 boolean表达式进行检查，一个正确程序必须保证这个 boolean表达式的值为 true；如果该值为 false，说明程序已经处于不正确的状态下，系统将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。assertion检查通常在开发和测试时开启。为了提高性能，在软件发布后，assertion检查通常是关闭的。

 

1.35.   switch是否能作用在byte/long/String上?

switch（expr1）中，expr1是一个整数表达式。因此传递给 switch和 case 语句的

参数应该是int、short、char或者byte。long,string都不能作用于switch。

 

1.36.  写一个singleton例子。

package javaSingleTon;

/**

 * 单例模式：保证在该类中，只能实例化一个对象。

 * @author 2萌

 *

 */

方法一：

public class Singleton {

         /**

          * 第一种：创建一个类，其构造函数为private的，它有一个static的private的静态变量，在类初始化的时候实例化。

          * 通过getInstance()方法获取对该变量的引用，以此提供给外部对其的调用。

          */

private Singleton() {

         }

        

         private static Singleton instance = new Singleton();

        

         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;

         }

}