第一篇: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总结专题
在这忙忙碌碌的这段时间里,经过老师的辅导,迅速的将一点没有学的JAVA基础搞定了!有了基础学习还是好,万事开头难这句话说的太对了,学计算机语言我觉得记忆好的方法就是多打代码,课前预习,课堂上认真听讲,把现学的方法把以前所做的作业用最简便的方法再一次巩固,创新最重要,在后续的学习中,得要加倍努力学习。
其实学java有不懂,要先自己思考。想清楚这句代码是什么意思。为什么要写在这,等等之类的。等你真的搞不明白的时候,就一定要向老师咨询,不要感到有什么丢人的。因为不会是很正常的事。并不是每个人都是天才,一学就会,一学就能运用自如的。学java有一点是非常重要的,就是练习。一段代码要不停的敲,多敲几遍,尤其是自己不熟悉或者不熟练的代码,更要敲。不要感觉到厌烦,其实我感觉敲代码挺好玩的,并不是一件很枯燥的事。
老师平常布置的课后上机练习题一定要做,课后的练习题能够让你把新学到的知识巩固一遍,能够加深记忆,不会让你在以后做题的时候感到没一点思路。
当感觉到不会的时候,千万不要气馁,因为这很正常,现在的学习就是为了培养你有一个逻辑思维,为了以后开发软件的时候有个完整,清晰的思路。
其实,总体来说。学习java很快乐。尤其是当你遇到一道自己不会的题,然后,又通过自己的努力解决了,那时候,那种心情不是用言语来表达的。就好像你遇到一个数学难题,自己解决了之后那种成就感一样。
学java的时候一定要,放松心情,轻轻松松的来学,随时让自己快乐着,这样能够让你能够更快的接受java,千万不要有什么心理负担,因为java的特点之一就是--简单易懂。只要自己努力到了,就一定能够学好java。
学完了JAVA今天我们用项目案例:迷你DVD管理器来巩固了我们所学的所有内容,通过这项目的操练,首先,1、项目用到了会使用顺序、分支、循环、跳转语句编写程序,2、要会使用数组、操作字符串,3、会使用带参的方法;
4、会定义类、创建和使用对象,看到这些脑袋里一片迷茫啊!不知道怎样写,然后想到早写晚写都一样,就照着书上写起来了,到现在还是弄不懂的就是那个对象数组,不知道怎样去理解,抽象的把我抽晕了,有望老师来给我们补补这一章,在实现DVD的业务处理时,计算时差还是不懂,照着书上打了一遍,可还是得不到想要的结果,经过网上的搜寻与老师讲解,现在已略懂一二了,在做完这项目后,真不知道当时是怎样敲出来的,难道这就是所说的灵感!感觉很高兴,现在已习惯了代码报错,其实代码报错是一件值得鼓励的事,因为没有错就觉得自己什么都懂了,在学习中相信每一个人都遇到过挫折吧!但一定要想方法战胜挫折!我的战胜挫折方法就是不懂思考后还不懂就问,懂了以后就笔记本记下当时的解决方案!学习刚开始!后面的路很长,慢慢的去磨炼了!总结完毕!
第三篇:Java格式总结
Java定义格式:
1、数据类型的强制性转换语法:
(欲转换的数据类型)变量名称;
2、if语句的格式:
if(条件判断)
语句;
3、if语句的格式:
if(条件判断){ 语句1;
语句2;
…
语句3; }
4、if…else语句的格式:
if(判断条件){ 语句主体1; } else { 语句主体2; }
5、条件语句格式:
条件判断?表达式1:表达式2; 即:
If(条件判断){ 变量 x=表达式1; } Else { 变量x=表达式2; }
6、if…else if…else语句格式:
if(判断条件1){ 语句主体1; } else if(判断条件2){ 语句主体2; }
…
//多个else if语句 Else { 语句主体3; }
7、switch语句格式:
switch(表达式){ case 选择值1:语句主体1;
break;
case 选择值2:语句主体2;
break;
……
case 选择值n:语句主体n;
break;
default: 语句主体; }
8、while循环语句格式:
while(判断条件){ 语句1;
语句2; ……
语句n; }
9、do……while语句格式:
do { 语句1;
语句2;
……
语句n;
}while(判断条件)
10、for循环语句格式:
for(赋值初值:判断条件:赋值增减量){ 语句1;
……
语句n; }
11、break语句格式:
for(赋值初值:判断条件:赋值增减量){ 语句1;12、13、14、15、16、17、18、19、20、21、语句2; …….break;
……
//若执行break语句,此块内的语句都不再执行 语句n; } continue语句格式:
for(赋值初值:判断条件:赋值增减量){ 语句1;
语句2;
……
Continue;//若执行continue语句,此块内的语句不再执行
……
语句n; } 一维数组的声明与分配内存格式:
数据类型
数组名[];
//声明一维数组
数组名=new 数据类型[个数];
//分配内存给数组 声明数组的同时分配内存格式:
数据类型 数组名[]=new 数据类型[个数] 数组长度的取得格式: 数组名.length 数组初值的赋值格式:
数据类型 数组名[]={初值0,初值1,…,初值n}; 二维数组的声明格式: 数据类型 数组名[][];
数据名=new 数据类型[行的个数][列的个数]; 二维数组色声明及分配内存格式:
数据类型 数据名[][]=new 数据类型[行的个数][列的个数]; 二维数组初值的赋值格式:
数据类型 数组名={{第0行初值},{第1行初值},……
{第n行初值} };
取得二维数组的行数与特定行的元素的个数格式: 数组名.length
//取得数组的行数
数组名[行的索引].length
//取得特定行元素的个数 声明方法并定义内容格式:
返回值类型 方法名称(类型 参数1,类型 参数2,…){ 程序语句;
return 表达式;22、23、24、25、26、27、28、} 类的定义格式: class 类名称 { 数据类型 属性;
……
返回值的数据类型 方法名称(参数1,参数2…){ 程序语句;
return 表达式; } } 对象的产生格式:
类名 对象名=new 类名();
访问对象中某个变量或方法格式: 访问对象:对象名称.属性名 访问方法:对象名称.方法名()封装类中的属性或方法格式:
封装属性:private 属性类型 属性名
封装方法:private 方法返回类型 方法名称(参数)构造方法的定义格式: class 类名称 { 访问权限 类名称(类型1 参数1,类型2 参数2,…){
程序语句;
…
//构造方法没有返回值 } } 定义内部类格式:
标识符 class 外部类名称 { //外部类的成员
标识符 class 内部类的名称 {
//内部类的成员 } } 类的继承格式
class父类
//定义父类 { } class 子类 extends 父类
//用extends关键字实现类的继承 {29、30、31、32、33、34、35、} Super调用父类中的属性或方法格式: super.父类中的属性; super.父类中的方法();
子类复写父类中的方法的格式: class Super { 访问权限 方法返回值类型 方法1(参数1)
{ } } class Sub extends Super { 访问权限 方法返回值类型 方法1(参数1)//复写父类中的方法
{ } } 抽象类的定义格式:
abstract class 类名称
//定义抽象类 { 声明数据成员;
访问权限 返回值的数据类型 方法名称(参数…)
{ } abstract 返回值的数据类型 方法名称(参数…);
//定义抽象方法,在抽象方法里,没有定义处理的方式 } 接口的定义格式:
Interface 接口名称
//定义抽象类 { final 数据类型 成员名称=常量;
//数据成员必须赋初值
abstract 返回值的数据类型 方法名称(参数…);
//抽象方法,注意在抽象方法里,没有定义处理的方式 } 接口的实现格式:
class 类名称 implements 接口A,接口B
//接口的实现 { …… } 接口的扩展格式:
Interface 子接口名称 extends 父接口1,父接口2,… { …… } 异常处理的语法格式: try36、37、38、39、40、41、{ 要检查的程序语句;
… } catch(异常类 对象名称){ 异常发生时的处理语句; } finally { 一定会运行到的程序代码; } 抛出异常的语法格式: Throw 异常类实例对象; 由方法抛出异常格式:
方法名称(参数…)throws 异常类1,异常类2,… 编写自定义异常类格式:
class 异常名称 extends Exception { …… } Package的声明格式: Package package名称; package的导入格式:
import package名称.类名称; 由键盘输入数据基本形式格式: Import java.io.*;Public class class_name
//类名 { Public static void main(String args[])throws IOException { BufferedReader buf;//声明buf为BufferedReader类的变量
String str;//声明str为String类型的变量
……
Buf=new BufferedReader(new InputStreamReader(System.in));//产生buf对象
Str=buf.readLine();
//读入字符串至buf …… } }
第四篇: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、利于各层逻辑的复用