数学建模社区-数学中国

标题: [转帖]Java入门需掌握的30个基本概念 [打印本页]
作者: god    时间: 2005-3-31 01:13
标题: [转帖]Java入门需掌握的30个基本概念
Java的白皮书为我们提出了Java语言的11个关键特性  
0 V, P3 |; J# ^1 _9 i( x# n1 g) o7 \% ?6 A+ Q/ `
　　(1)Easy:Java的语法比C++的相对简单，另一个方面就是Java能使软件在很小的机器上运行，基础解释其和类库的支持的大小约为40kb，增加基本的标准库和线程支持的内存需要增加125kb。  ; z3 `3 n4 a; \% x, _
, @# a$ F9 H! J$ v+ ]* t
　　(2)分布式:Java带有很强大的TCP/IP协议族的例程库，Java应用程序能够通过URL来穿过网络来访问远程对象，由于servlet机制的出现，使Java编程非常的高效，现在许多的大的web server都支持servlet。  , ~/ s; A* m1 y) Z  X

( S9 i/ M. R, h0 `6 E6 M　　(3)O面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同，在与多重继承的处理及Java的原类模型。  " K7 t3 j, K- \1 a  n
6 y- c: N9 s1 H* S/ Q$ j) ^
　　(4)健壮特性:Java采取了一个安全指针模型，能减小重写内存和数据崩溃的可能型。  ; |3 V% h2 R" F5 z/ C
6 l* M  \% F$ z% @2 ]
　　(5)安全:Java用来设计网路和分布系统，这带来了新的安全问题，Java可以用来构建防病毒和防攻击的System.事实证明Java在防毒这一方面做的比较好。  ' d% s  p- p! \" B! Q

# z/ |# _& ~& {) \9 j; K. j　　(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行，编译器产生的指令字节码(Javabytecode)实现此特性，此字节码可以在任何机器上解释执行。  
) i3 K4 d' c6 v3 ]. H# V5 F4 a4 z6 o0 K/ c" e+ _5 ]) }
　　(7)可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植性很好。  : d0 Z/ c/ \! \

