2023年java基础知识点总结.docx

《2023年java基础知识点总结.docx》由会员分享，可在线阅读，更多相关《2023年java基础知识点总结.docx（24页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、Cre a ted b y Alwen on 2023/5 / 1 4 .java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义 的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特性，而对象则是类的具 体存在，j a va程序使用类的构造器来创建该类的对象。Aja v a也支持面向对象的三大特性:封装、继承、和多态。j a v a提供了 p rivat e p r otec t ed和public 三个访问控制修饰符来实现良好的封装，提供了 ex t ends关键字让子类继承父类,子类继承父类就可以继承到父类的

2、成员变量和和方法，假如访问控制允许，子类实例可以直接调用父类里定义的方法。继承是实现类复用的重要手段。 使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性。面向对象的程序设计过程中有两个重要的概念：类（Class）和对象（obj ect,也被称为实例，in s tance） o类可 以包含三种最常见的成员:构造器、成员变量、和方法。a构造器用于构造该类的实例,java语言通过new关键字类调用构造器，从而返回该类的实例。构造器是一个类创建 对象的主线途径，假如一个类没有构造器，这个类通常无法创建实例。因此java语言提供了一个功能：假如程序员 没有为一个类编写构造器，则

3、系统会为该类提供一个默认的构造器，这个构造器总是没有参数的。一旦程序员为一个 类提供了构造器,系统将不再为该类提供构造器。构造器用于对类实例进行初始化操作，构造器支持重载，假如多个重载的构造器里包含了相同的初始化代码，则可以 把这些初始化代码放置在普通初始化块里完毕,初始化块总在构造器执行之前被调用。静态初始化块代码用于初始化 类，在类初始化阶段被执行。假如继承树里某一个类需要被初始化时，系统将会同时初始化该类的所有父类。构造器修饰符:可以是public、pr o t e c t ed、priva t e其中之一，或者省略构造器名：构造器名必须和类名相 同。注意:构造器既不能定义返回值类型，也

4、不能使用void声明构造器没有返回值。假如为构造器定义了返回值类型， 或使用v o id声明构造器没有返回值，编译时不会犯错,但j ava会把这个所谓的构造器当成方法来解决一一它就不 再是构造器。超事实上类的构造器是有返回值的，当使用new关键字来调用构造器时,构造器返回该类的实例,可以把 这个类的实例当成构造器的返回值。因此构造器的返回值类型总是当前类，无须定义返回值类型。不要在构造器里显 式的使用return来返回当前类的对象，由于构造器的返回值是隐式的。占java类名必须是由一个或多个故意义的单词连缀而成的，每个单词首字母大写，其他字母所有小写,单词与单词之 间不要使用任何分隔符。A2

5、.查找当前类中是否包含名为a的成员变量.查找a的直接父类中是否包含名为a的成员变量，一次上溯a的所有父类，直到j a va. Ian g. Obje c t类,假如最 终不能找到名为a的成员变量，则系统出现编译错误。假如被覆盖的是类变量,在子类的方法中则可以通过父类名作为调用者来访问被覆盖的类变量当程序创建一个子类对象时,系统不仅会为该类中定义的实例变量分派内存，也会为它从父类继承得到的所有实例变 量分派内存，即使子类定义了与父类中同名的实例变量。假如在子类里定义了与父类中已有变量同名的变量，那么子类中定义的变量会隐藏父类中定义的变量。注意不是完全 覆盖,因此系统在创建子类对象时，仍然会为父类

6、中定义的、被隐藏的变量分派内存空间。public c 1 ass Par e n t a publ i c Str i ng tag= h e 1 1 oworl d ”; public class Deri v ed extends Parent a/定义一个私有的tag实例变量来隐藏父类的tag实例变量pri v a te St r i n g tag=abc publi c cl a ss HideT e s t 仙 pu b lie s tat i c voi d main (String arg s ) aD e ri v edd=new Der i ve d () ;A/程序不可访

7、问d的私有变量t a g,所以会出现编译错误/Sys t em. out. pri n tin (d. tag);/将d变量显式的向上转型为P a r e nt后，即可访问t a g实例变量S ystem. out. p r i nt In (Pare n t) d). ta g) ;a a)调用父类构造器：子类不会获得父类的构造器，但子类构造器里可以调用父类构造器的初始化代码。在一个构造器里调用另一个重载的构造器使用th i s调用来完毕,在子类构造器中调用父类构造器使用SU p er调用来完毕。pu b lie class Base a. . public double size;pub

