第一篇：java总结-2011-12-7
一、面向对象的语言特性： 封装，多态，继承
二、hashtable和hashmap的区别：
hashtable是dictionary的子类，hashmap是map接口中的一个实现类
hashtable中的方法是同步的，hashmap中的方法在缺省情况下是非同步的 hashmap允许将null作为key值或value值，hashtable不允许
三、方法重写和方法重载的区别：
方法重载：方法名相同，参数不同。重载时权限没有严格要求。发生在同一个类中。可以改变返回值类型 方法重写：方法名相同，参数相同。重写时被重写的方法不能拥有更严格的权限。重写发生在继承类中
四、面向对象的具体特征： 封装性，多态性，继承性
封装的目的是：高内聚，低耦合
五、什么是多态性：
多态性就是“一种接口，多种方法”，可以为一组相关的动作设计一个通用的接口。重载就是一种多态
六、String和StringBuffer的区别： String类是一个final类，一旦生成对象便不可一改变它的值，如果改变这个对象则相当于生成了一个新的对象。
StringBuffer类则可以创建和操作动态字符串，系统可以自动的为对象扩展内存以容纳新增的文本。
String 是一个只读的，不可改变的。StringBuffer是可变的。
StringBuffer中的函数length()只是代表其中的字符串的长度，而capcity()代表了StringBuffer的真正长度。
StringBuffer的字符串内容即使和String的相同，他们两者也不能用==比较，必须将StringBuffer用toString()转化后才能相等
七、JSP页面的对象有哪些？四个作用域分别是什么？ 九大对象：
Page
页面对象 Request
请求对象 Session
会话对象
Application
应用程序对象 Response
响应对象 Out
输出对象 Config
配置对象
Pagecontext
页面上下文对象 Exception
例外对象、四个作用域： Page Request Session Application
八、JSP的两种跳转方式，及其区别 服务器端跳转：在服务器内部完成的跳转，可能有多个资源参与一个请求的处理 重定向：在客户端完成的跳转，每次访问都是一个请求，请求一次响应一次，一个资源参与一个请求的处理。
九、vector，linkedlist，arraylist的区别：
ArrayList底层采用数组完成，而LinkedList是以双向链表完成的
ArrayList在遍历时的性能高于LinkedList，但是LinkedList在增加，删除时的性能高于ArrayList Vector的方法都是多线程安全的，而ArrayList的方法则是非多线程安全的
十、写出五个常见的异常：
ArithmeticException
运算异常；NullPointerExcetion
空指针异常；
ClassCastException
强制转换异常；IndexOutOfBoundsException 索引越界异常；
BufferOverFlowException
缓冲区限制异常
十一、map，list，set的区别：
List是有序可重复的；set是无序不可重复的；map是键值形式的，一个key对应一个value
十二、equles和==的区别：
“==”表示的数值的比较，对象引用的比较 “equals”是对象的引用的值的比较
基本数据类型进行==比较时，只是比较两个变量的值。
十三、Collection与Collections的区别：
Collection是java.util下的接口，它是各种集合的父接口。Collections是java.util下的类，是针对集合的帮助类，提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。
十四、session和request的会话区别：
Request范围是请求级别的范围，客户端发送一次请求服务器响应一次，request对象只在本次请求中有效
Session范围是会话级别，一次会话可能有多次请求
十五、public，private，proceted的作用域：
Public：同一个类，一个包中的不同类，不同包中的父类，不同包中的不同类 Private：同一个类
Proceted：同一个，一个包中的不同类，不同包中的父类
十六、&与&&的区别：
&是位运算符，表示按位与；&&是逻辑运算符，表示and
十七、运行时异常和一般异常有何异同：
Java编译器要求方法必须声明抛出可能发生的非运行时异常，但并不要求必须抛出未捕获的运行时异常
十八、final，finally，finalize的区别：
Final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
Finally 是异常处理语句结构的一部分，表示总是执行 Finalize 是object类的一个方法
十九、正则的功能：
测试字符串的某个模式；替换文本
二十、最有效率的算出2乘以8等于几的方法： 2<<3 二十一、八种基本数据类型： 字符型：char(16)整型：byte(8)，short(16)，int(32)，long(64)浮点型：float(32)，double(64)布尔型：boolean Java中，整型默认的是int，浮点型默认的是double，boolean型默认的是false 基本数据对应的类型我们称为包装类，char-character,int-Integer,double-Double,long-Long,float-Float 二
十二、servlet的生命周期：
事物的生命周期指的是从事物的产生，生存，发展到消亡的过程。
init()调用一次，一般第一次访问Servlet时调用。默认调用有参数的，除非只有无参数的。
service()调用多次，每次访问时调用。
destroy()调用一次，应用程序关闭时调用
二十三、抽象类和接口的区别：
1、abstract class在java中表示一种继承关系，一个类只能使用一次继承关系。但是一个类可以实现多个接口interface。
2、在abstract class中可以有自己的数据成员，也可以有非abstract的成员方法，而在interface中，只能有静态的不能被修改的数据成员，所有的成员方法都是abstract的
3、Abstract class和interface所反映的设计理念不同。Abstract class表示的是“is-a”的关系；interface表示的是“like-a”的关系
4、实现抽象类和接口的类必须实现其中的所有方法。抽象类中可以有非抽象方法。接口中不能有实现方法。
5、接口中定义的变量默认是public static final 类型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。
6、抽象类中的变量默认是friendly类型，其值可以在子类中重新定义，也可以重新赋值。
7、接口中的方法默认都是public，abstract类型的。
第二篇：JAVA总结专题
在这忙忙碌碌的这段时间里，经过老师的辅导，迅速的将一点没有学的JAVA基础搞定了！有了基础学习还是好，万事开头难这句话说的太对了，学计算机语言我觉得记忆好的方法就是多打代码，课前预习，课堂上认真听讲，把现学的方法把以前所做的作业用最简便的方法再一次巩固，创新最重要，在后续的学习中，得要加倍努力学习。
其实学java有不懂，要先自己思考。想清楚这句代码是什么意思。为什么要写在这，等等之类的。等你真的搞不明白的时候，就一定要向老师咨询，不要感到有什么丢人的。因为不会是很正常的事。并不是每个人都是天才，一学就会，一学就能运用自如的。学java有一点是非常重要的，就是练习。一段代码要不停的敲，多敲几遍，尤其是自己不熟悉或者不熟练的代码，更要敲。不要感觉到厌烦，其实我感觉敲代码挺好玩的，并不是一件很枯燥的事。
老师平常布置的课后上机练习题一定要做，课后的练习题能够让你把新学到的知识巩固一遍，能够加深记忆，不会让你在以后做题的时候感到没一点思路。
当感觉到不会的时候，千万不要气馁，因为这很正常，现在的学习就是为了培养你有一个逻辑思维，为了以后开发软件的时候有个完整，清晰的思路。
其实，总体来说。学习java很快乐。尤其是当你遇到一道自己不会的题，然后，又通过自己的努力解决了，那时候，那种心情不是用言语来表达的。就好像你遇到一个数学难题，自己解决了之后那种成就感一样。
学java的时候一定要，放松心情，轻轻松松的来学，随时让自己快乐着，这样能够让你能够更快的接受java，千万不要有什么心理负担，因为java的特点之一就是--简单易懂。只要自己努力到了，就一定能够学好java。
学完了JAVA今天我们用项目案例：迷你DVD管理器来巩固了我们所学的所有内容，通过这项目的操练，首先，1、项目用到了会使用顺序、分支、循环、跳转语句编写程序，2、要会使用数组、操作字符串，3、会使用带参的方法；
4、会定义类、创建和使用对象，看到这些脑袋里一片迷茫啊！不知道怎样写，然后想到早写晚写都一样，就照着书上写起来了，到现在还是弄不懂的就是那个对象数组，不知道怎样去理解，抽象的把我抽晕了，有望老师来给我们补补这一章，在实现DVD的业务处理时，计算时差还是不懂，照着书上打了一遍，可还是得不到想要的结果，经过网上的搜寻与老师讲解，现在已略懂一二了，在做完这项目后，真不知道当时是怎样敲出来的，难道这就是所说的灵感！感觉很高兴，现在已习惯了代码报错，其实代码报错是一件值得鼓励的事，因为没有错就觉得自己什么都懂了，在学习中相信每一个人都遇到过挫折吧！但一定要想方法战胜挫折！我的战胜挫折方法就是不懂思考后还不懂就问，懂了以后就笔记本记下当时的解决方案！学习刚开始！后面的路很长，慢慢的去磨炼了！总结完毕！
第三篇：Java总结
Java实验
1.调试HelloWorld程序
2.this,super,get ,set,把课本90页程序4.7中的name改成私有变量
3.继承，重写，父类引用指向子类对象
4.验证数组Arrays类和Collection类
5.编写一个自己的异常类并捕获之。
6.编写一个类，将该类的几个对象装入TreeSet容器中，并将该容器的内容通过输出流写入文件中。
前三章重点
0.java的数据类型：四类八种-（1）布尔类型Boolean;(2)字符类型char;(3)整数byte,short,int,long;(4)浮点类型：float,double;1.面向对象的3个基本特征：封装，继承，多态。
2.构造方法和普通方法的区别：对构造方法而言，它有以下特性---（1）方法名必须与要创建对象的类名相同。（2）不允许声明返回类型，即使声明为void也不被允许。
3.this关键字:是一个引用，this引用指向的是其本身所在方法的当前对象。this的使用方法:(1)调用成员变量；（2）可以用this()调用其他构造函数。
4.java中只对类成员变量进行自动初始化，而方法内部的局部变量在使用前必须手动初始化。
5.static 关键字：可用来修饰类的成员变量和成员方法，需要注意两点--（1）静态方法不能调用类的非静态方法，不能访问类的非静态变量。（2）静态方法和静态变量（非私有的）可以有两种调用方式，一是实例对象调用，二是类名直接调用。
6.类成员访问控制修饰符public、private、default(可不写，即缺省状态)、protected的使用：public-公用的；private-私有的，只在定义它的类内部使用；default-可以被同一包中的类访问；protected-既可以被同一包中的类访问，也可以被不在同一包中的子类访问。
7.方法的重载：指方法名相同，而方法的参数列表不相同。参数列表不同有三层意思：（1）参数类型不同。（2）参数顺序不同。（3）参数个数不同。另外需注意，在同一个类中，当方法名和参数列表都相同时，访问控制修饰符或方法返回类型不相同并不是方法的重载，而且这种情况在java中是不被允许的。
第四五章重点
1.继承：需使用关键字extends.在使用继承时需注意--（1）每个子类只能定义一个超类（父类），即extends后面应且仅应跟一个类名作为该类的父类。（2）父类中的私有属性和私有方法不能被继承。
2.方法的重写：即子类对超类中的方法保持方法名、返回类型和参数列表不变，重写了方法体，使子类和超类完成不同的工作。重写需注意下面几个关键点：（1）超类中的私有方法不能被重写。（2）访问限制符强度由低到高依次是：public、protected、default、private,在重写过程中，如果子类和父类中方法的返回值、方法名及方法的参数列表都相同，这时，要求子类中该方法的访问限制符强度不能超过父类的。即如果父类中为public时，子类也只能为public,而不能是余下的三种。
3.重载（overload）和覆盖（override）的区别：(1)重载—发生在一个类的内部或子类与父类之间，要求方法名相同而参数列表不一样。（2）覆盖—只能发生在继承过程中，要求子类方法的返回类型，方法名和参数列表同父类的都相同，而方法体不一样。
4.构造器的调用顺序：先祖先，再客人，最后自己。
5.多态：指在类继承中子类和父类中可以有同名但意义或实现方式不同的属性和方法。分为：覆盖和重载。多态的优点：因为多态，可以在程序中对类进行扩展，而不需改变那些操作基类接口的方法。
6.动态绑定：指在代码执行期间，判断所引用对象的实际类型，根据其实际类型调用相应方法。动态绑定存在的三个必要条件--（1）要有继承；（2）要有重写（覆盖）；（3）父类引用指向子类对象（向上转型）。
7.Object中常用的方法总结：toString();wait();equals();notify();notifyAll();hashCode();getClass();clone();finalize();（呵呵，尽可能记几个，以防老师让咱们列举）注：java中Object类是所有类的父类，即java中所有的类都有上述9种方法。
8.对象的比较：注意关键字instanceof的使用。
9.抽象类：
抽象方法—用关键字abstract修饰的方法，该方法只需方法的声明，而不需方法的实现（即无方法体）。
抽象类——至少包含一个抽象方法的类，也用abstract关键字声明。（注：（1）抽象类中可以有一些具体方法。（2）抽象类不能实例化。（3）子类继承抽象类必须实现其抽象方法。）
10.接口：
（1）可以看成是高度抽象的抽象类，但是接口不是类。
（2）用关键字interface来声明接口，用关键字imlpements来实现接口。
（3）接口不能有具体方法，不能有实例数据，但可以定义常量。
（4）实现接口的非抽象类必须实现接口的所有方法。
（5）每个类可以实现多个接口，这些接口用逗号隔开，同时，一个接口可以被多个类实现。
第六章：重点看一下实验四
1.容器——Collection(接口)和Map（接口）.Collection——Set(接口)和List(接口)。其中，List必须保持元素的特定顺序，常见的实现类有ArrayList和LinkedList；Set不能有重复元素,常见的实现类有HashSet和TreeSet。
Map——一组成对的“键值对”对象，即其元素是成对的对象，常见的实现类有HashMap和TreeMap。
第七章 1.异常类的根类是Throwable类，它的两个直接子类是Error类和Exception类。
2.异常中常用的5个关键字为：try,catch,finally,throw,throws.其中，try和catch:用于捕获异常；finally:无论try块中的异常是否抛出，finally中的代码块总能被执行；throw:抛出异常；throws：声明异常。
3.“未被检查的异常（Unchecked Exceptions）”和“受检查的异常(Checked Exceptions)”——
Unchecked Exceptions :编译器不检查方法是否处理或抛出的异常，即不做处理，编译时不报错。
Checked Exceptions：受编译器检查的异常，即不做处理编译时通不过。
4.常见的几种Checked Exceptions：ClassNotFoundExceptionIOExceptionInterruptedExceptionFileNotFoundException.(尽可能的记几个吧，以防不测)第八章
1.流--字节流和字符流；
流--节点流和处理流。
2.所有的输入流都是从抽象类InputStream和Reader继承而来。所有输出流都是从抽象类OutputStream和Writer继承而来。3．字节流：InputStream和OutputStream;字符流：Reader和Writer；
4.节点流：直接与文件等底层打交道，如FileInputStreamFileOutputStreamFileReaderFileWriter.处理流：相当于包装流，套在节点流上，方便数据处理。相关一些用法，具体参考最后一次实验。
第四篇：java总结
调用父类构造方法
在子类的构造方法中可使用super(argument_list)语句调用父类的构造方法
如果子类的构造方法中没有显示地调用父类构造方法，也没有使用this关键字调用重载的其它构造方法，则系统默认调用父类无参数的构造方法
如果子类构造方法中既未显式调用父类构造方法，而父类中又没有无参的构造方法，则编译出错
1public class Person {
3private String name;
4private int age;private Date birthDate;
7public Person(String name, int age, Date d){ 8this.name = name;
9this.age = age;
10this.birthDate = d;
11}
12public Person(String name, int age){ 13this(name, age, null);
14}
15public Person(String name, Date d){ 16this(name, 30, d);
17}
18public Person(String name){
19this(name, 30);}
21// ……
22}
1public class Student extends Person {
2private String school;
4public Student(String name, int age, String s){ 5super(name, age);
6school = s;
7}
8public Student(String name, String s){
9super(name);
10school = s;
11}
12public Student(String s){ // 编译出错: no super()13school = s;
14}
15}
对象构造和初始化细节
分配存储空间并进行默认的初始化
按下述步骤初始化实例变量
1.绑定构造方法参数
2.如有this()调用，则调用相应的重载构造方法，然后跳转到步骤5
3.显式或隐式追溯调用父类的构造方法(Object类除外)
4.进行实例变量的显式初始化操作
5.执行当前构造方法的方法体
==操作符与equals方法
==操作符与equals方法的区别：
引用类型比较引用；基本类型比较值；
equals()方法只能比较引用类型，“==”可以比较引用类型及基本类型；
特例：当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个实例；
用“==”进行比较时，符号两边的数据类型必须一致(可自动转换的基本数据类型除外)，否则编译出错；
由装箱引发的——Integer比较的来龙去脉
前置知识： 众所周之，java是保留了int，char等基本数据类型的，也就是说int类型的并不是对象，然而有些方法却需要object 类型的变量，所以java使用了装箱机制，我们可一自豪的这样声明一个整型变量：Integer a = new Integer(10);那么整型的a也就是对象了，那这句是什么意思呢：Integer a= 10;java中可以这样声明一个对象吗？当然不是，从jdk1.5后，java实现了自动装箱，也就是自动将Integer a =10 中的int类型的10转化为了 Integer类型。好，有了前面的只是我们且先看一个题目：
Integer a = 127;
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a==b);
System.out.println(c==d);
答案是什么呢？ 如果您回答true，false，那么很遗憾的告诉你，哈哈，其实你答对了！！
那我们晕了就相差1的两个数为啥走向了“反目成仇”的地步呢？凭啥127等于127，我128就不等于128呢？且听我慢慢道来，Integer a =127,Integer a=128。
127，128应该不会造成什么差异吧，难道是自动装箱的过程有猫腻？找下源码看看：
private static class IntegerCache {
private IntegerCache(){}
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i128);
}
这是用一个for循环对数组cache赋值，cache[255] = new Integer(255-128),也就是newl一个Integer(127),并把引用赋值给cache[255],好了，然后是Integer b= 127,流程基本一样，最后又到了cache[255] = new Integer(255-128),这一句，那我们迷糊了，这不是又new了一个对象127吗，然后把引用赋值给cache[255]，我们比较这两个引用（前面声明a的时候也有一个）,由于是不同的地址，所以肯定不会相等，应该返回false啊！呵呵，这么想你就错了，请注意看for语句给cache[i]初始化的时候外面还一个{}呢，{}前面一个大大的static关键字大咧咧的杵在哪呢，对静态的，那么我们就可以回想下static有什么特性了，只能初始化一次，在对象间共享，也就是不同的对象共享同一个static数据，那么当我们Integer b = 127的时候，并没有new出一个新对象
来，而是共享了a这个对象的引用，记住，他们共享了同一个引用！！，那么我们进行比较a==b时，由于是同一个对象的引用（她们在堆中的地址相同），那当然返回true了！！
然后我们在看Integer c = 128;Integer d = 128;这两句。现在不用我说就应该能明白了吧，当数据不再-128到127之间时，是不执行return
IntegerCache.cache[i + offset];这句的，也就是不会返回一个static的引用，而是执行了return new Integer(i);于是当 Integer d = 128 时，又会重新返回一个引用，两个不同的引用
在做c==d 的比较时当然返回false了！
下面附上本程序的字节码以供喜欢底层的读者参考：
Compiled from “CompareInteger.java”
public class CompareInteger extends java.lang.Object{
public CompareInteger();
Code:
0:aload_0
1:invokespecial#1;//Method java/lang/Object.“
public static void main(java.lang.String[]);
Code:
0:bipush 127
2:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
5:astore_1
6:bipush 127
8:invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
11: astore_2
12: sipush 128
15: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
18: astore_3
19: sipush 128
22: invokestatic#2;//Method
java/lang/Integer.valueOf:(I)Ljava/lang/Int
eger;
25: astore 4
27: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
30: aload_1
31: aload_2
32: if_acmpne39
35: iconst_1
36: goto40
39: iconst_0
40: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V43: getstatic#3;//Field
java/lang/System.out:Ljava/io/PrintStream;
46: aload_3
47: aload4
49: if_acmpne56
52: iconst_1
53: goto57
56: iconst_0
57: invokevirtual#4;//Method java/io/PrintStream.println:(Z)V60: return
}
评论：呵呵，这么想你就错了，请注意看for语句给cache[i]初始化的时候外面还一个{}呢，{}前面一个大大的static关键字大咧咧的杵在哪呢，对静态的，那么我们就可以回想下static有什么特性了，只能初始化一次，在对象间共享，也就是不同的对象共享同一个static数据，那么当我们Integer b = 127的时候，并没有new出一个新对象来，而是共享了a这个对象的引用，记住，他们共享了同一个引用！！
呵呵，博主我被你这句话小小的误导了一下，其实你这里说的原理没错，但是把位置说错了，这段代码只是初始化cache：
static {
for(int i = 0;i < cache.length;i++)
cache[i] = new Integer(i-128);
}
但真正让cache[i]为static变量的是这句代码：
static final Integer cache[] = new Integer[-(-128)+ 127 + 1];
第五篇：Java个人总结参考
1、Java中取消指针运算防止了内存泄露的可能性。Java中的引用其实就是指针。JAVA语言不支持C++友元方法或友类。
2、编写完java源代码后，首先将其编译为一种中间状态字的字节码，然后Java虚拟机上的解释器来解释执行，“一次编程，到处运行”，Java是文本文件，编辑代码。
3、Window系统对于DOS命令中字符大小写不敏感；Java编译器和解释器对大小写敏感；保存源文件时，文件名一定要和源文件中公开类的类名一致。
4、习惯上，变量名以小写字母开头，类名以大写字母开头，常量名中所有的字符均大写。
5、final常量：初始化后不再重新赋值，在类继承时不允许子类覆盖。
6、类实例化就成为对象。
7、类继承：继承父类的属性和方法（关键字extends）
定义抽象类：关键字abstract
类声明：P62
类成员：P63
8、Java接口中声明了一组抽象方法，它构成了实现该接口的不同类共同遵守的约定。在类的定义中可以用关键字implements来指定其实现的接口。
9、Java接口与类的重要区别：Java接口中不存在构建器。
10、包的作用（P105）；Java中类的访问控制符（P77）；操作符优先级（P38）
11、包的命名：网络域名的逆序
包的使用：关键字import
12、异常处理（P119.120.125）：FileNotFoundException：代表文件未找到；SQLException：代表有关JDBC的异常；NullPointerException：表示试图引用null对象的方法或属性；IndexOutOfBoundException：表示数组越界的异常。
13、框架的默认关闭程序：f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
14、setIconImage用于设定框架的图标；setLocation用于设定框架在屏幕上的位置。
15、取得框架的内容窗格：Container contentPane=f.getContnetPane();
16、面板的默认布局管理器是FlowLayout。setBownds(x,y,w,h)设置x，y坐标以及宽和高
17、内容窗格的默认布局管理器是边框布局（BorderLayout）
18、网格布局（GridLayout）将容器划分为大小相同的网格。
19、网格袋布局（GridBagLayout）是最灵活，也是最复杂的布局管理器。20、对话框 P180
showMessageDialog：消息对话框
showInputDialog：输入对话框
showConfirmDialog：确认对话框
showOptionDialog：选项对话框
21、类File有三种常用构建器：
File（String fileName）
File（String directory ,String fileName）File（File directory ,String fileName）
22、位于java.io包中的类包含两组独立的类层次结构：一个用于读取字节，成为字节流；一个用于读写字符，称为字符流。区别在于它们处理数据的方式，字节流按字节（一个8位组）来处理。字节流（P243）字符流（P245）
23、System.in 表示系统标准输入流，指向键盘输入；System.out 表示系统标准输出流，指向屏幕输出；System.err 表示系统标准错误输出流，指向屏幕输出；
24、文件的读写工作包括三个步骤：①、打开文件输入流或输出流；②、文件读或写操作；③、关闭文件输入流或输出流；
25、定制线程类：①、继承线程类Thread；②、实现Runnable接口；
#约定俗成的命名规则#
1、类名首字母必须大写
2、方法和属性必须小写
3、由多个单词组成的类名或方法必须采用驼峰标识
如：类名：StudentAdmin 方法或属性：studentName
*Equal 匹配
*equalIgnoreCase 匹配时忽略大小写 *Indexof 包含
*getMetaDate 获取元数据 *精度转换
*面向对象三大特性：封装、继承、多态 *界面逻辑、业务逻辑、数据逻辑 *三层架构总结：
1、开发人员可以只关注整个结构中的其中某一层
2、可以很容易用新的实现来替换原有层次的实现
3、可以降低层与层之间的依赖
4、有利于标准化
5、利于各层逻辑的复用
点击咨询 