$ _' u/ l4 [3 m: P/ ?: |1 @　　(8)多线程:Java处理多线程的过程很简单，Java把多线程实现交给底下操作系统或线程程序完成.所以多线程是Java作为服务器端开发语言的流行原因之一。  
8 u7 e  t$ @5 y+ y* r
; x" z- E0 m" \. T　　(9)Applet和servlet:能够在网页上执行的程序叫Applet，需要支持Java的浏览器很多，而applet支持动态的网页，这是很多其他语言所不能做到的。  
* w9 R3 |' A) O6 s0 b
( |/ w; y5 h* R# D, e　　基本概念  
$ W" N' q1 {$ t$ _7 X0 Q3 Q* B* ]! H+ p2 n; `& g: O4 n
　　1.OOP中唯一关系的是对象的接口是什么，就像计算机的销售商她不管电源内部结构是怎样的，他只关系能否给你提供电就行了，也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的，不同的对象的访问通过函数调用来完成，对象间所有的交流都是通过方法调用，通过对封装对象数据，很大限度上提高复用率。  
' F# L. q& _+ D) K
$ {. S$ O- V/ W% D3 S' w+ G　　2.OOP中最重要的思想是类，类是模板是蓝图，从类中构造一个对象，即创建了这个类的一个实例(instance)。  
3 X0 s& Z% X6 H: h9 L% Q. M
, C; c( P/ L" T6 v. Q8 l　　3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程，一个对象中的数据叫他的实例字段(instance field)。  0 a5 i. v% }5 f3 Y: p
5 k& k# X# q- h3 `% O
　　4.通过扩展一个类来获得一个新类叫继承(inheritance)，而所有的类都是由Object根超类扩展而得，根超类下文会做介绍。  
. q4 l- X. I) `2 Q( o$ ^/ T' r8 w/ Z
　　5.对象的3个主要特性  9 C; Z, H2 k$ ~0 }! C
* N7 \8 E9 d4 g4 v3 H3 \7 O1 J
　　behavior---说明这个对象能做什么.  2 b: F: W/ d0 j1 \/ N
' X4 y3 m  v( b) d; \, S. D+ X) C
　　state---当对象施加方法时对象的反映.  ' V8 W: R6 c  i2 u: j( u
$ D: C; o$ q6 L6 f  _- [
　　dentity---与其他相似行为对象的区分标志.  
9 Y2 Z3 |0 r( m1 T+ l1 ?" H) H  P* c/ O5 U0 S- j3 K2 C
　　每个对象有唯一的indentity 而这3者之间相互影响.  
; G5 e: V+ O% j3 w; q0 {6 z/ Y8 A7 l
　　6.类之间的关系:  
: u- z* ^: \/ j* ]
7 K. @( y+ u4 x- _/ q, ?" H5 Z# {　　use-a :依赖关系  
, }  Y0 y' e1 s0 _- [# I# t9 _  s7 _' j
　　has-a :聚合关系  
- _, w  ~2 j, O
, T( b* c" F+ {: W　　is-a :继承关系--例:A类继承了B类，此时A类不仅有了B类的方法，还有其自己的方法.(个性存在于共性中)  - {# g* w- [3 C5 ]
  a+ i' k: X& M* W5 e
　　7.构造对象使用构造器:构造器的提出，构造器是一种特殊的方法，构造对象并对其初始化。  
" M( W$ ^5 t% c4 j+ m, Z& n4 @& q, Z4 @  J" @) K7 z+ T
　　例ata类的构造器叫Data  
& A5 e8 |. T; b- f/ y& [: x7 A0 X9 S# n6 c
　　new Data()---构造一个新对象，且初始化当前时间.  
# B5 `! X2 X. P
, y  i* j: O* u　　Data happyday=new Data()---把一个对象赋值给一个变量happyday，从而使该对象能够多次使用，此处要声明的使变量与对象变量二者 1 }# H, s0 g$ ~5 q
是不同的.new返回的值是一个引用。  
0 U' w; R& G# X& K. C/ k' ?* v  n
- _7 x- Z# b0 w$ c3 q5 `6 E2 v　　构造器特点:构造器可以有0个，一个或多个参数  
; A7 v4 I+ V$ J5 ~# f& v* g6 j0 Y
! v4 B+ f5 ]" d% C3 R" X　　构造器和类有相同的名字  " a9 @  B4 V8 J0 ~( m
6 d# a) z0 N% t+ g& {) X
　　一个类可以有多个构造器  $ L: V* Q- {) _, o. m/ A1 i
8 E) q2 y5 q8 F* ~" Z
　　构造器没有返回值  
4 D- ~3 k3 k3 X* A9 [4 F3 Z: N
0 d3 X+ H/ p" {# l% u6 Z　　构造器总是和new运算符一起使用.　　 $ M# ^; q2 v, ?3 j# s* y; |
　　8.重载:当多个方法具有相同的名字而含有不同的参数时，便发生重载.编译器必须挑选出调用哪个方法。  + Q) F. k! h  R