8、lie String n a me;A . public Base (double size, S tr i ng name) t h is. s ize=si z e;this. name=nam e ;a ap u blic cla s s Su b e xtends Base a public Str i n g color; apubli c Su b (do uble s i ze, Str i ng name, String color) a/通过super调用父类构造器的初始化过程super(size, name)；this, col o r=color； a publ i c

9、static vo i d mai n (S tr i ng args) aSub s= new Su b (5. 6,测试，” re d )；Sy s tem. o ut. prin t 1 n (s. s ize+”, +s name+”, +s c o 1 o r) )S u per调用的是其父类的构造器，而this调用的是同一个类中重载的构造器;因此，使用sup er调用父类的构造器 也必须出现在子类构造器执行体的第一行,所以thi s调用和super调用不会同时出现。当调用子类构造器来初始化子类对象时，父类构造器总会在子类构造器之前执行;不仅如此,执行父类构造器时，系统会再次上溯执行

10、其父类的构造器依次类推，创建任何java对象，最先执行的总是java. lang. Obj e c t类的构造器。pu b lie cl a ss Cr e ature a p u b li c Crea t ure () aS y stem, on print ln(n 无参”)；.public c la s s An i mal extend s Creature a pub 1 ic Animal (Str ing name) aSystem. out. print 1 n( A n imal 带一个参数的构造器+n a me)a publ i c An i mal ( S trin g

11、name, in t a ge) /this调用同一个重载构造器二this ( n ame);S y stem.i n t 1 n ( An i ma 1 带两个参数的构造器 +age)；. public c 1 a ss Wolf extends Animal p u blic Wolf () asuper (灰太狼，4) ；aS y stem. out. p r i n tin (wolf 无参构造器”)；)pu b lie st a tic void ma i n (St r ing ar g s) Wolf wf=new Wolf ();/虽然main方法只创建了一个Wolf对象，但系

12、统在底层完毕了复杂的操作,运营将会得到/ 无笏Anima 1带一个参数的构造器灰太狼/ Anim a 1带两个参数的构造器4/wolf无参构造器口 创建任何对象总是从该类所在继承树最顶层类的构造器开始执行，然后依次向下执行,最后才执行本类的构造器。假 如某个父类通过this调用了同类中重载的构造器,就会依次执行此父类的多个构造器。47多态:Jav a引用变量有两个类型：一个是编译时类型,一个是运营时类型。编译时类型由声明该变量时使用的类型决定, 运营时类型由实际赋给该变量的对象决定。假如编译时类型和运营时类型不一致，就也许出现所谓的多态。public class Bas e C 1 ass a

13、 publ ic int book= 6 ;A Syst e m. out. p r i ntl n (父类的普通方法);a pub 1 ic void test () S yst e m. out. printl n (父类被覆盖的方法”); )publ i c cla s s S u bC 1 a s s e x te n d s Bas e Clas s /重写定义一个bo o k实例变量隐藏父类的book实例变量publ i c String book =a b c ;apubl i c void test () a类的覆盖父类的方法)；public v o id su b () S

