当前位置：搜档网 › java程序员面试宝典(刘磊版)笔记

java程序员面试宝典(刘磊版)笔记

java程序员面试宝典（刘磊版）笔记 1：JDK与JRE

JDK:JA V A Development Kit, java开发工具包? 包括各种类库和工具，当然也包括JRE JRE：JA V A Runtime Environment，java程序运行环境，包括JA V A类库的class文件和JVM

2：JA V A_HOME PATH CLASSPATH

JA V A_HOME ：JDK的安装目录，很多web服务器如tomcat没有内置JDK，它们通过JA V A_HOME找到JDK PA TH：在原有值后加“?%JA V A_HOME%\bin”?通过配置PA TH,可以再任何命令提示符窗口中使用JA V AC、JA V A等命令了CLASSPA TH：用来指定JA V A程序搜索类的路径的，JA V A程序在编译和运行时，先搜索jre/lib/rt.jar中的类，然后搜索CLASSPA TH中指定的类；一般CLASSPA TH会包括当前目录“.”

3：JA V A程序动态的指定类搜索路径方法

利用-cp或-classpath选项，如 javac –cp D:\wrok\log4j.jar Hello.java (编译时指定D:\wrok\log4j.jar为搜索路径) java –cp D:\wrok\log4j.jar Hello

4：JA V A和C++程序在编译及运行上的区别

C，C++这类语言的编译器（例如 UNIX下的CC命令，WINDOWS下的CL命令）都是把源代码直接编译成计算机可以认识的机器码，如EXE、DLL之类的文件，然后直接运行。 JA V A为了实现跨平台，多了一个中间步骤，就是先生成字节码文件，javac命令先把源文件编译成计算机无法直接识别的class文件，但是它可以被JVM所认识，JVM有多个平台版本，因此可以在多个平台执行。

5：什么是JVM及其工作原理

JVM是一个想象中的机器，在实际的计算机上通过软件模拟来实现。Java虚拟机有自己想象中的硬件，如处理器、堆栈、寄存器，还有相应的指令系统。JVM在执行字节码时，把字节码解释成具体平台上的机器指令执行。

6：JA V A垃圾回收机制

JVM中栈存放的是非static的自动变量、函数参数、表达式的临时结果和函数返回值。栈中这些实体数据的分配和释放均是由系统自动完成的。堆中存放的实体数据是程序员显示分配的（new）,没有自动垃圾回收机制的系统中（有些JVM没有垃圾回收机制）必须显示的释放这些实体 C、C++中也有栈和堆，对堆的管理，C是通过malloc()和free()；而C++是通过new和delete Object对象中有个finalize()，它会在对象被回收之前被调用； System.gc()?和Runtime.getRunime().gc()两个方法都可以显示请求开始垃圾回收线程

7：jar和war

两者都是java可执行文件，jar是对于桌面应用程序，war是对于web应用程序； Jar和war打包都通过JDK的jar命令

8：JA V A变量及作用范围

分为：静态变量、成员变量、局部变量静态变量在类中用static修饰，生存周期由类决定；成员变量是类中没有用static修饰的变量，生存周期有对象来决定；局部变量是定义在方法里的变量、方法的参数、代码块里的变量，它们的作用范围用大括号{}来界定

9：JA V A变量分为哪两种大的数据类型

基本数据类型和引用数据类型，它们最大的区别在于引用数据类型存放的是数据所在的地址，而基本数据类型直接存放数据的值；二者都保存在栈中

10：装箱、拆箱指的是基本基本数据类型和包装类型的自动相互转化 11：C++指针和JA V A引用的区别

相同：都是指向一块内存地址不同：一类型转换：引用的类型转换，可能抛出https://www.sodocs.net/doc/8e6881965.html,ng.ClassCastException,引用对应的类型不同的话，转换不成功；C++指针则一定能转换成功，指向哪儿，还是一个地址二初始值：引用类型的初始值为null；C++指针是int，如不初始化，值是随机的三计算：引用不可计算；指针可计算，如++或— 四内存泄露：JA V A引用基本不会产生内存泄露；指针容易，程序员须及时回收五作为参数：JA V A方法本质上只有传值，引用作为参数使用时，回给函数内引用的COPY，所以在函数内交换两个引用参数是没意义的，但改变一个引用参数的属性是有意义的，因为引用参数的COPY所引用的对象和引用参数是同一个对象； C++指针作为参数，实际上就是它所指的地址在函数中被操作。

12：equals()和==

==运用在基本数据类型是比较的是实际的值；用于比较引用类型时候，比较两个引用的地址是否相同；（都是比较栈中数据） Object有equals()方法,默认的比较方式与==相同，String类重写了该方法，使其能比较字符串的内容；

13：JA V A三元运算符表达式1？表达式2：表达式3 表达式1为true则执行表达式2 ；否则执行表达式3

14：Java注释类型 ①行注释 // ②块注释 /* ….. */ ③文档注释 /** …. */ ④Annotation

15:类与对象类是一种抽象，JVM对类只加载一次对象是类的实现，通过new创建，可以创建多个对象；

面向对象特性：封装、继承、多态

16：什么是多态

本质是可发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用赋值给超类对象引用变量（向上转型）来实现动态方法调用

17：java中静态成员的特点

类的静态成员是通过static修饰的成员，主要有：静态成员变量、静态方法、静态代码块；它们具有如下特点： ①在类加载的时候，就进行创建、初始化或执行代码 ② 对于一个类来说，都只有一份 ③ 类的所有实例都能访问到它们

18：子类调用父类的构造函数 super([args])必须放在子类构造函数的第一行

19：抽象类和接口的区别

① 接口中的方法都是抽象方法，不必写abstract ② 接口中的属性为static final 静态不可修改的常量 ③ 最大区别是一个类可以实现多个接口，但只能继承一个抽象类 ④ 抽象类中可以有非抽象方法面向功能用接口，面向继承用抽象类；如果属性得继承用抽象类；

20：内部类成员式：静态内部类和成员内部类局部式：普通局部内部类和匿名内部类