* g: M0 r) ?& T7 ]4 {　　9.包(package)Java允许把一个或多个类收集在一起成为一组，称作包，以便于组织任务，标准Java库分为许多包.java.lang java.util java，net等，包是分层次的所有的java包都在java和javax包层次内。  0 K* \0 z1 m" ]$ b8 i# J# g% g3 k
1 b# e8 H3 g3 f. q2 {, J/ R
　　10.继承思想:允许在已经存在的类的基础上构建新的类，当你继承一个已经存在的类时，那么你就复用了这个类的方法和字段，同时你可以在新类中添加新的方法和字段。  % }" K% T/ ]1 f) s$ i: ^
$ I2 A0 h1 D, \- k2 X$ n5 {7 j
　　11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类)。  
% S( }: _9 d- S0 r& Q8 ]$ i) I' ^. W/ \. m; A, {' L  J$ Y+ i1 k% C# O
　　12.多态:在java中，对象变量是多态的.而java中不支持多重继承。  
$ \' K  A" X+ g' x" A6 Z9 U' M, ?
' |# [, v" M( ^% [: u" A7 p1 W! j　　13.动态绑定:调用对象方法的机制。  
6 i1 D7 d! s- i- I1 {2 X. b
3 u7 [$ L" v1 \9 ]/ D* m/ {　　(1)编译器检查对象声明的类型和方法名。  
# \0 i% c. x# m1 {* u" t& g$ i; M- @2 ]
　　(2)编译器检查方法调用的参数类型。  ) c: [6 ]0 D$ ~( H) ?% v0 A* p" Z
$ T8 e  t9 ~( m
　　(3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法。  1 k4 w. m; m4 T9 B( i: ]
4 Y4 o! R* S  u8 c
　　(4)当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本。  
- L4 {1 q: ^- J1 c
( i. M: q* x3 B5 C: `8 G　　(5)动态绑定:是很重要的特性，它能使程序变得可扩展而不需要重编译已存代码。  # _/ u6 V, z! C- P) f
1 o! D2 X% \/ [* p' h$ X
　　14.final类:为防止他人从你的类上派生新类，此类是不可扩展的。  
+ o7 q1 b# ?$ q" x# }
- s$ W8 |% T7 y4 P- z& E2 t  W6 X　　15.动态调用比静态调用花费的时间要长。  3 M- i/ h, @1 H. i" K
& c* k, {. M6 N6 b2 F6 \* B
　　16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract。  ) T; O* t1 H0 H: v) m

) ]0 M& I- p/ }9 I　　例: public abstract string getDescripition  
0 J0 J) V' n+ H
% w+ q. B/ V/ }# d! a  J　　17.Java中的每一个类都是从Object类扩展而来的。  ) G. U; {& c( l) R% q

+ w) a! I5 C1 s8 R: M( B% u- y, T　　18.object类中的equal和toString方法。  , M+ X8 S% d6 n+ D! P3 G
0 p# A9 M3 T3 p. |9 n) N
　　equal用于测试一个对象是否同另一个对象相等。  9 ?" G: g. c! j  Z1 P/ X% \

2 `) S- y: R( d& [$ ]1 Q　　toString返回一个代表该对象的字符串，几乎每一个类都会重载该方法，以便返回当前状态的正确表示.  : d# D0 e) U$ g) z) Q; P

0 y% L  t$ n5 R! R$ |5 C　　(toString 方法是一个很重要的方法)  7 k* i4 ^2 z  H( {0 H$ o6 }

; v0 o0 A0 E; S  [$ K$ |　　19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。  
; v2 @4 x! ?0 k" X% z! R( ^
0 w) v8 s$ B' Z" C6 B　　20.数组列表:ArrayList动态数组列表，是一个类库，定义在java.uitl包中，可自动调节数组的大小。  4 J* q# u2 x: I; X# {) [  N7 b$ r

2 }% ^6 V. l8 ?　　21.class类 object类中的getclass方法返回ckass类型的一个实例，程序启动时包含在main方法的类会被加载，虚拟机要加载他需要的所有类，每一个加载的类都要加载它需要的类。  , t* O  T% |& n
+ M$ Q# l3 a" b
　　22.class类为编写可动态操纵java代码的程序提供了强大的功能反射，这项功能为JavaBeans特别有用，使用反射Java能支持VB程序员习惯使用的工具。  - P7 U* ^" |, u9 g; x! i0 _4 M

0 P" O5 c  V) c) S' o　　能够分析类能力的程序叫反射器，Java中提供此功能的包叫Java.lang.reflect反射机制十分强大.  5 ]* Q% S7 O3 j0 T; s- I$ z

9 {. I+ U7 c# \7 c5 m/ E& A4 b# R% ^' B　　1.在运行时分析类的能力。  
: R+ W+ p/ `0 q9 L: {" @; a. |. K' e# Q- S2 t/ J5 d+ A
　　2.在运行时探察类的对象。  " U+ `, p6 O. r! o$ w0 P' U( l

( S6 }( p0 ?( t4 G　　3.实现通用数组操纵代码。  
5 m4 [( T3 v% n) x. m# `' ?3 r8 ]' ]2 [% @- ~4 X: M, J; w+ N9 R
　　4.提供方法对象。  
* O9 I3 V$ k( z　　而此机制主要针对是工具者而不是应用及程序。  6 _  g8 G9 T" i$ u/ e& R$ E# b4 y

" g, }' n+ }" K' |3 f) y1 B　　反射机制中的最重要的部分是允许你检查类的结构.用到的API有:  
4 M  o' w) Z, i) a0 v% O: e; `, \7 v" r9 Q: R9 S3 _
　　java.lang.reflect.Field 返回字段.  
% F4 |& V" j) Z. E- e3 L3 |7 z& B( Q- I; X' r. @" q2 }
　　java.reflect.Method 返回方法.  
" N# D9 I: m) A. g9 l" c; N4 R
) Q9 f7 o5 M( ~3 f　　java.lang.reflect.Constructor 返回参数.  
& {0 R4 q  F3 m: _0 |8 {8 g" H4 ^% E& v
　　方法指针:java没有方法指针，把一个方法的地址传给另一个方法，可以在后面调用它，而接口是更好的解决方案。  
/ @9 C% t+ W7 S9 s2 h* u- Z9 b3 i
! n. x: p, i, U! S& k( C7 _　　23.接口(Interface)说明类该做什么而不指定如何去做，一个类可以实现一个或多个interface。  3 |: X* X: C3 X8 G

9 e1 L6 l; C9 n& D6 F5 a, H0 |　　24.接口不是一个类，而是对符合接口要求的类的一套规范。  
( L8 H' ?! n2 M# ~' z( O6 [- r0 _" I5 h# N% p# R% S; I
　　若实现一个接口需要2个步骤:　  ( i3 }6 K6 f3 @0 `$ ]

; @0 g/ |& H8 Z* U& k2 }　　1.声明类需要实现的指定接口。  
7 ?9 C7 O4 d. X* {" L, B' G
# O6 I' h3 S: a6 J3 B, `　　2.提供接口中的所有方法的定义。  7 L. ?" @. n4 N* H1 `2 Z+ P

1 z6 h5 e4 w0 k1 b　　声明一个类实现一个接口需要使用implements 关键字  / n; J7 e9 s) T% c) ~, ?

, P1 R, d, Z: D: {8 ~　　class actionB implements Comparable 其actionb需要提供CompareTo方法，接口不是类，不能用new实例化一个接口.  , C  u$ z. n2 f; S4 z

; o6 S- e" Y  v　　25.一个类只有一个超类，但一个类能实现多个接口。Java中的一个重要接口：Cloneable  
- t$ t, Z8 @8 k" o( e2 z6 ]" ~/ ?* u9 M. r
　　26.接口和回调.编程一个常用的模式是回调模式，在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。  
! V( l( ^/ J* O4 {% D2 `- {, R3 @8 l$ C
　　例:ActionListener 接口监听.  
# G# S$ X+ ?9 Q4 f% M: }* H/ v# M. t* q9 s! _7 C
　　类似的API有:java.swing.JOptionPane  
; m9 B* C5 J, ~7 W7 ]/ A5 H
1 h4 p* T6 q9 B& f; m9 x　　java.swing.Timer  
0 f9 f6 n6 }0 w! Q+ H. e. [; y/ F  e$ q' @3 {/ r
　　java.awt.Tookit  
& H7 T- C: @) ?# p
! z6 y6 x: s  {7 \& u( W　　27.对象clone:clone方法是object一个保护方法，这意味着你的代码不能简单的调用它。  - @" l, U4 @2 a
* V$ W; G+ J% Q
　　28.内部类:一个内部类的定义是定义在另一个内部的类。  2 u( n* m$ U( C( o; F, B, d$ p
: N2 G/ s; l) O# |8 R( [
　　原因是:  
9 s' q* L; T; \
2 [0 g7 |! s, o8 p& K4 h　　1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。  
/ `7 O8 ]- S3 j- D7 j1 `* _5 L& G! b* Q7 m% Y2 |
　　2.对于同一个包中的其他类来说，内部类能够隐藏起来。  & r' p- L8 d$ p; g
1 L# @, ^  C! ^! V& c, y
　　3.匿名内部类可以很方便的定义回调。  
/ F; h( S7 r' t* N/ O/ l) W, ^$ A& F% I4 O$ x6 e9 j- `
　　4.使用内部类可以非常方便的编写事件驱动程序。  
* ]7 M& v# E' }# F+ a) S+ x+ D9 D8 Y, a4 A2 g# X: H
　　29.代理类(proxy):  
5 t2 N; P! N+ X7 X( b% W9 i; |5 ]$ n
; O4 D0 Q4 G. A. E　　1.指定接口要求所有代码  , A% f8 k9 k4 b* h) ^. Q

1 G0 @- b' X* I- V' N" ^　　2.object类定义的所有的方法(toString equals)  
9 ?" X0 J7 }4 W5 z7 ^6 G. K. U8 Y; S, J0 M4 X
　　30.数据类型:Java是强调类型的语言，每个变量都必须先申明它都类型，java中总共有8个基本类型.4种是整型，2种是浮点型，一种是字符型，被用于Unicode编码中的字符，布尔型。



欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5