14、y st e m. out. printin (子类的普通方法”)鸿 )pub 1 i c sta t ic v o id mai n (S t ring口 a r gs) /编译时类型和运营时类型完全同样,因此不存在多态口publi c v o id base() aS y s tem. out. p rintln(子BaseC lass bc= new B a seC 1 a输出父类b c对象的成员变量值:6 口输出父类b c对象的成员变量值:6 口Sys t em. ou t .p r in t In (be. boo k)；be.test ();be. base()；/编译时类型和运营

15、时类型完全同样,因此不存在多态S ubC las s sbc= n ew Su b Cla s s () ； a /输出子类对象 s b c 的成员变量值:a b c口System, out. pr i nt 1 n ( s be. b o o k);as be. test ()；sbc. s ub() ;A/下面调用将执行从父类继承到的ba s e()方法sb c . ba s e ()；/编译时类型和运营时类型不同样,发生多态发生Ba s eC 1 ass ployB c=newSubClass ()；访问的是父类对象的实例变量System.oat.pr i ntln ( p 1 o y

16、B c . bo o k) ;A/执行从父类继承到的base。方法p 1 oyBc. ba s e ();/调用将执行当前类的test ()方法ployB c . te s t();/ ploy Be. sub ()；由于编译时类型是B a seClas s,没有提供sub()方法,所以编译会出现错误由于子类是一种特殊的父类,因此java允许把一个子类对象直接赋给一个父类引用变量，无须任何类型转换，或者被 称为向上转型，向上转型由系统自动完全。a对象的实例变量不具有多态性。注：引用变量在编译阶段只能调用其编译时类型所具有的方法，但运营时则执行它运营时类型所具有的方法。因此在编写 Java代码时

17、，引用变量只能调用声明该变量时所用类里包含的方法。例如：0 b ject p=n e w Person。代码定义 了一个变量p,则这个p只能调用Ob ject类的方法，而不能调用Per s on类里的方法。假如需要让这个引用变量调用它运营时类型的方法,则必须把它强制类型转化成运营时的类型，强制类型转换符需要 借助于类型转换运算符,用法是(type) var iabl e强制类型转换需要注意：基本类型之间的转换只能在数值类型之间进行，这里所说的数值类型涉及，整数型、字符型和浮点型；但数值类型和布 尔类型之间不能进行类型转换。引用类型之间的转换只能在具有继承关系的两个类型之间进行,假如是两个没有任

18、何继承关系的类型，则无法进行类 型转换。考虑到强制类型转换时也许出现异常，因此进行类型转换之前应先通过instan ceof运算符来判断是否可以成功转 换。注意：当把子类对象赋给父类引用变量时,被称为向上转型，这种转型总是可以成功的,这也从另一个侧面证实了子类是一种 特殊的父类。这种转型只是表白这个引用变量的编译时类型是父类，但实际执行它的方法时，仍然表现出子类对象行 为方式。但把一个父类对象赋给子类引用变量时，就需要进行强制类型转换，并且还也许在运营时产生Clas s Ca s t Exception异常,使用instanceof运算符可以让强制类型转换更安全。I n st a nceof

19、运算符:In s tanceof运算符前一个操作数通常是一个引用类型变量，后一个操作数通常是一个类（也可以是接口），它用于判 断前面的对象是否是后面的类，或者其子类、实现的实例。假如是，则返回ture,否则返回false.在使用instanceof运算符时需要注意：i n s t a nceof运算符前面操作数的编译时类型要么与后面的类相同,要么与后面的类具有父子继承关系,否则会引起编译错误。p ublic cl a ss instanceof T est (publi c stat i c void main (String1 a r gs) 声明h ello 时使用 Obj e c t类,

20、J/HJhe 11 oObj e ctU/Object 是所有类的父类,但h e 1 lo变量的实际类型是S tringU Obj ec t hello=h e 1 lo”;System, out. print 1 n (h ell o i ns t an ceof Ob j ect);Stri ng和Obj e c t类存在继承关系,可以进行i ns t a nee o f运算,返回trueSystem, o ut. pri n t 1 n (h e llo i nstanc e of S tring);/Math和Object类存在继承关系,可以进行i n stance o f运算,返回f

21、alseSy s t e m. out. p r int 1 n( (hel 1 o i n stanceof M a th);/St r ing 实现了Compa rabel 接口，所以返回 t r u e 口Sy s t e m. out. p rin tln(h e 1 1 o i n s ta n ceof Com p a rab le);St r in g a= hell o ”；/S t r ing类和Math类没有继承关系,所以下面的代码编译无法通过/Sy s t em. out. prin t In (a i n s t anc e of Ma t h ) ； 4.8初始化块：

22、初始化块是一段固定执行的代码,它不能接受任何参数。因此初始化块对同一个类的所有对象所进行的的初始化解决 完全相同。假如两个构造器中有相容的初始化代码，且这些初始化代码无须接受参数，就可以把它们放在初始化块中 定义。当创建ja v a对象时，系统总是先调用该类里定义的初始化块，相同类型的初始化块之间按顺序执行。初始化块在 执行构造器之前执行。与构造器类型，创建一个java对象时，不仅会执行该类的普通初始化块和构造器，并且系统会一直上溯到jav a . 1 an g.Object类,先执行ja v a. 1 a n g . Object类的初始化块,再开始执行j a va.1 ang. Objec

23、t的构造器,依次向 下执行其子类的初始化块，再开始执行其子类的构造器最后才执行该类的初始化块和构造器,返回该类的对象。静态初始化块：假如定义初始化块时使用了 static修饰符，则这个初始化块就变成了静态初始化块,也被称为类初始化块（普通初 始化块负责对对象执行初始化,类初始化块则负责对类进行初始化）。静态初始化块总是类相关的,系统将在类初始化 阶段执行静态初始化块,而不是在创建对象时才执行。因此静态初始化块总是比普通初始化块先执行。通常静态初始化块用于对类变量执行初始化解决O与普通初始化块类型，系统在类初始化阶段执行静态初始化块时，不仅会执行本类的静态初始化块，并且还会一直上溯到j ava.

24、 la ng. Ob j ect类，从最高父类开始一直到本类结束，依次执行每个类中的静态初始化块。p ublic cl a s s Test a p u b 1 i c static void ma i n (Stri n g a rgs) new Leaf ( )new L e af ();M 1 ass Root b static aSys t e m. o 力 pr i ntl n (Root 的静态初始化块); A (S y s t em. out. pri n tin (Ro o t 的初始化块);a pu b lie Ro o t () aSyst e m. 0 1. p r i

25、n tln(Root 的无参构造器”)；aac1 a s s Mid e x tends Rootstatic a.S y stem. out. printin (n M i d 的静态初始化块”)；)(Sys t em. out. printin (Mid 的初始化块“);)p ublic Mid() Sy s t em. ou t. prin t In(Z，M i d 的无参构造器“);. public M i d (Strin g m s g) /通过t his调用同一类中重载的构造器口t his ();System. out. r i nt 1 n (Mid的带有参数的构造器“); c

26、l a ss Lea f extends M i d s ta t ic aS ystem. 0。. pr i nt 1 n(Le a f 的静态初始化块”)；.(S y s t em. out. pri n tin (Leaf 的初始化块”);pub 1 ic Lea f () s u p er (“a be”)；S y stem. out. print 1 n (执行Leaf 的构造器“)；a )Roo t的静态初始化块Mid的静态初始化块Lea f的静态初始化块Roo t的初始化块Root的无参构造器Mid的初始化块Mid的无参构造器Mid的带有参数的构造器Leaf的初始化块执行L ea

27、 f的构造器Root的初始化块Root的无参构造器M i d的初始化块M i d的无参构造器Mid的带有参数的构造器Leaf的初始化块执行L ea f的构造器 类初始化阶段，先执行最顶层父类的静态初始化块,然后依次向下,直到执行当前类的初始化块。对象初始化阶段，先执行最顶层父类的初始化块、最顶层父类的构造器，然后依次向下，直到执行当前类的初始化块、当前类的构造器Java系统加载并初始化某个类时，总是保证该类的所有父类（涉及直接父类和间接父类）所有加载并进行初始化。静态初始化块和静态成员变量的执行顺序与在源程序中排列顺序相同。第五章面向对象下5 . 1 java增强的包装类为了解决8种基本类型的

28、变量不能当成Obje c t类型变量使用的问题,java提供了包装类的概念。除了 in t和char有点例外，其他的基本数据类型相应的包装类都是将其首字母大写即可。自动装箱和自动拆箱用法：public class AutoBo x i n g U n box i ng publi c static void main(String args) a直接把一个基本类型变量赋给 Integ e r 对象Int e ger i n Obj= 5 ；/直接把一个bo o lean类型变量赋给Obje c t类型变最0 b je c t boolObj=true；/直接把一个In t eger对象赋给in

29、 t类型变量int it二 i nOb j ;i f (bo o lObj i n s t anceof B o olean) /EObje c t对象强制类型转换为Boolean类型,再赋给b o olean变量 boole a n b= (Boolean) b ool 0 bj ；aS y stem. out. p r i ntln(b) ；a 包装类还可实现基本类型变量和字符串之间的转换。把字符串类型的值转换为基本类型的值有两种方式：1)运用包装类提供的par s eXxx (S t ring s)静态方法2)运用包装类提供的Xxx(S t ring s)构造器Strin g类提供了多个

30、重载的value。f ()方法，用于将基本类型变量转换成字符串。p u bl i c cla s s P r i mitive2S t rin g a p ub 1 ic stati c void m a in (S t r ing arg s ) Str ing int Str=12 3 ;/把一个特定的字符串转换成i n t变量Lint i t 1 = I n t e ger. pa r s e /方(int Str) ； ai nt it2=new I n t eg e r ( i ntStr) ；aSystem, out. pri n t I n ( i t2) ；aString f

31、loatSt r=4. 56 ；a/把一个特定的字符串转换成float变量float f tl=Floa t . pars e F 1 o a t(f 1 o a t Str) ；aflo a t f t 2= n ew Floa t (f 1 oatStr);把一个 float 变量转换成 Str i n g 变量JStr i ng ftStr = S t ring, value 0 f(2. 345 f ) ；aSystem, ou t .p r i nt 1 n(ftStr) ；a/ /把一个 do u ble 变量转换成 S t rin g 变量String d b Str= Str

32、i n g . v a Jue0f(3. 344)；S y st e m. out. prin t 1 n( d bS t r) ；a/ / 把一个 b o ol e an 变量转换成 S t r in g 变S2String boolSt r =Strin g . valueO f (tr u e);S y s t em. o u /. pr i n t 1 n(bo o IStr. t o Uppercase ();假如希望把基本类型变量转换成字符串，尚有一种更简朴的方法：将基本类型变量和”进行连接运算，系统会自动把基本类型变量转换成字符串O虽然包装类型的变量时引用数据类型,但包装类的实例

33、可以与数值类型的值进行比较，这种比较是直接取出包装类实 例所包装的数值来进行比较的。public clas s T estDemo a public static void m a in (Str i ng args) aInteger a=new I n t e g e r (6) 冷System, out. println(a 5 );/两个包装类实例进行比较时,只有两个包装类引用指向同一个对象时才返回t u r尤System. ou t. prin t 1 n( n e w In tege r (2)二二 new I n t e ger (2) ；a a系统把一个一 1 28-12 7之

34、间的证书自动装箱成Integer实例，并放入了一个名为c a che的数组中缓存起来。假如 以后把一个一1 2 8127之间的整数自动装箱成一个Integer实例时，事实上是直接指向相应的数组元素，因此一12812 7之间的同一个整数自动装箱成Integer实例时，永远都是引用each e数组的同一个数组元素，所以它们都相等。但假如整数不在这个范围内，则会重新创建一个Integer实例。pub 1 i c cl a ss Test Dm o 2 a public stat i c void ma i n (String 口 a r g s ) In t eg e r a= 2 ;Integ e

35、 r b = 2； aSystem. out. pr i n tln( a = =b) ;/ / tr uIn t eg er b iga= 1 2 8； aI nteger bigb= 1 28; aSy s tem. ou t. p r intln (biga=bigb);/ / f alse ) 5. 2解决对象对象打印的误区：pu b 1 i c clas s P r int 0 bjec t a publ i c s t ati c void ma i n (S t r i ng arg s ) a P e r so n p =new Per son (Pet e r )；假如想打E

36、p对象的内容,下面两种方法都不可以,打出来的都是地址值口/ Obje c t类提供的toSt r ing ()方法总是返回该对象实现类的“类名+ + has hCode ”的值Sys t em. out. print In (p)；aSystem. o u t. p r int 1 n (p. t oString ()；aaclas s P e rs o n pr i vate St r in g name* publ ic Person (S t r ing name) athis, n a me=n a me;重写t oString。方法，通过重写,就可以让系统在打印Apple对象时打印该

37、对象的“自我描述”内容public cl a s s T oStri n gT e s t public stat i c v o id mai n (Str i n g arg s ) Apple a =new Appl e ( r ed”, 100) ；a/打印 Apple 对象Sy s tem. out. printl n (a);)c 1 as s Ap p le pr i vate St r i n g c olo r ；a pri v ate double wei g h t ;/提供有参数的构造器publ ic Apple (Stri n g c o lor, d ouble w

38、e i g h t ) athis, c o lor= c o lor;this, we i g ht=weight;)public Stri n g g e t Co 1 o r () r e t u rn c o lor;pub 1 i c voi d se t C o lor (S t ri n g co 1 or) at h is. c o lor=colo r ;p ublic double getWeig h t () are t ur n weight； a p ublic v o id setWe i g t h(d o u b 1 e weig t h ) t h is. w

39、 e ight= weight;) 一/重写 to S trin g。方法Cpu b lieStri n g toString ()areturn color+”, +weight；a )2 . 2 =和 e quals 方法J ava中测试两个变量是否相等有两种方式,一种是运用=运算符,一种是运用e q u a 1 s ()方法。当使用=来判断 两个变量是否相等时，假如两个变量是基本类型变量，且都是数值类型(不一定规定数据类型严格相同)，则只要两 个变量的值相等，就将返回true.对于两个引用类型变量，只有他们指向同一个对象时,=判断才会返回trueo =不可用于比较类型上没有父子关系 的两