① 静态内部类：相当于外部类的静态成员一样，用static修饰，外部类加载时内部类也随之加载，完整类名是abc.Outter.Inner?无法访问外部类的非静态成员 ② 成员内部类：相当于外部类的普通成员一样，没有用static修饰，需等外部类创建了对象以后才会被加载到JVM中；创建成员内部类方法： Outter o = new Outter()? Outter.Inner I = o.new Inner()? ③ 局部内部类：定义在一个方法体中，它往往仅作为方法短暂的使用，只能访问用final 修饰的局部变量 ④ 匿名内部类：也定义在方法体中，但没有一个具体的名字如： Public void adc(){ new OneInterface() {//OneInterface为一个接口名 … //直接提供具体的实现 } }

21：int和Integer有什么区别

int 属于8中基本数据类型之一，4字节长度，取值范围：-231~231-1；它保存在栈中；可以用算术运算符进行加、减…；在参数传递时传递的是它的值。 Integer是int的包装类；保存在堆中；不可以用算术运算符进行加、减…（因此得转为int）；在参数传递时传递的是它所代表对象的引用。 int a = 10? Integer b = new Integer(a)? //int-->Integer Integer c = Integer.valueOf(a)? //int->Integer a = b.intV alue()+1? //Integer-->int

22：float f = 2.3（错） 2.3默认为double型 float f = 2.3f或float f = (float)2.3

23：类型转换

隐式转换：由类型字节长度小的向类型字节长度大的转换如int隐式转换为double或者是子类对象赋值给父类的引用显示转换：与上相反当实型向整型转换时，会出现精度的损失，而且在进行float或double进行计算时会出现奇怪的问题，这时可以用BigDecimal类进行精确计算

24：用BigDecimal类进行精确计算

BigDecimal提供add() substract() multiply() divide()方法如： BigDecimal b1 = new BigDecimal(Double.toString(0.2))? BigDecimal b2 = new BigDecimal(Double.toString(0.3))?System.out.println(b1.add(b2).doubleV alue())?

25:JA V A不能用0代表false?也不能用非0代表true? 只能用boolean类型的true和false

因此C++中 while(1){…}在JA V A是错的

26：JA V A中 char类型采用unicode编码格式，用2个字节表示一个字符，范围从0到216-1

char能存储中文，且兼容英文字母(ASCII 0~127)

27：JA V A对象池

从JDK5.0开始，JVM启动时会实例化9个对象池。这个对象池分别用来存储8中基本类型的包装类对象和String对象。主要是为了效率问题。例子： ① String str1 = “hello”? String str2 = “hello”? ② String str3 = new String(“hello”)? System.out.println(str1==str2)?//输出true System.out.println(str1==str3)?//输出false ①处用字符串字面量（双引号），JVM到String对象池中去检查是否有一个值相同的对象，如果有就取现成的对象，如果没有，则创建一个新的对象，并加入到对象池中； ②处直接创建新的字符串，且未加入到对象池

对象池的简单实现： class Dog{ private String name? private int age? private static HashSetpool = new HashSet()? public static Dog newInstance(String name,int age){ for(Dog dog:pool){ if(https://www.sodocs.net/doc/8e6881965.html,.equals(name)&&dog.age==age) return dog? } //如果对象池中没有,创建并加入对象池 Dog dog = new Dog(String,name)? pool.add(dog)? return dog? }

28：StringBuffer和StringBuilder

Java字符串String对象有个特性---不变性，它只能被创建，而不能被修改（只要一改变就新创建一个对象）；因此，一些大量使用字符串的程序（如字符串拼接）可能会出现性能瓶颈，甚至内存溢出；这时需要用到StringBuffer 或StringBuilder，两者API相似，但StringBuilder能保证线程安全。简单示例： StringBuffer sb = new StringBuffer()? sb.append(“a”)? String str = sb.toString()?

29:如何输出反转过后的字符串

方法1：利用字符串存储字符的原理，取出它的char数组，进行重新排列；方法2：利用StringBuffer的reverse()方法

30：JA V A数组本质上是一个类，该类保存了数据类型的信息。通过成员变量的形式来保

存数据，并且通过[]，使用下标来访问这些数据。将基本数据类型初始为各自默认的初

始值，如将int初始为0（若程序员未提供初始值）,将引用数据类型初始为null

31：集合

List: 有序，允许重复 Set: 无序，不允许重复 SortedSet: 排好序的Set Map: 键值对键不可重复 SortedMap:排好序的Map(根据key排序)?

List和Set是Collection的子类

32：迭代器

提供一种访问一个集合对象中各个元素的途径，同时又不需要暴露该对象的内部细节。JA V A通过提供Iterable和Iterator两个接口来实现集合类的可迭代性。从JA V A5.0开始，迭代器可以被foreach循环所替代，但是foreach循环的本质就是使用Iterator进行遍历的。

33：比较器

方法1：要比较的自定义类实现Comparable接口，实现其compareTo(Object o)方法方法2：定义比较器，实现Comparator接口，实现compare(Object o1，Object o2)方法 String类实现了Comparable,用方法1实现了比较Collections.sort(Collections c,Comparator com)//这时用方法2定义比较器传入sort方法 Collections.sort(Collections c)//这时用方法1

示例1： public class Person { private String name? private int age? public Person(String name,int age){ https://www.sodocs.net/doc/8e6881965.html, = name? this.age = age? } ………setters and getters… }

public class CompareByName implements Comparator{ public int compare(Object o1, Object o2) { Person p1=null? Person p2=null? if(o1 instanceof Person&&o2 instanceof Person){ p1 = (Person)o1? p2 = (Person)o2? } /* if(p1.getName().compareToIgnoreCase(p2.getName())>0){ return 1? } if(p1.getName().compareToIgnoreCase(p2.getName())<0){ return -1? } return 0?*/ return (p1.getName()).compareTo(p2.getName())? }

public class DemoPerson { public static void main(String[] args) { Person p1 = new Person("c",24)? Person p2 = new Person("b",8)? Person p3 = new Person("a",34)? List list = new ArrayList()? list.add(p1)? list.add(p2)? list.add(p3)? //未排序之前 for(Person p:list){ System.out.println(p.getName()+":"+p.getAge())? } //按年龄排序之后 System.out.println("按年龄排序之后")? Collections.sort(list,new CompareByAge())? for(Person p:list){ System.out.println(p.getName()+":"+p.getAge())? } }

示例2： public class Dog implements Comparable{ private String name? private int age? public Dog(String name,int age){ https://www.sodocs.net/doc/8e6881965.html, = name? this.age = age? } //实现Comparable接口的方法 public int compareTo(Object o) {//参数必须是Object Dog d = null? if(o instanceof Dog){ d = (Dog)o? } if(this.getAge()>d.getAge()){ return 1? } if(this.getAge()

}

public class DemoDog { public static void main(String[] args) { Dog d1 = new Dog("c",24)? Dog d2 = new Dog("b",8)? Dog d3 = new Dog("a",34)? List list = new ArrayList()? list.add(d1)? list.add(d2)? list.add(d3)? //未排序之前 for(Dog d:list){ System.out.println(d.getName()+":"+d.getAge())? } //按年龄排序之后 System.out.println("按年龄排序之后")? Collections.sort(list)? for(Dog

d:list){ System.out.println(d.getName()+":"+d.getAge())? } } }

34:Vector和ArrayList

V erctor的大多数成员方法都会加上synchronized关键字，也就是说V ector是线程安全的；也正因如此，它的执行效率没ArrayList高；通常建议使用ArrayList

35：HashTable和HashMap的区别 ① HashTable是线程安全的，HashMap不是 ② HashTable不允许null值（key和value都不可以）,HashMap可以 ③

HashTable有个contains()方法，功能和HashMap的containsV alue()一样 ④ HashTable使用Enumeration遍历，HashMap使用Iterator

36:符合什么条件的数据集合可以使用foreach循环

从JDK5开始可以使用foreach代替迭代器,从语法上讲,数组或者实现了Iterable接口的类实例，都可以用foreach循环。

实例1：（迭代器模式方法） public class Person { private String name? private int age? public Person(String name,int age){ https://www.sodocs.net/doc/8e6881965.html, = name? this.age = age? } ………setters and getters… }

public class Persons implements Iterable{ List personlist = new ArrayList()? //实现Iterable的方法 public Iterator iterator() { PersonIterate pt = new PersonIterate()? pt.setPersonList(personlist)? return pt? } public void add(Person p){ personlist.add(p)? } } public class PersonIterate implements Iterator{ Listpersonlist = new ArrayList()? private int index = 0? public void setPersonList(Listpersonlist){ this.personlist = personlist? } public boolean hasNext() { // TODO Auto-generated method stub return personlist.size()>index? }

public Person next() { // TODO Auto-generated method stub return personlist.get(index++)? }

public void remove() { // TODO Auto-generated method stub personlist.remove(index)? } }

这样下面的foreach就能成功； Persons persons = new Persons()? persons.add(new Person("a",1))? persons.add(new Person("b",2))? persons.add(new Person("c",3))? for(Person p:persons){ System.out.println(p.getName()+":"+p.getAge())? }

实例2：(内部类方法) public class Persons2 implements Iterable{ Listpersonlist = new ArrayList()? public void add(Person p){ personlist.add(p)? } public Iterator iterator() { // TODO Auto-generated method stub return new Iterator(){ //用局部内部类实现 private int index=0? public boolean hasNext() { return personlist.size()>index?//可以访问外部类成员 } public Person next() { return personlist.get(index++)? }

public void remove() { personlist.remove(index)? } }? } }

这样也能进行foreach循环了

说明：Persons也可直接实现Iterator接口，并实现其hasNext(),next()等方法，但是这样的话Persons必须维护一个索引index，其index值是不确定的，如进行循环一次，index变为a,紧接着进行第二次循环遍历会得到空结果；方法1和方法2每次进行循环迭代都将产生一个新的索引为0；

37:目录和文件操作

Java提供了java.io.File类对目录和文件进行操作，主要操作方法包括：路径字符串的构造方法、isDirectory、isFile、createNewFile、list(返回文件数组)、getName、delete、getLastModify(返回最近修改时间)、listFile(返回文件名数组)等

38：随机存取文件RandomAccessFile类

主要方法包括new RandomAccessFile(“路径”,”rw|r|w…”)? length()方法获得文件内容长度 seek()定位 read()获取当前位置数据 write()写数据 close()关闭打开的文件示例：（将文件中所有字母a替换成c） RandomAccessFile raf =new RandomAccessFile("d:/1.txt", "rw")? int len = (int) raf.length()?//length()返回long类型 for(int i=0?i

38：字节流和字符流

字节流处理的是计算机最基本的单位byte，它可以处理任何数据格式的数据。主要的操作对象是byte数组，通过read()和write()方法把byte数组的数据写入或读出字符流有字节流包装而来，字符流创建时，一般要包装一个字节流；inputStreamReader提供字节流向字符流的转换,其构造函数中可以指定字符编码格式；读取或输出文本一般用BufferedReader.readLine()和PrintWriter.println()方法； PrintWriter和BufferedWriter同样提供可缓冲输出，但是PrintWriter可设置自动清除缓冲，不需要pw.flush()? PrintWriter pw = new PrintWriter(OutputStreamWirter(“d.txt”,”UTF-8”),true)?//true表示自动清除缓冲注意：①写时需要flush() ,PrintWriter 可设定自动清除 ②别忘了关闭流

39：序列化

Java可以通过序列化保存或传输一个对象。序列化本质上是把数据，变成一系列的字节数据。然后把这些字节数据写入到流中。 java.io.Serializable接口是可以进行序列化的类的标志性接口，该接口本身没有任何需要实现的方法，仅提供一个能唯一辨别一个类的serialV ersionUID.作用是在序列化和反序列化过程中，起到辨别作用。在反序列过程中，若有两个相同类名的类，就通过serialV ersionUID来判断到底反序列化成哪个类。

序列化：ObjectInputStream.readObject() 反序列化：ObjectOutputStream.writeObject()

40:进程与线程区别

① 线程隶属于某个进程 ② 进程能独占资源，而线程不能 ③ 线程是调度和分配的基本单位，进程是拥有资源的基本单位 ④ 进程间通信困难，而线程间共享一块内存区域，通信方便 ⑤ 创建销毁进程及进程切换系统开销大，而对于线程开销小

41：Runnable接口和Thread类的区别

两者都可以实现多线程编程，区别如下： ① 通过继承Thread方法定义线程就不能继承其他类，而实现Runnable接口方法可以 ② Thread方法为“多线程多实例”?Runnable：当多个线程公用一个Runnable时为“多线程单实例”,这时可以共享一个变量，但可能有线程安全问题；当每个线程都有各自的Runnable，则为“多线程多实例” ③ Runnable可以方便的访问同一变量，而Thread需要用内部类实现。

ThreadLocal: 线程局部变量（ThreadLocal）其实的功用非常简单，就是为每一个使用该变量的线程都提供一个变量值的副本，是每一个线程都可以独立地改变自己的副本，而不会和其它线程的副本冲突。从线程的角度看，就好像每一个线程都完全拥有该变量。一个ThreadLocal只能存放一个专有对象，若线程需要多个专有对象的话，必须设计多个ThreadLocal。ThreadLocal主要有两个方法set(Object) 和 get()

42:线程安全问题是指两方面的问题：变量安全和线程同步（见深入JDK206页）

解决变量安全的方法：1：多线程多实例 2：变量定义在方法中 3：使用ThreadLocal 解决线程同步问题用synchronized(监视器) 监视器默认为this?

(单实例，多线程中多个Thread基于同一个Runnable创建，Runnable中的变量为多个 Thread共享，所以存在变量安全问题)

ThreadLocal示例：(每个线程都实现从1~10累加) public class Accumulator implements Runnable{ ThreadLocal threadLocal = new ThreadLocal()?//创建threadlocal public void run() { for(int i=1?i<=10?i++){ if(threadLocal.get()==null){ threadLocal.set(new Integer(0))? } int x = (Integer) threadLocal.get()? x = x+i? threadLocal.set(x)?

try { Thread.sleep(1000)? } catch (InterruptedException e) { e.printStackTrace()? } System.out.println(Thread.currentThread().getName()+"\t累加和="+threadLocal.get())? } } }

public class Main { public static void main(String[] args) { Accumulator a = new Accumulator()?//单实例多线程 Thread t1 = new Thread(a)? Thread t2 = new Thread(a)? t1.start()? t2.start()? } }

说明：单实例多线程，假如不用ThreadLocal方法，在Accumulator中定义一个成员变量SUM保存每次累加和，则线程共享Runnable的变量SUM，会有变量安全问题；若改为多实例多线程则没有这问题；若将SUM定义在run()方法中也没有这样的问题；

43：同步锁Synchronized(括号内为可能发生同步冲突的监视器,默认为this)

当线程执行到Sychronized时候，检查传入的监视器对象，并得到该对象的同步锁，如果得不到(被占用),就会被加入到一个与该监视器对象相关联的等待线程池中，一直等待同步锁被释放，池中的等待线程就会得到该同步锁，然后继续执行下去，当线程执行完同步代码块，就会自动释放它占的同步锁。

44：协调运行—线程通信

wait()方法:使当前调用同步方法的线程等待，直到其他线程调用notify()或notifyAll() notify():唤醒当前同步监视器(sychronized的参数)上正在等待的单个线程，如果有多个，随机唤醒一个。 notifyAll():唤醒当前同步监视器(sychronized的参数)上正在等待的所有线程

示例：(实现生产者消费者模式)

public class Store {//仓库类 private final int MAX_SIZE? private int count? public Store(int size,int c){ MAX_SIZE = size? count = c? } //往仓库放货物 synchronized public void add(){//synchronized默认的同步监视器为this即Store if(count>=MAX_SIZE){ System.out.println("仓库满了")? try { wait()?//进入与Store实例相关联的等待线程池中 } catch (InterruptedException e) { e.printStackTrace()? } } count++? System.out.println("put "+count)? notifyAll()?//从线程池中唤醒所有等待线程，(若是producer被唤醒，则从等待处继续执行，（count++处） } //从仓库取货物 synchronized public void get(){ if(count<=0){ System.out.println("仓库空了")? try { wait()?

} catch (InterruptedException e) { e.printStackTrace()? } } System.out.println("get "+count)? count--? notifyAll()? } }

public class Producer extends Thread{//生产者线程 private Store s? public Producer(Store s){ this.s = s? } public void run(){ while(true){ s.add()? try { Thread.sleep(500)? } catch (InterruptedException e) { e.printStackTrace()? } } } }

public class Consumer extends Thread{//消费者线程 private Store s? public Consumer(Store s){ this.s = s? } public void run(){ while(true){ s.get()? try { Thread.sleep(500)? } catch (InterruptedException e) { e.printStackTrace()? } } } }

public class Main { public static void main(String[] args) { Store s = new Store(5,0)?//单实例多线程共享仓库 Producer producer1 = new Producer(s)? Producer producer2 = new Producer(s)? Consumer consumer1 = new Consumer(s)? Consumer consumer2 = new Consumer(s)? producer1.start()? producer2.start()? consumer1.start()? consumer2.start()? } }

45:JA V A实现线程池

思想：启动一个线程的开销是相当高的，利用线程池，程序向线程池传递一个实现Runnable接口的类的实例时，程序就会从线程池中启动一个空闲线程，并执行run()方法，run方法执行结束后，该线程又成为空闲线程，回到线程池，等待下一个Runnable对象，并执行对象的run()方法，从而大大提高了系统的性能。通过java.util.concurrent 包中的Executors类可以创建线程池对象，即创建线程池类ExecutorService的实例。

示例： public class Thread1 implements Runnable{ public void run() { System.out.println("this is thread1")? } } public class Thread2 implements Runnable{ public void run(){ System.out.println("this is thread2")? } }

import java.util.concurrent.ExecutorService? import java.util.concurrent.Executors? public class Main { public static void main(String[] args) { //创建线程池对象 ExecutorService es = Executors.newFixedThreadPool(5)? es.submit(new Thread1())?//传递Runnable接口实现类这是利用回调吗? es.submit(new Thread2())? es.shutdown()?//关闭线程池对象 } }

46：反射的原理：反射是为了能够动态的加载一个类，动态地调用一个方法，动态地访

问

一个属等动态要求而设计的。它的出发点在于JVM会为每个类创建一个https://www.sodocs.net/doc/8e6881965.html,ng.Class类的实例，通过该对象可以获取这个类的信息，然后通过使用https://www.sodocs.net/doc/8e6881965.html,ng.reflect包下的API以达到各种动态要求。

类在以下情况下会被加载： ① 需要使用该类创建对象。如Student s = new Student() Student会被加载 ② 访问该类的静态成员。如system.out.println(Calendar.MONDA Y)? ③ 使用Class类的forName()方法

类一旦被加载，JVM就会为其创建一个Class对象，如何得到一个类的Class对象？ ① Class.forName()返回就是一个Class对象 ② 类名.class ③ 对象名.getClass()

47:Field、Method、Construtor

Field通过Class类对象的getDeclaredField()和getDeclaredFields()方法得到?Field方法主要分为两大类：setXXX(object,value)和getXXX(object)其中object为实例对象。 Method通过Class类对象的getMethod()或getMethods()获得，Method最常用的方法是invoke(object,参数…)。 Constructor类通过Class类对象的getConstructor(参数类型.class…)获得。Constructor类最常用的方法是newInstance()，通过构造函数创建实例(Class

对象也能通过newInstance()创建实例，但该类中提供无参构造函数) 获得一个类中私有变量:调用Field的setAccessible(true)

示例： public class Person { public String name? private int age? public Person(){} public Person(String name,int age){ https://www.sodocs.net/doc/8e6881965.html, = name? this.age = age? } public void getInfo(){ System.out.println(name+":"+age)? } }

public class Main { public static void main(String[] args) { Class personclass = Person.class? try { Constructor con = personclass.getConstructor(String.class,int.class)? Person person = (Person) con.newInstance("li",20)? Field f = personclass.getDeclaredField("name")? String name = (String) f.get(person)? Field f2 = personclass.getDeclaredField("age")? f2.setAccessible(true)?//设置可以访问私有变量age int age = (Integer) f2.get(person)? System.out.println(name+":"+age)? Method m = personclass.getDeclaredMethod("getInfo",null)?//参数为null，可不写 m.invoke(person, null)?//调用方法 } catch (Exception e) { e.printStackTrace()? } } }

48:TCP通信特点

① 面向连接的传输 ② 端到端的通信 ③ 可靠性，确保传输数据的正确性，不出现丢失或乱序 ④ 采用字节流方式，即以字节为单位传输字节序列编程模型：服务器端:①创建ServerSocket ②accept()等待客户请求 ③获得输入流和输出流，并进行传输 ④释放资源，关闭输入流输出流、Socket、ServerSocket

49：UDP通信特点

① UDP是一个无连接协议，当它想传送数据时就简单地抓取来自应用程序的数据，并尽可能快地把它扔到网络上

② 不需要维护连接状态，包括收发状态等 ③ 字节开销很小，传输速度快，效率高编程模型：（点对点，没有服务器与客户端之分；分为接收端和发送端）接收端和客户端都需要有一下步骤： ① 创建DatagramSocket,指定一个端口号. ② 提供一个byte数组进行数据的存储；对于发送端，还需要提供对端的IP地址和端口号。 ③ 调用DatagramPacket的receive()或send()方法进行数据的接收或发送 ④ 调用DatagramPacket的getData()方法得到byte数组的数据。 ⑤ 释放资源说明： DatagramSocket ds = new DatagramSocket(port)?//port为接收端口接收：DatagramPacket dp = new DatagramPacket(buff,len)? ds.receive(dp)? 发送: Datagrampacket dp = new DatagramPacket (str.getBytes() ,0,str.length(),InetAddress.getByName(“localhost”),sendPort)?//参数:字节数组,offset,len,主机号或IP,对方接收端口号 ds.send(dp)?

50：TCP实现web服务器

public class WebServer { public static void main(String[] args) throws Exception{ ServerSocket ss = new ServerSocket(80)? Socket s = null? System.out.println("服务器已启动!")? while(true){ s = ss.accept()? new HTTPThread(s).start()? } } }

public class HTTPThread extends Thread{ private Socket socket? public HTTPThread(Socket s){ this.socket = s? } public void run(){ try{ OutputStream os = socket.getOutputStream()? PrintWriter pw = new PrintWriter(os)? pw.println("")? pw.println("")? pw.println("hello world")? pw.println("")? pw.println("")? pw.flush()? pw.close()? socket.close()? }catch(IOException e){ e.printStackTrace()? } } }

在浏览器输入http://localhost 会显示hello world

50:UDP实现一个即时聊天软件

QQ、MSN对安全的要求不是太高，一般会采用UDP的通信模式。UDP为点对点模式，没有服务器和客户端之分，两端都创建两个线程,SendThread（发送消息）还有ReceiveThread (接收消息)。代码如下： public class ReceiveThread extends Thread{ private DatagramSocket ds? public ReceiveThread(int recport){ try { this.ds = new DatagramSocket(recport)?//接收端口 } catch (SocketException e) { e.printStackTrace()? } } public void run(){ try { byte []buff = new byte[1024]? DatagramPacket dp = new DatagramPacket(buff,1024)? while(true){ ds.receive(dp)?//接收数据 String str = new String (dp.getData(),0,dp.getLength())? System.out.println("receive:"+str)? } } catch (IOException e) { e.printStackTrace()? }finally{ ds.close()? } } }

public class SendThread extends Thread{ private DatagramSocket ds? private int sendPort? public SendThread(int sendport,int otherPort){//发送、对方端口 this.sendPort = sendPort? try { this.ds = new DatagramSocket(sendport)?//发送端口 } catch (SocketException e) { e.printStackTrace()? } } public void run(){ try{ BufferedReader br = new BufferedReader(new InputStreamReader(System.in))? String str = null? while((str = br.readLine())!=null){ DatagramPacket dp = new DatagramPacket (str.getBytes(),0,str.length(), InetAddress.getByName("localhost"),otherPort)? ds.send(dp)? System.out.println("send:"+str)? } }catch(Exception ex){ ex.printStackTrace()? }finally{ ds.close()? } } }

public class Chat { public static void main(String[] args) { new ReceiveThread(7000).start()? new SendThread(7500,9000).start()?//发送端口和对方接受端口 } } 说明：在本机模拟执行时要两次运行Chat,并且设置好端口。如第一次为:7000 7500 9000 第二次则为:9000 7600 7000

TCP实现聊天室思路：多线程实现，服务器维护一个socket的List,每次接收消息时遍历list将消息发送给每个客户端。

UDP实现聊天室思路：可以用UDP组播 MultiCastSocekt实现

51：使用JA V A访问WEB站点

网络爬虫的原理就是模拟浏览器挨个访问web站点，得到站点网页的映射 JA V A也可以用编程的方式去访问网站,步骤： ① 用URL创建一个资源定位对象 ② 调用URL的openConnection()得到HttpURLConnection对象 ③ 调用HttpURLConnection的connect()方法打开连接 ④ 用getHeaderFields()方法得到响应结果的头信息 ⑤ 用getInputStream()方法得到输入流对象，得到响应内容

public class HttpConnTest { public static void main(String[] args) throws Exception{ //创建URL对象 URL url = new URL("https://www.sodocs.net/doc/8e6881965.html,")? HttpURLConnection conn = (HttpURLConnection) url.openConnection()? conn.connect()?//打开连接 //获取请求响应的头部信息 Map> header = conn.getHeaderFields()? for(String key:header.keySet()){ System.out.println(key+":"+header.get(key))? } //获取响应内容 BufferedReader br = new BufferedReader( new InputStreamReader(conn.getInputStream(),"UTF-8"))? String str = null? while((str=br.readLine())!=null){ System.out.println(str)? } conn.disconnect()? } }

52:JDBC（java data base connectivity）工作原理

JDBC采用了一种驱动模式的设计，提供了两套的接口：开发者使用的API和数据库厂商使用的SPI（service provider interface 数据库厂商需要实现的接口）,充分体现了面向接口编程的好处。程序员无需关心具体数据库的连接和调用，只需要使用JDK中提供的标准API编程即可，而具体的实现由特定的数据库生产商提供，也就是JDBC驱动。

53：JDBC编程步骤：

① 注册驱动程序。就是把驱动程序类加载到JVM，一般用Class.forName(“完整类名”) ② 获取数据库连接Connection conn = DriverManager.getConnection(“URL”,”用户名”,”密码”)? ③ 创建会话Statement(用于向数据库发送SQL命令,并返回结果) 实际开发中用的更多的是PreparedStatement,它是一种预编译的会话,用占位符的方法效率高，且可以避免SQL注入 ④ 执行SQL语句。 executeQuery()或executeUpdate() ⑤ 处理结果集。若是查询操作的话，会返回ResultSet 用其next()方法操作结果集 ⑥ 关闭连接。关闭顺序ResultSet、Statement、Conection

53：如何使用JDBC事务

事务特性：ACID（原子性、一致性、隔离性、持久性）

1. Atomicity（原子性）

原子性很容易理解，也就是说事务里的所有操作要么全部做完，要么都不做，事务成功的条件是事务里的所有操作都成功，只要有一个操作失败，整个事务就失败，需要回滚。

2. Consistency（一致性）

一致性也比较容易理解，也就是说数据库要一直处于一致的状态，事务开始前是一个一致状态，事务结束后是另一个一致状态，事务将数据库从一个一致状态转移到另一个一致状态。

3. Isolation（独立性）

从字面上来说，独立性是其中最难理解的一点，但如果结合Oracle中的undo，也就不难理解了。所谓的独立性就是指并发的事务之间不会互相影响，如果一个事务要访问的数据正在被另外一个事务修改，只要另外一个事务还未提交，它所访问的数据就不受未提交事务的影响。换句话说，一个事务的影响在该事务提交前对其它事务是不可见的。

注意：这里的Isolation跟隔离级别（Isolation Level)是无关的。

4. Durability(持久性)

持久性也不难理解，是指一旦事务提交后，它所做的修改将会永久的保存在数据库上，即使出现宕机也不会丢失。

JDBC使用事务步骤： ① 关闭自动提及事务:conn.setAutoCommit(false)? ② 捕获(try catch)执行代码,如果发生异常，在catch中conn.rollback() ③ 关闭连接。一般在finally{}中

54：如何使用可滚动的结果集

Statement stmt = conn.createStatement(sql,type,concurrency)? 其中concurrency变量用于指定是否可更新的结果集,可取以下值： ① TYPE_FORW ARD_ONLY:不允许滚动，只能向前(next())? ② TYPE_SCROLL_INSENSITIVE：可滚动，对数据库变化不敏感，数据库查询生产结果集后若发生变化，结果集不发生变化 ③TYPE_SCROLL_SENSITIVE:可滚动，且对数据库变化敏感可滚动的结果集方法： rs.next()、https://www.sodocs.net/doc/8e6881965.html,st()?//到最后一行、rs.previous()?//回一行 rs.absolute(6)?//直接定位到第六行

55：如何使用可更新的结果集

当concurrency变量为以下值时： ① CONCUR_READ_ONLY:不能用于更新数据库 ② CONCUR_UPDA TABLE:结果集可用于更新数据库

如： PreparedSatement pstmt = conn.prepareStatement(sql, ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDA TABLE)? rs = pstmt.executeQuery()? https://www.sodocs.net/doc/8e6881965.html,st()? //更新最后一行数据 rs.updateString(2,”aaaa”)?//修改值 rs.updateRow()?//更新

56：什么是Servlet

Servlet在JA V A Web服务器中充当了信息资源的最小表示单位，代表了一个用户可以通过浏览器获取的资源，Servlet可以进行无限的扩展,它可以使用java的所有类库资源，为用户返回文本、图片、视频等各类信息资源。从编程角度看，Servlet是一个java类,这个类需要实现Servlet接口，提供一个公开的无参构造方法。有WEB容器来控制它的创建、初始化、提供服务、销毁等。它的各种行为方式通过在web.xml中配置决定。说明：在实际开发中,servelt一般通过继承自javax.servlet.http.HttpServlet 来创建（HttpServlet也是Servlet的实现）,它可以为开发者提供一些方法的默认实现，而且可以区别不同的请求方法(doGet() doPost())

57:Servlet生命周期 ① 加载。Servlet类加载到JVM中，并且实例化。这个过程中，web容器会调用Servlet类的无参构造方法。默认下，

Servlet是在第一次请求时被加载，但可通过在web.xml中配置标签设置在web容器启动时加载。 ② 初始化。调用init()方法，如为Servelt配置的初始化参数是在init()中取得的。 ③ 提供服务。当有HTTP请求时，调用service()方法。如果是继承自HttpServlet的话，service()会根据请求类型不同调用doGet()或doPost()方法 ④ 销毁。当重新部署web应用，关闭web容器时被销毁并调用destroy()方法

Servlet运行时的基本原理

1)、当WEB客户请求Servlet服务或当WEB服务启动时，容器环境加载一个Java Servlet类。 2)、容器环境也将根据客房请求创建一个Servlet对象实例，或者创建多个Servlet对象实例，并把这些实例加入到Servlet实例池中。 3)、容器环境调用Servlet的初始化方法HttpServlet.init()进行Servlet实例化。在调用初始化时，要给init()方法传入一个ServletConfig对象，ServletConfig对象包含了初始化参数和容环境的信息,并负责向servlet传递信息，如果传递失败，则会发生ServletException。Servlet将不能正常工作。 4)、容器环境利用一个HttpServletRequest和HttpServletResponse对象，封装从Web客户接收到的HTTP请求和由Servlet生成的响应。 5)、容器环境把HttpServletRequest和HttpServletResponse对象传递给HttpServlet.Service()方法。这样，一个定制的Java Servlet就可以访问这种HTTP请求和响应接口。Servlet()方法可被多次调用，各调用过程运行在不同的线程中，互不干扰。 6)、定制的Java Servlet从HttpServletRequest对象读取HTTP请求数据，访问来自HttpSession或Cookie对象的状态信息，进行特定应用的处理，并且用HttpServletResponse对象生成HTTP响应数据。 7)、当WEB服务器和容器关闭时，会自动调用HttpServlet.destroy()方法关闭任何打开的资源，并进行一些关闭前的处理。

servlet 的生命周期。

Servlet 运行在 Servlet 容器中，其生命周期由容器来管理。 Servlet 的生命周期通过 Servlet 接口中 init （）、service （）、 destroy （）方法来表示。

Servlet 的生命周期包含了下面 4 个阶段。

（1）加载和实例化 Servlet 容器负责加载和实例化 Servlet 。当 Servlet 容器启动时，或者在容器检查到需要这个Servlet 来响应一个请求时，创建 Servlet 实例。当 Servlet 容器启动后，它必须要知道所需的 Servlet 类在什么位置， Servlet 容器可以从本地文件系统、远程文件系统或者其他网络服务器中通过类加载器加载 Servlet 类，成功加载后，容器创建 Servlet 实例。因为容器是通过 Java 的反射 API 来创建 Servlet 实例，调用的是 Servlet 的默认构造函数，也就是那个不带参数的构造函数，所以我们在编写 Servlet 类的时候，不应该提供带参数的构造函数。——这也就是为什么 Servlet 类可以不写构造函数的原因。

（2）初始化在 Servlet 实例化之后，容器必须调用 Servlet 的 init （）方法初始化这个对象。初始化的目的是为了让 Servlet 对象在处理客户请求前完成一些初始化工作，如建立数据库连接，获取配置信息等。对于每一个 Servlet 实例， init （）方法只能被调用一次。在初始化期间， Servlet 实例可以使用容器为它准备的 ServletConfit 对象从web 应用程序的配置信息（在 web.xml 中配置）中获取初始化的参数信息。在初始化期间，如果发生错误， Servlet 实例可以抛出异常来通知容器。（3）请求处理

Servlet 容器调用 Servlet 的 service （）方法对请求进行处理。要注意的是，在 service （）方法调用之前， init （）方法必须成功执行。在 service （）方法中， servlet 实例通过 ServletRequest 对象得到客户端的相关信息和请求信息，在对请求进行处理后，调用 servletResponse 对象的方法设置响应信息。

（4）服务终止当容器检测在一个 Servlet 实例应该从服务中被移除的时候，容器就会调用实例的 destroy （）方法，以便让该实例可以释放它所使用的资源，保存数据到持久存储设备中。当需要释放内存或者容器关闭时，容器就会调用 Servlet 实例的 destroy （）方法。在调用 destroy （）方法后，容器会释放这个 Servlet 实例，该实例随后会被 java 的垃圾收集器回收。在整个 Servlet 的生命周期过程中，创建 Servlet 实例、调用实例的 init （）和destroy （）方法都只进行一次，当初始化完成后， Servlet 容器会将该实例保存在内存中，通过调用它的 service （）方法，为接收到的请求服务。

58：在web.xml中Servlet的标准配置

LoginServlet com.abc.LoginServelt myparam 100 0 LoginServlet /*Servlet

59:Forward(直接转发或请求转发)和Redirect(间接转发或重定向)的区别

① 直接转发或请求转发： RequestDspatcher rs = request.getRequestDispatcher(“url”)? Rs.forward(request,response)? 本质上是一次请求，共享同一个request对象，地址栏地址不会改变 ② 间接转发或重定向response.sendRedirect(“url”)?本质上是两次请求，对应两个不同request对象，请求信息不一样。

forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。还有，转发是在web应用程序之内进行的，可以访问web应用程序所设定的内部目录，像是WEB-INF目录，只能在Web应用程序中进行，不能指定至其它的Web应用程序的地址。

redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。web应用程序会要求客户端浏览器重新发出请求地址，客户端会重新连接至所指定的地址，因此浏览器的地址会出现重新导向的信息，重新导向后的请求由浏览器发出，所以不能访问Web应用程序中的隐藏目录，像是WEB-INF，重新是由浏览器重新要求一个网页，可以指定至其他的Web应用程序地址。 RequestDispatcher.forward()方法和HttpServletResponse.sendRedirect()方法的区别是：前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址，他是不会改变Request的值，如果你需要在下一个页面中能从中获取新的信息的话，你可以Request.setAttribute()来放置一些标志，这样从下一个页面中获取；后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用RequestDispatcher.forward()方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用 HttpServletResponse.sendRequest()方法。

1、forward与include共亨Request范围内的对象,而redirect则不行，即：如果一个javabean被声明为request范围的话，则被forward到的资源也可以访问这个javabean,而redriect则不行。

2、forward与include基本上都是转发到context内部的资源，而redirect可以重定向到外部的资源,如： req.sendRedriect

1、从地址栏显示来说 forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址. redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.

2、从数据共享来说 forward:转发页面和转发到的页面可以共享request里面的数据. redirect:不能共享数据.

3、从运用地方来说 forward:一般用于用户登陆的时候,根据角色转发到相应的模块. redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.

4、从效率来说 forward:高. redirect:低.

不要仅仅为了把变量传到下一个页面而使用session作用域，那会无故增大变量的作用域，转发也许可以帮助你解决这个问题。

redirect：以前的request中存放的变量全部失效，并进入一个新的request作用域。 forward：以前的request中存放的变量不会失效，就像把两个页面拼到了一起。

他们的调用分别如下： request.getRequestDispatcher("apage.jsp").forward(request, response)? //转发到apage.jsp response.sendRedirect("apage.jsp")? //重定向到apage.jsp

在jsp页面中你也会看到通过下面的方式实现转发：

60：过滤器的作用和原理

过滤器是处于web容器内的一个组件,它会过滤特定请求和响应.当一个请求到来时，web容器判断是否有过滤器与该信息资源关联，若有，则交给过滤器—处理，然后交给目标资源。响应的时候则以相反的顺序交给过滤器，最后返回给用户。过滤器是一种很重要的设计模式（基于AOP思想）可以再不侵入原有代码的基础上为它们提供一些功能。Struts就是利用过滤器工作的。过滤器要实现javax.servlet.Filter接口，并实现doFilter()方法。

public class MyFilter implements Filter{ //过滤器的业务逻辑方法 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException { //业务代码 chain.doFilter(request, response)?//将请求转发给下一个过滤器或目标资源 }

public void init(FilterConfig arg0) throws ServletException { //初始化代码 } public void destroy() { //释放资源代码 } }

Web.xml中配置： MyFilter com.abc.MyFilter MyFilter /*Servlet

61：监听器的作用和工作原理

对于web应用程序来说，监听器是处于web容器内的一个组件，它会对web容器中的request,session和application 3种对象进行监听。当这些对象在创建或销毁时，web容器主动调用它们的初始化和销毁方法。 Request事件监听接口ServletRequestListener? Session事件监听接口HttpSessionListener? Application事件监听接口ServletContextListener? 应用：当用户第一次访问web应用程序是，程序将在线人数加1

62：JSP的运行机制

JSP本质上是Servlet,但JSP的存在是必要的，因为Servlet在处理静态内容（如HTML标签）时非常笨拙，不得不以字符串形式进行拼接，而JSP可以很好的实现动态和静态内容的分离。当客户端发出一次对某个JSP的请求，web容器处理该请求过程如下： ① web容器会检验JSP的语法是否正确 ② 将JSP文件转换成Servlet的源代码文件 ③ 编译该源代码文件称为class文件 ④ 创建一个该Servlet类的对象实例，为请求提供服务说明：JSP只会在第一次访问时才转换盒编译。以后的访问web容器就直接调用编译好的servlet对象实例了，如果JSP被修改过，整个过程重新执行一次。

63：JSP内置对象及用途(见文档)

request 类型 javax.servlet.ServletRequest 作用域 Request response 类型 javax.servlet.SrvletResponse 作用域 Page pageContext 类型 javax.servlet.jsp.PageContext 作用域 Page session 类型javax.servlet.http.HttpSession 作用域 Session application 类型 javax.servlet.ServletContext 作用域 Application out 类型 javax.servlet.jsp.JspWriter 作用域 Page config 类型 javax.servlet.ServletConfig 作用域 Page page 类型 https://www.sodocs.net/doc/8e6881965.html,ng.Object 作用域 Page exception 类型 https://www.sodocs.net/doc/8e6881965.html,ng.Throwable 作用域 page

64：JSP作用域

JSP比Servlet多了一种页面范围(page)，一共四种作用域：page,request,session和application。 Request范围指的是一次请求，如果请求指向一个单一的JSP文件，则此时的page和request的生命周期是一样的，但是如果一次请求经过多次请求转发(forward)，则这个request周期可以为多个page周期之和

65：jsp中使用javabean

JavaBean规范： ① 是一个公开类 ② 提供一个无参数的构造方法 ③ 提供了公开的setXXX和getXXX JSP使用javabean两种方法 ① 纯JA V A代码，如Dog dog = new Dog() ② Jsp动作标签

Scope属性默认为page

66:表达式语言EL和JSTL（详见文档EL OGNL JSTL）

EL是一种数据表现语言 JSTL是一个标签库，而EL是从JSTL诞生出来的 EL用${https://www.sodocs.net/doc/8e6881965.html,}方法区别于OGNL{#https://www.sodocs.net/doc/8e6881965.html,}或{https://www.sodocs.net/doc/8e6881965.html,}(根对象)

67:Struts框架是如何体现MVC模式的？

Controller由ActionServlet、Action和Struts-config.xml组成。 Model由ActionForm来实现 View主要由JSP实现一次典型的Struts请求是这样的：客户端（浏览器）发送请求，然后ActionServlet接收到请求后，会根据请求的路径和参数来判断由哪个Action来处理该次请求。等到Action处理完成以后，通常是Execute方法调用完成以后，Struts会根据该方法返回的ActionForward来判断由哪个JSP来作为最终响应。

68:Hibernate实体存在哪几种状态瞬时态、持久态、脱管态

69：Hibernate继承关系的映射策略

有三个类 Animal Dog Cat 单表策略：当所有子类都在一张表中，只需建一个Animal.hbm.xml 用添加子类 //区别子类的字段 //子类 … … 多表策略：当每个子类一张表,只需建一个Animal.hbm.xml 用添加子类 < joined-subclass name=”Dog” table=”dog”>//子类需指明表名 //指明dog表的主键同时为指向animal的外键 … < joined-subclass …>… 这样数据库有三个表animal dog cat 其中dog，cat共同属性放在animal表中单表策略：无需表连接，查询速度快，适合多态查询（查询有继承关系的类时，同时查询到多个子类），缺点是可能造成表太大的结果（因为每个子类属性不一样，造成很多NULL），不利于维护。多表策略：数据存储比较紧凑，当查询某个子类的数据时速度比较快，缺点是可能会有很多的表连接，不太适合多态查询

69：AOP原理

AOP是一种对OOP有益补充的编程技术，它可以解决OOP和过程化方法不能够很好解决的横切问题，如事务，安全，日志等。随着软件系统变得越来越复杂，横切关注点成为一个大问题，AOP可以很轻松的解决横切关注点这个问题，Spring框架对AOP提供了很好的支持。简单来说，AOP就是一种功能比较复杂的拦截器。在代码真正达到目标以前，AOP可以对其进行拦截，提供一些通用的中间件的服务，例如，加上事务服务，记录日志等。Spring的声明式事务也就是基于AOP实现的。

70：打印1000以内的回文数字

for(int i=10?i<10000?i++){ int temp = i? int reverse = 0? while(temp>0){//反序 reverse = reverse*10+temp%10? temp=temp/10? } if(i==reverse){ System.out.println(i)? } } //判断一个字符串是否回文 String str = "abababa"? StringBuffer str2 = new StringBuffer(str)? str2 = str2.reverse()? if(str.equals(str2.toString())){ System.out.println("回文")? }

71:50个人围城一圈数到3和3的倍数时出圈，问剩下的人是谁，在原来的位置是多少？

public static void main(String []args) { Listlist = new LinkedList()? for(int i=1?i<=50?i++){//模拟50人 list.add(i)? } int index=-1?//模拟当前数的数字 while(list.size()>1){//多于一个人 //取余如果数到最后一个人，循环 index = (index+3)%list.size()?// //因为删除一个元素后，后边元素自动前移，所以索引减一 list.remove(index--)? } System.out.println(list.get(0))? }

行测总结笔记-学霸笔记-必过知识讲解

行测总结笔记-学霸笔记-必过

如果第一年的数据为A，第1年为B 二、下面重点讲一下资料分析速算技巧 1、÷(1)≈b×(1)结果会比正确答案略小，记住是略小，如果看到有个选项比你用这种方法算出来的结果略大，那么就可以选；比它小的结果不管多接近一律排除；x越小越精确 ÷(1)≈(1)结果会比正确答案略小，x越小越精确特别注意： ⑴当选项差距比较大时，推荐使用该方法，当差距比较小时，需验证 ⑵增长率或者负增长率大于10%，不适用此方法 2、分子分母比较法 ⑴分子大分母小的分数大于分子小分母大的分数 ⑵差分法★ 若其中一个分数的分子和分母都大于另外一个分数的分子和分母，且大一点点时，差分法非常适用。例：2008年产猪6584头，2009年产猪8613头,2010年产猪10624头，问2009与2010哪一年的增长率高

Java基础学习心得笔记

Java基础学习心得笔记对于很多只会C语言的初学者而言，面对java基础语法学习，反而感觉很难，其实其中最大的问题不是语法难，而是一种编程思想的转变。面向过程就是把你的代码封装成函数，然后依次去做一件事情，面向过程是把你要做的事情抽象成对象，告诉对象去做。所以要想学好java入门，必须知道类和对象的概念。类是对生活中事物的抽象描述，比如人类，动物类，交通工具类；对象即是对类的具体实例化，比如张三是人，猫是动物，飞机是交通工具（对象-----类）。Java基础入门学习路线可以总结为四步走： 1.java开发环境的搭建； 2.java初级之基础语法学习（80%类似C语言）; 3.java中级之面向对象编程学习(重点)； 4.java中级之应用编程学习。第一步：JDK软件开发包时java软件开发环境，包括jre运行环境和jvm虚拟机，在oricle官网下载javaSE版本JDK包；配置好环境变量就可以使用了。第二步:java初级语法学习， 1.基本数据类型整形，字符型，字节型，长整形，短整形，浮点型，双精度，布尔型；

2.运算符+，-，*，/，%等； 3.控制流（while,switch，if else）; 4.数组的定义方式。此阶段基本无难度，只要了解练习例题。第三步:java面向对象学习， 1.类和对象； 2.java语言三大特性，封装、继承、多态； 3.一些关键字学习（static，final，abstract,extends）等。这是重点，大家根据知识点一步步研究学习才是关键。第四步：java应用编程，例如：文件IO，集合（类似C语言数据结构），异常处理，线程，网络，JDBC数据库操作等，都是掌握面向对象以后，在查找不同的类使用类中不同的方法达到应用的效果，所以并不会很难。等基础语法掌握了就可以继续后面框架学习（java web方向，android学习），相信明确思路你会豁然开朗，更有学习动力。以上没有具体的实例和知识点讲解，分享的只是完全没接触过java的初学者自学java的思路和学习的流程，应该把握的重点，希望大家有所帮助。如果你想学好Java，找一家靠谱的培训机构，能让你的学习事半功倍。

行测总结笔记学霸笔记必过模板

现在开始资料分析之所以把资料分析放在第一，是因为本人以前最怕资料分析不难但由于位于最后，时间紧加上数字繁琐，得分率一直很低。而各大论坛上的普遍说法是资料分析分值较高，不可小觑。有一次去面试，有个行测考90分的牛人说他拿到试卷先做资料分析，我也试过，发觉效果并不好，细想来经验因人而议，私以为资料分析还是应该放在最后，只是需要保证平均5分钟一篇的时间余量，胆大心细。一、基本概念和公式 1、同比增长速度（即同比增长率）=（本期数-去年同期数）/去年同期数x100% =本期数/去年同期数-1 显然后一种快得多环比增长速度（即环比增长率）=（本期数-上期数）/上期数=本期数/上期数-1 2、百分数、百分比（略） 3、比重（略） 4、倍数和翻番翻番是指数量的加倍，翻番的数量以2^n次变化 5、平均数（略） 6、年均增长率如果第一年的数据为A，第n+1年为B 二、下面重点讲一下资料分析速算技巧 1、a=b÷(1+x%)≈b×(1-x%)结果会比正确答案略小，记住是略小，如果看到有个选项比你用这种方法算出来的结果略大，那么就可以选；比它小的结果不管多接近一律排除； x越小越精确 a=b÷(1-x%)≈bX(1+x%)结果会比正确答案略小，x越小越精确特别注意： ⑴当选项差距比较大时，推荐使用该方法，当差距比较小时，需验证 ⑵增长率或者负增长率大于10%，不适用此方法 2、分子分母比较法 ⑴分子大分母小的分数大于分子小分母大的分数 ⑵差分法★ 若其中一个分数的分子和分母都大于另外一个分数的分子和分母，且大一点点时，差分法非常适用。例：2008年产猪6584头，2009年产猪8613头,2010年产猪10624头，问2009与2010哪一年的增长率高答：2009增长率8613/6584-1 ，2010增长率10624/8613-1，-1不用看，利用差分法

黑马毕向东JAVA基础总结笔记

Java基础知识总结（超级经典）写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java虚拟机)。3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；如果指定了classpath，那么会在指定的目录下查找要运行的类文件。还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目录找。一般不指定分号，如果没有在指定目录下找到要运行的类文件，就报错，这样可以调试程序。 4，javac命令和java命令做什么事情呢？要知道java是分两部分的：一个是编译，一个是运行。 javac：负责的是编译的部分，当执行javac时，会启动java的编译器程序。对指定扩展名的.java 文件进行编译。生成了jvm可以识别的字节码文件。也就是class文件，也就是java的运行程序。 java：负责运行的部分.会启动jvm.加载运行时所需的类库,并对class文件进行执行. 一个文件要被执行,必须要有一个执行的起始点,这个起始点就是main函数. ----------------------------------------------------------------------------------------------

资料分析报告笔记整理好

资料分析笔记整理一．资料分析基础概念与解题技巧 1.资料分析核心运算公式 2.资料分析常用基本概念 3.资料分析速算技巧二．资料分析高频高点梳理 1.ABR类问题 2.比重类问题资料分析基础概念与解题技巧一、基期、本期基期，表示的是在比较两个时期的变化时，用来做比较值（基准值）的时期，该时期的数值通常作为计算过程中的除数或者减数；本期，相对于基期而言，是当前所处的时期，该时期的数值通常作为计算过程中的被除数或者被减数。【注】和谁相比，谁做基期。二、增长量、增长率（增长速度、增长幅度）增长量，表示的是本期与基期之间的绝对差异，是一绝对值。增长率，表示的是末期与基期之间的相对差异，是一相对值。增长率=增长速度（增速）=增长幅度（增幅）【注】在一些“最值”比较题的题干表述中，经常出现“增加（长）最多”和“增加（长）最快”，我们需要注意，前者比较的是增长量，而后者则比较的是增长率。三、同比、环比同比和环比均表示的是两个时期的变化情况，但是这两个概念比较的基期不同。同比，指的是本期发展水平与历史同期的发展水平的变化情况，其基期对应的是历史同期。环比，指的是本期发展水平与上个统计周期的发展水平的变化情况，其基期对应的是上个统计周期。【注】环比常出现在月份、季度相关问题。四、公式运用与练习资料分析的考察离不开对于两个时期的数值的比较，由此得出四个概念，

即基期（A），本期（B）,增长率（R），增长量（X）。增长量=基期量*增长率=本期量-基期量=本期量-本期量/1+增长率增长率=增长量/基期量=（本期量-基期量）/基期量=本期量/基期量-1 本期=基期+增长量=基期+基期*增长率=基期*（1+增长率）基期=本期-增长量=本期/1+增长率【习题演练】【例一】2012年1-3月，全国进出口总值为8593.7亿美元，同比增长7.3%，其中：出口4300.2亿美元，增长7.6%；进口4293.6亿美元，增长6.9%。3月当月，全国进出口总值为3259.7亿美元，同比增加216亿美元，其中：出口1656.6亿美元，增长135.4亿美元；进口1603.1亿美元，增长5.3%。 1、2011年一季度，全国进出口总值约为多少？ 2、2012年一季度，全国出口额同比增长多少？ 3、2011年三月份，全国进出口总值约为多少？ 4、2012年三月份，全国出口总值同比增速约为多少？【注】进出口相关问题，为资料分析中的一个易错点，注意题目中进出口、进口、出口的表述，注意进出口量与进出口额的不同，理解顺差、逆差的含义出口-进口=顺差，反之则是逆差 2、资料分析常用基本概念一、百分数、百分点百分数，表示的是将相比较的基期的数值抽象为100，然后计算出来的数值，用“%”表示，一般通过数值相除得到，在资料分析题目常用在以下情况：（1）部分在整体中所占的比重；（2）表示某个指标的增长率或者减少率。百分点，表示的是增长率、比例等以百分数表示的指标的变化情况，一般通过百分数相减得到，在资料分析题目常用在以下情况：（1）两个增长率、比例等以百分数表示的数值的差值；（2）在A拉动B增长几个百分点，这样的表述中。【例1】2010年，某省地区生产总值达到6835.7亿元，比去年同期增长14.9%。其中，第一产业增加值为483.5亿元，比去年同期增长25.8%，第二产业增加值为2985.6亿元，同比增长12.5%。 1、2010年，该省第一产业增加值占地区生产总值的比重为（）。A．12.63% B．12.63个百分点 C．7.07% D．7.07个百分点 2、2010年，该省第一产业增加值同比增速比第二产业增加值增速高（）。A．13.3% B．13.3个百分点 C．14.3% D．14.3个百分点二、倍数、翻番倍数，指将对比的基数抽象为1，从而计算出的数值。翻番，指数量的加倍，如：如果某指标是原来的2倍，则意味着翻了一番，是原来的4倍，则意味着翻了两番，依此类推。所用的公式为：末期/基期=2n，即翻了n番。【注】注意“超过N倍”“是xx的N倍”两种说法的区别。超过N倍，说明是基数的N+1倍。

java基础笔记

1什么是变量？答:是指代在内存中开辟的储存空间，用于存放运算过程中需要用到的数据。一个类中不能有2个public以为有pulic要和类名保持一致，有2个的话就不知道是和谁保持一致了，可以用很多类。 2变量的声明答:当需要使用一个变量的时候，必须要对该变量就行声明，变量的声明包含2点，1是变量的基本数据类型，2是变量名比如int a ；int是数据类型a是变量名，可以声明多个变量，比如int a，b，c；等 3，变量的初始化答:有2种初始化方法， 1是在变量声明时初始化，变量类型变量名=初始值，比如int a=0； 2是先声明变量，然后再初始化给变量赋值，，比如int a；a=0； 3.1可以对变量中的值进行存取，操作，变量使用之前，要使用与其变量符合的数据类型。 3.2基本数据类型，8种 1整数类行:byte,short int(常用)，long（常用）2浮点类型:float，double（常用）3，boolean 4 char 类型名称字节空间使用场景 ------------------------------------------------------------------------------------------------------------ byte 丨1字节（8位）丨储存字节数据（较少用） --------------------------------------------------------------------------------------------------------------- short 丨2字节（16位）丨兼容性考虑（很少用） ------------------------------------------------------------------------------------------------------------ int 丨4字节（32位）丨存储普通整数（常用） -------------------------------------------------------------------------------------------------------------- long 丨8字节（64位）丨存储长整数（常用） ------------------------------------------------------------------------------------------------------------- float 丨4字节（32位）丨存储浮动数（不常用） ------------------------------------------------------------------------------------------------------------ double 丨8字节（64位）丨存储双精浮点数（常用） ----------------------------------------------------------------------------------------------------------- boolean 丨1字节（8位）丨存储逻辑变量（true，fales）（常用） --------------------------------------------------------------------------------------------------------------- char 丨2字节（16位）丨存储一个字符（常用） ---------------------------------------------------------------------------------------------------------------

公务员考试行测资料分析状元笔记

2017年公务员考试行测资料分析状元笔记通用阅读——上看标题，下看注释，中间看时间，单位（重点） 1文字性材料——难的是阅读（结构阅读是重点）文字性材料阅读结构和中心结构几段落——总分和并列—并列部分找中心词（圈点标点，括号标结构，圈标中心词）无结构小段，就仔细阅读，创造结构（圈点标点，标点暗示结构，括号标结构，圈标中心词）无结构大段，就直接读题—找两个关键词——区分性（平均气温），明显性（符号数字字母，例如括号，摄氏度，顿号之类的）——2007年底比2007年更合适多个题目涉及同一个关键词的，可以一起做 2表格型材料——难的是计算阅读横标目和纵标目分清合计和项目和地区 3图形型材料——难的是理解饼状图——看周围类别名称（包括大小的排名要心中有印象）柱状趋势图——看横轴和纵轴（要注意两个纵轴的分别对应柱状和点）柱状分两种：一种是绝对值（高低差异），一种是比例（高低相同，柱状分几个部分） 4统计术语（不是重点）增长率是属于后一年（所以第一年的增长率是算不出来的）前一年的总量=后一年除以（1+增长率）后一年除以（1-增长率）增长率的对比（很容易会出隔两年的总量，倒推2次）：增长率增长或降低了5个百分点（直接加减）乘以2看成除以5 乘以5看成除以2 乘以25看成除以4 除以125看成乘以8 同比是与上一年的同一期相比较环比是挨着的相同时间段相比较同比和环比：如果有注释按注释为准今年5月份环比=今年4月份今年5月份同比=去年5月份 5统计性数据的要素——时间和单位（重点） 1时间表述（陷阱）——对时间很敏感 1.计算的年份不一样 2.计算的时间段不一样 2单位表述（陷阱）——对单位很敏感 1.饼状图有单位，就不是百分比相比较的数据的单位不一样（注意是百分号还是千分号。年利率往往用百分，月利率用千分之） 2.计算的单位不一样下列选项一定正确和一定错误的题目是最难的，可以放在最后做。

Java笔记汇总

2010.3.11.Java笔记 1、定义一个年份判定这个年是否是闰年： import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; publicclass near { publicstaticvoid main(String args[])throws IOException{ int year; String str; BufferedReader buf; buf=new BufferedReader(new InputStreamReader(System.in)); System.out.println("Input the year:"); str=buf.readLine(); year=Integer.parseInt(str); if(year%4==0&&year%100!=0||year%400==0) System.out.println("year"+year+"is a leap year."); else System.out.println("year"+year+"is not a leap year."); } } 2、求出1~100之间的奇数： publicclass qishu { publicstaticvoid main(String args[]){ int i,j; for(i=1;i<=100;i++){ if(i%2!=0){ System.out.print(i+" "); } } } } 3、一段刚才长2000米每天截取一半多少天后长度短于5米publicclass day { publicstaticvoid main(String args[]){ int i ,j=0; for(i=2000;i>0;i--){ if(i/2<5) j++;} System.out.print(j+" "); } } 4、求125的所有因子： publicclass yinzi { publicstaticvoid main(String args[]){ int i; for(i=1;i<=125;i++){ if(125%i==0){

【黑马程序员】毕向东老师Java基础入门教程笔记

【黑马程序员】毕向东老师Java基础入门教程笔记毕向东Java基础视频教程_适合初学者入门完整视频：https://www.sodocs.net/doc/8e6881965.html,/course/7.html?1911sxkqq 提取码：ks8m 课程资料：https://https://www.sodocs.net/doc/8e6881965.html,/s/1jAjI85SlUTlrTuF_J2QNeQ 提取码：4bfg 黑马程序员视频库网址：https://www.sodocs.net/doc/8e6881965.html,（海量热门编程视频、资料免费学习）学习路线图、学习大纲、各阶段知识点、资料网盘免费领取+QQ 3285264708 / 3549664195 1.编程：人与计算机之间交流的过程就是编程。 2.Java语言特点：跨平台性。原理：JAVA程序是通过java虚拟机运行在系统平台上的，只要该系统可以安装相应的java虚拟机，该系统就可以运行JAVA程序。 3.JRE和JDK的区别： JDK：开发工具包，JDK是提供给开发人员使用的工具包。 JRE：JAVA运行环境包括java虚拟机和java程序所需的核心类库。 4.JAVA虚拟机jvm 是JAVA语言的运行环境，jvm读取并处理编译过的与平台无关的字节码文件 5.JAVA程序运行机制 Java源文件通过javac.exe 编译器编译成字节码文件，然后再通过jvm运行。 6.Java中需要注意的地方：一个JAVA源文件只定义一个类，不同的类使用不同的源文件定义；将每个源文件中单独定义的类都定义成public的；保持JAVA源文件的主文件名与源文件中的类名一致；

7.Main方法的作用：程序的入口，保证程序的独立运行，被JVM调用。 8.文档注释：单行注释：// 多行注释/* */ 文档注释/** */ 9.标识符的命名规则：由字母、数字、下划线、$组成，不能以数字开头，严格区分大小写，不能使用关键字，10.Java中的常量和变量定义变量的格式：数据类型变量名=初始化值；作用范围：定义开始到定义它的代码块结束，定义范围内的左大括号开始，到右大括号结束。同一作用范围内，不允许多个局部变量命名冲突；常量分为：整型常量小数常量布尔型常量字符型常量空常量（null）。、 11.整型常量：三种表现形式：计算机中存放的是二进制最低组成单位是八位，每八位表示一个字节。分为十进制八进制十六进制 12.局部变量和成员变量局部变量：不是声明在类体括号里面的变量；局部变量使用前必须初始化值; 局部变量没有默认初始化值; 局部变量的作用域是从定义开始到定义它的代码块结束; 成员变量:在方法体外,类体内声明的变量，又称字段(Field)或全局变量；（其实Java中没有全局变量，由于Java是面向对象语言，所有变量都是类成员），没有初始化时，会被赋予默认的初始化值。

资料分析笔记整理样本

资料分析笔记整顿一．资料分析基本概念与解题技巧 1.资料分析核心运算公式 2.资料分析惯用基本概念 3.资料分析速算技巧二．资料分析高频高点梳理 1.ABR类问题 2.比重类问题资料分析基本概念与解题技巧一、基期、本期基期，表达是在比较两个时期变化时，用来做比较值（基准值）时期，该时期数值普通作为计算过程中除数或者减数；本期，相对于基期而言，是当前所处时期，该时期数值普通作为计算过程中被除数或者被减数。【注】和谁相比，谁做基期。二、增长量、增长率（增长速度、增长幅度）增长量，表达是本期与基期之间绝对差别，是一绝对值。增长率，表达是末期与基期之间相对差别，是一相对值。增长率=增长速度（增速）=增长幅度（增幅）【注】在某些“最值”比较题题干表述中，经常浮现“增长（长）最多”和“增长（长）最快”，咱们需要注意，前者比较是增长量，而后者则比较是增长率。三、同比、环比同比和环比均表达是两个时期变化状况，但是这两个概念比较基期不同。同比，指是本期发展水平与历史同期发展水平变化状况，其基期相应是历史同期。

环比，指是本期发展水平与上个记录周期发展水平变化状况，其基期相应是上个记录周期。【注】环比常出当前月份、季度有关问题。四、公式运用与练习资料分析考察离不开对于两个时期数值比较，由此得出四个概念，即基期（A），本期（B）,增长率（R），增长量（X）。增长量=基期量*增长率=本期量-基期量=本期量-本期量/1+增长率增长率=增长量/基期量=（本期量-基期量）/基期量=本期量/基期量-1 本期=基期+增长量=基期+基期*增长率=基期*（1+增长率）基期=本期-增长量=本期/1+增长率【习题演习】【例一】1-3月，全国进出口总值为8593.7亿美元，同比增长7.3%，其中：出口4300.2亿美元，增长7.6%；进口4293.6亿美元，增长6.9%。3月当月，全国进出口总值为3259.7亿美元，同比增长216亿美元，其中：出口1656.6亿美元，增长135.4亿美元；进口1603.1亿美元，增长5.3%。 1、一季度，全国进出口总值约为多少？ 2、一季度，全国出口额同比增长多少？ 3、三月份，全国进出口总值约为多少？ 4、三月份，全国出口总值同比增速约为多少？【注】进出口有关问题，为资料分析中一种易错点，注意题目中进出口、进口、出口表述，注意进出口量与进出口额不同，理解顺差、逆差含义出口-进口=顺差，反之则是逆差 2、资料分析惯用基本概念一、百分数、百分点百分数，表达是将相比较基期数值抽象为100，然后计算出来数值，用“%”表

java各知识点详细总结(毕向东笔记整理)

Java基础知识总结写代码： 1，明确需求。我要做什么？ 2，分析思路。我要怎么做？1,2,3。 3，确定步骤。每一个思路部分用到哪些语句，方法，和对象。 4，代码实现。用具体的java语言代码把思路体现出来。学习新技术的四点： 1，该技术是什么？ 2，该技术有什么特点(使用注意)： 3，该技术怎么使用。demo 4，该技术什么时候用？test。 ----------------------------------------------------------------------------------------------- 一：java概述： 1991 年Sun公司的James Gosling等人开始开发名称为 Oak 的语言，希望用于控制嵌入在有线电视交换盒、PDA等的微处理器； 1994年将Oak语言更名为Java； Java的三种技术架构: JAVAEE：Java Platform Enterprise Edition，开发企业环境下的应用程序，主要针对web程序开发； JAVASE：Java Platform Standard Edition，完成桌面应用程序的开发，是其它两者的基础； JAVAME：Java Platform Micro Edition，开发电子消费产品和嵌入式设备，如手机中的程序； 1，JDK：Java Development Kit，java的开发和运行环境，java的开发工具和jre。 2，JRE：Java Runtime Environment，java程序的运行环境，java运行的所需的类库+JVM(java 虚拟机)。 3，配置环境变量：让java jdk\bin目录下的工具，可以在任意目录下运行，原因是，将该工具所在目录告诉了系统，当使用该工具时，由系统帮我们去找指定的目录。环境变量的配置： 1）：永久配置方式：JAVA_HOME=%安装路径%\Java\jdk path=%JAVA_HOME%\bin 2）：临时配置方式：set path=%path%;C:\Program Files\Java\jdk\bin 特点：系统默认先去当前路径下找要执行的程序，如果没有，再去path中设置的路径下找。 classpath的配置: 1）：永久配置方式：classpath=.;c:\;e:\ 2）：临时配置方式：set classpath=.;c:\;e:\ 注意：在定义classpath环境变量时，需要注意的情况如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；如果指定了classpath，那么会在指定的目录下查找要运行的类文件。还会在当前目录找吗？两种情况： 1）：如果classpath的值结尾处有分号，在具体路径中没有找到运行的类，会默认在当前目录再找一次。 2）：如果classpath的值结果出没有分号，在具体的路径中没有找到运行的类，不会再当前目

Java工作笔记(必看经典)

JAVA的面向对象编程--------课堂笔记面向对象主要针对面向过程。面向过程的基本单元是函数。什么是对象：EVERYTHING IS OBJECT（万物皆对象）所有的事物都有两个方面：有什么（属性）：用来描述对象。能够做什么（方法）：告诉外界对象有那些功能。后者以前者为基础。大的对象的属性也可以是一个对象。为什么要使用面向对象：首先，面向对象符合人类看待事物的一般规律。对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。方法的定义非常重要。方法有参数，也可能有返回值。注意区分：对象（本身）、对象的实现者、对象的调用者。分析对象主要从方法开始。我们通过类来看待对象，类是对象的抽象。其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。这样才能使每个对象本身做成最好的。对于对象的要求：高内聚、低耦合，这样容易拼装成为一个系统。实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。可复用性是OOP的基础。比较面向过程的思想和面向对象的思想：面向过程的思想：由过程、步骤、函数组成，以过程为核心；面向对象的思想：以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。面向过程是先有算法，后有数据结构。面向对象是先有数据结构，然后再有算法。在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。从语法上来看，一个类是一个新的数据类型。在面向对象编程中，除了简单数据类型，就是对象类型。定义类的格式： class Student{ 代码 } 注意类名中单词的首字母大写。实例变量：定义在类中但在任何方法之外。（New出来的均有初值）局部变量：定义在方法之中的变量。

粉笔资料分析听课笔记(整理版)

粉笔资料分析听课笔记(整理版) 一、常用分数、百分数、平方 1 3 =33.3% 1 4 =25% 1 5 =20% 1 6 =16.7% 1 7 =14.3% 1 8 =12.5% 1 9 =11.1% 1 10 =10% 1 11 =9.1% 1 12 =8.3% 1 13 =7.7% 1 14 =7.1% 1 15 =6.7% 1 16 =6.3% 1 1.5 =66.7% 1 2.25 =44% 1 2.5 =40% 1 3.5 =28.6% 1 4.5 =22% 1 5.5 =18.2% 1 6.5 =15.4% 1 7.5 =13.3% 1 8.5 =11.8% 1 9.5 =10.5% 1 10.5 =9.5% 1 11.5 =8.7% 1 12.5 =7.8% 1 13.5 =7.4% 1 14.5 =6.9% 1 15.5 =6.5% 1 16.5 =6.1% 22=2 32=9 42=16 52=25 62=36 72=49 82=64 92=81 102=100 112= 121 122=144 132=169 142=196 152=225 162=256 172=289 182=324 192=361 202=400 212=441 222=484 232=529 242=576 252 =625 262=676 272=729 282=784 292=841 二、截位直除速算法逍遥龙舞公考笔记1

三、其他速算技巧 1、一个数×1.5，等于这个数本身加上这个数的一半。 2、一个数×1.1 等于这个数错位相加. 3、一个数×0.9 等于这个数错位相减. 4、一个数÷5，等于这个数乘以2，乘积小数点向前移 1 位。 5、一个数÷25，等于这个数乘以4，乘积小数点向前移 2 位。 6、一个数÷125，等于这个数乘以8，乘积小数点向前移 3 位。 7、比较类：①分母相同，分子大的大；分子相同，分母小的大。 ②分子大分母小>分子小分母大。③当分母大分子大，分母小分子小时，看分母与分母的倍数，分子与分子的倍数，谁倍数大听谁的，谁小统统看为1，再比较。四、统计术语 1、基期：相对于今年来说，去年的就是基期。 2、现期：相对于去年来说，今年的就是现期。 3、基期量：相对于今年来说，去年的量就是基期量。 4、现期量：相对于去年来说，今年的量就是基期量。 5、增长量：现期量和基期量的差值，就是增长量。 6、增长率：增长量与基期量的比值，就是增长率。 7、倍数：A是B的多少倍；A为B 的多少倍，等于增长率加1。辨析：A比B增长了500%，那么就是A比B增长（多）5 倍，A是B的6 倍。逍遥龙舞公考笔记2

java课堂笔记(全部基础知识)

Java_U1课堂笔记（一）初识Java 一、配置Java环境变量： 1、复制JDK安装路径，如：C:\Program Files (x86)\Java\jdk1.7.0_51\bin 2、粘贴到我的电脑->属性->高级系统设置->环境变量->Path 3、加上英文的分号 4、验证是否配置正确：dos-->java -version 进入DOS窗口的方法：运行（或快捷键windows键+r）二、Java程序编写三步骤：编写.java 编译：javac **.java 运行java ** 三、使用jad反编译工具： DOS中切换至jad安装目录，如：C:\jad1.5.8g.win 输入命令：jad -s java D:\t01\HelloWorld.class 四、变量的使用: 变量取名，命名规则类型数值：int、double、float(f) 非数值:char、String 类型名字= 值; int age=10; 五、上机验证： System.out.println(5+3); System.out.println("5"+3); 六、Scanner的使用，接收用户键盘输入 Scanner import java.util.Scanner; Scanner input=new Scanner(System.in); input.next();（相关方法，nextDouble()、nextFloat()、nextInt(等）bin:exe jre lib src.zip （二）数据类型一、数据类型转换自动类型转换： int num=100; double b=num;

资料分析知识点(整理版)

资料分析第一节增长【例1】2012年国家外汇储备33116亿美元，2011年国家外汇储备31812亿美元。 {求增长量}○12012年国家外汇储备比上年增加了多少亿美元？ {求增长率}○22012年国家外汇储备比上年增加了百分之几？解析：○133116-31812；○2%10013181233116%100318123181233116??? ? ??-=?- 【例2】2012年2月因低温冷冻天气造成直接经济损失61亿元，比1月份减少27亿元，比2011年2月减少21亿元。2012年2月的损失比1月减少了百分之几？比上年2月减少了百分之几？解析：○1%100276127?+；○ 2%100216121?+ 【例3】2012年社会消费品零售总额183996亿元，2012年社会消费品零售总额比2011年增长了14.3%。

{求基期量}①2011年社会消费品零售总额为多少亿元？（% 3.141183996+） {求现期量}②按此增速，到2013年社会消费品零售总额预计达到多少亿元？（()%3.141183996+?） {求现期量}③2012年社会消费品零售总额比2011年多多少亿元？（%3.14% 3.141183996?+）第二节同比增长与环比增长 1.同比是强调相同时间特性下的两个量之间的比较；而环比则是强调时间顺延下的两个量之间的比较。 2、有关公式

第三节年均增长与年均增长率时间差首段时间该指标量末段时间该指标量平均增长量-= 如果第m 年数据指标为A ，第n 年数据指标为B ，那么这几年年均增长量=m n A B -- ★年均增长量是指标在一段时间内平均每年的增长幅度。如果第m 年数据指标为A ，第n 年数据指标为B ，这几年的年均增长率为x ，且1-=-m n A B x ① （1）已知第m 年数据指标为A ，年均增长率为x ，求第n 年数据指标B 。 [] 略大于该值）B x m n A x A B m n ()(1)1(-+?≈+?=-②（前提：x ＜10%）（2）已知第m 年数据指标为A ，第n 年数据指标为B ，求年均增长率。第n 年相对于第m 年的增长率为x ，1-=A B x 根据①式得()A B x m n =+-1，则有()11+=+-x x m n 根据二项式展开得()()()2 2 1x m n m n x m n x ---+-≈③，()实际值1-