40、个对象。public c1 a ss EqualTest p u bl i c s tatic voi d mai n ( S trin g args) aint it=65；af 1 o a t f1=65. 0 f ;Syst e m. out. p rintln( “ 65 和 6 5. 0 是否相等？ ”+ (it=fl)；/ truecha r c h =A;Syst e m. o 1. pr i n t In ( 6 5 和 A 是否相等？ + ( i t=ch) ;/t rueSt r ing s trl= n ew Strin g ( he 1 1 o ) ；aString s

41、tr2=new S t r in g ( h ell o”)；S y stem, ou t. pri n tl n ( M s tri 和 st r 2 是否相等？ ”+ (st r l=str 2 );/ f al s eSystem. o u t. p r i n tin (strl 是否 equals st r 2?”+( s tri. equa 1 s ( s tr2);/true当Jav a程序直接使用形如 hel 1 o”的字符串直接量（涉及可以在编译时就计算出来的字符串值）时,JVM将会使用常量池来管理这些字符串；当使用new Str i ngChello）时，JVM会先使用常量

42、池来管理“hel 1。”直接量，再调用String类的构造器来创建一个新的String对象，新创建的Stri n g对象被保存在堆内存中。换句话说，newStri ng（ hell。）一共产生了两个字符串对象。pub lie class S t ri n g C ompa r e T e st a pub lie static v o id main （Str i ng args） a sl直接引用常量池中的“疯狂java匚S tring si二疯狂java”;St r i n g s 2 =疯狂,冷String s 3 = java ； a/s4 s 5 后面的字符串值可以在编译时就拟定下来

43、,它们都直接引用常量池中的“疯狂java”String s 4二疯狂+ jav a ；aStr i ng s5二疯 + 狂+ ” java/ / s 6后面的字符串值不能在编译时就拟定下来Strin g s6=s2+s3；a/ / s 7引用堆内存中新创建的Str i n g对象匚Str i ng s7二 new Str i ng(疯狂 ja v a ) ；aS ystem. ou t .p r i ntln (sl=s4) ;/ / tr u cS ys t e m. t. p r intln(sl=s 5 ) ;/true JS ystem. out. pr i n t1 n ( s l=

44、s 6 ) ；/falseLSystem, out. pri n tin( s 1 = = s7) ;/faIse aJVM常量池保证相同的字符串直接量只有一个，不会产生多个副本。St ring已经重写了 Obje c t的equals。方法，S t ring的e qu a 1 s ()方法判断两个字符串相等的标准是:只要两个字符串所包含的字符序列相同，通过equals。比较将返回t r ue,否则返回false类成员不能访问实例成员假如一个类始终只能创建一个实例，则这个类被称为单例类public cl a ss S i ng 1 etonTest a p ublic st a tic voi

45、d main (Strin g a r gs) /创建Singleton对象不能通过构造器,只能通过getlnstance方法得到实例 1Sin g 1 e ton s 1 =Si n gleto n . g e tins t ance () ； aSin g 1 eton s 2= S in g 1 e t o n . getln stanc e ();System. out. print ln(sl=:s2) ；a Jclass Singleton a/使用一个类变量来缓存曾经创建的实例p r ivate st a tic Singl e to n i n st a nc e /对构造器使

46、用P rivat e修饰,隐藏该构造器priva t e S ing 1 eton() /提供一个静态方法,用于返回S ing 1 eto n实例/该方法可以加入自定义控制,保证只产生一个Sing let on对象p ublic static S i ngle ton g e tlnstanc e () a/ /假如 Ins t ance 为Nu 11,，则表白还不曾创建si n glet o n对象/假如ints t a nc e不为null,则表白已经创建了 S i ng 1 eton对象,将不会重新创建新的实例口i f ( / /7 577 ce=nu 1 1 ) ains t an c

47、 e=nei Sing leton ();aret u rn i nst ance； a 5.4 f i nal修饰符F i n a 1修饰的变量不可被改变,一旦获得了初始值，该final变量的值就不能被重新赋值。因此j a va语法规 定:f i nal修饰的成员变量必须由程序员显式的指定初始值。Final修饰的类变量、实例变量能指定初始值的地方如下：类变量：必须在静态初始化块中指定初始值或声明该类型变量时指定初始值,并且只能在两个地方的其中之一指定 实例变量:必须在非静态初始化块、声明该实例变量或构造器中指定初始值,并且只能在三个地方的其中之一指定。实例变量不能在静态初始化块中指定初始值，由于静态初始化块时静态成员，不可访问实例变量非静态成员;类变 量不能在普通初始化块中指定初始值，由于类变量在类初始化阶段已经被初始化了，普通初始化块不能对其重新赋 值。public clas s Fin a IVariableTe s t a/定义成员