还剩26页未读，继续阅读
本资源只提供10页预览，全部文档请下载后查看！喜欢就下载吧，查找使用更方便
文本内容:
Created byAlwen on/5/
14.java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象类用于描述客观世界里某一类对象的共同特性，而对象则是类的详细存在，java程序使用类的构造器来创立该类的对象java也支持面向对象的三大特性封装、继承、和多态java提供了private、protected、和public三个访问控制修饰符来实现良好的封装，提供了extends关键字让子类继承父类，子类继承父类就可以继承到父类的组员变量和和措施，假如访问控制容许，子类实例可以直接调用父类里定义的措施继承是实现类复用的重要手段使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性面向对象的程序设计过程中有两个重要的概念类（Class）和对象（object,也被称为实例，instance）类可以包括三种最常见的组员构造器、组员变量、和措施构造器用于构造该类的实例，java语言通过new关键字类调用构造器，从而返回该类的实例构造器是一种类创立对象的主线途径，假如一种类没有构造器，这个类一般无法创立实例因此java语言提供了一种功能假如程序员没有为一种类编写构造器，则系统会为该类提供一种默认的构造器，这个构造器总是没有参数的一旦程序员为一种类提供了构造器，系统将不再为该类提供构造器构造器用于对类实例进行初始化操作，构造器支持重载，假如多种重载的构造器里包括了相似的初始化代码，则可以把这些初始化代码放置在一般初始化块里完毕，初始化块总在构造器执行之前被调用静态初始化块代码用于初始化类，在类初始化阶段被执行假如继承树里某一种类需要被初始化时，系统将会同步初始化该类的所有父类构造器修饰符可以是public、protected、private其中之一，或者省略构造器名构造器名必须和类名相似注意构造器既不能定义返回值类型，也不能使用void申明构造器没有返回值假如为构造器定义了返回值类型，或使用void申明构造器没有返回值，编译时不会出错，但java会把这个所谓的构造器当成措施来处理一一它就不再是构造器实际上类的构造器是有返回值的，当使用new关键字来调用构造器时，构造器返回该类的实例，可以把这个类的实例当成构造器的返回值因此构造器的返回值类型总是目前类，不必定义返回值类型不要在构造器里显式的使用return来返回目前类的对象，由于构造器的返回值是隐式的java类名必须是由一种或多种故意义的单词连缀而成的，每个单词首字母大写，其他字母所有小写，单词与单词之间不要使用任何分隔符组员变量组员变量的修饰符public、protected private、static、final前三个只能出现一种再和背面的修饰符组合起来修饰组员变量，也可省略组员变量由一种或者多种故意义的单词连缀而成，第一种单词首字母小写，背面每个单词首字母大写，其他字母所有小写，单词与单词之间不要使用任何分隔符类型可以是java语言容许的任何数据类型，包括基本类型和引用类型组员措施措施修饰符public、protected、private、static、final、abstract,前三个只能出现一种，static和final最多只能出现其中的一种，和abstract组合起来使用也可省略返回值类型可以是java语言的容许的任何数据类型，包括基本类型和引用类型措施名和组员变量的措施命名规则相似，一般提议措施名以英文动词开头措施体里多条可执行语句之间有严格的执行次序，排在措施体前面的语句总先执行，排在措施体背面的语句总是后执行static是一种特殊的关键字，它可用于修饰措施、组员变量等组员static修饰的组员表明它属于这个类自身，而//wolf无参构造器创立任何对象总是从该类所在继承树最顶层类的构造器开始执行，然后依次向下执行，最终才执行本类的构造器假如某个父类通过this调用了同类中重载的构造器，就会依次执行此父类的多种构造器
4.7多态Java引用变量有两个类型一种是编译时类型，一种是运行时类型编译时类型由申明该变量时使用的类型决定,运行时类型由实际赋给该变量的对象决定假如编译时类型和运行时类型不一致，就也许出现所谓的多态public classBaseClass{public intbook=6;public voidbase{System,out.println父类的一般措施；public void test{System,out.println父类被覆盖的措施”；}public classSubClass extendsBaseClass{//重写定义一种book实例变量隐藏父类的book实例变量public String book=abc;public void test{System,out.println子类的覆盖父类的措施;public voidsub{.System,out.println子类的一般措施；public staticvoid mainString[]args{〃编译时类型和运行时类型完全同样,因此不存在多态BaseClass bc=new BaseClass;〃输出父类be对象的组员变量值:6System,out.println be.book;be.test;be.base;//编译时类型和运行时类型完全同样,因此不存在多态SubClass sbc=new SubClass;//输出子类对象sbe的组员变量值:abcSystem,out.println sbc.book;sbc.test;sbc.sub;//下面调用将执行从父类继承到的base措施sbc.base;〃编译时类型和运行时类型不一样样,发生多态发生BaseClass ployBc=new SubClass;〃访问的是父类对象的实例变量System,out.println ployBc.book;〃执行从父类继承到的base措施ployBc.base;〃调用将执行目前类的test措施ployBc.test;//ployBc.sub;由于编译时类型是BaseClass,没有提供sub措施,因此编译会出现错误}}由于子类是一种特殊的父类，因此java容许把一种子类对象直接赋给一种父类引用变量，不必任何类型转换，或者被称为向上转型，向上转型由系统自动完全对象的实例变量不具有多态性.注引用变量在编译阶段只能调用其编译时类型所具有的措施，但运行时则执行它运行时类型所具有的措施因此在编写Java代码时，引用变量只能调用申明该变量时所用类里包括的措施例如Object p=new Person代码定义了一种变量P,则这个P只能调用Object类的措施，而不能调用Person类里的措施______________________________________________假如需要让这个引用变量调用它运行时类型的措施，则必须把它强制类型转化成运行时的类型，强制类型转换符需要借助于类型转换运算符，使用方法是type variable强制类型转换需要注意基本类型之间的转换只能在数值类型之间进行，这里所说的数值类型包括，整数型、字符型和浮点型；但数值类型和布尔类型之间不能进行类型转换引用类型之间的转换只能在具有继承关系的两个类型之间进行，假如是两个没有任何继承关系的类型，则无法进行类型转换考虑到强制类型转换时也许出现异常，因此进行类型转换之前应先通过instanceof运算符来判断与否可以成功转换注意当把子类对象赋给父类引用变量时，被称为向上转型，这种转型总是可以成功的，这也从另一种侧面证明了子类是一种特殊的父类这种转型只是表明这个引用变量的编译时类型是父类，但实际执行它的措施时，仍然体现出子类对象行为方式但把一种父类对象赋给子类引用变量时，就需要进行强制类型转换，并且还也许在运行时产生ClassCastException异常，使用instanceof运算符可以让强制类型转换更安全Instanceof运算符Instanceof运算符前一种操作数一般是一种引用类型变量，后一种操作数一般是一种类也可以是接口，它用于判断前面的对象与否是背面的类，或者其子类、实现的实例假如是，则返回ture,否则返回false.在使用instanceof运算符时需要注意instanceof运算符前面操作数的编译时类型要么与背面的类相似，要么与背面的类具有父子继承关系，否则会引起编译错误public classinstanceofTest{public staticvoid mainStringargs{//申明hello时使用Objec t类,则hello的编译类型是Objec t//Object是所有类的父类，但hell变量的实际类型是String Objecthello=hello;System,printin helloinstanceof Object;//String和Objec t类存在继承关系,可以进行ins tanceof运算,返回trueSystem.o〃t.printin helloinstanceof String.//Ma th和Objec t类存在继承关系,可以进行instanceof运算,返回false System,out.printin helloinstanceofMath;.//String实现T Comparabel接口,因此返回trueSystem,otrt.printin helloinstanceof Comparable;String a=hen”;,String类和Math类没有继承关系,所如下面的代码编译无法通过//System,out.print Ina instanceofMath;
4.8初始化块:初始化块是一段固定执行的代码，它不能接受任何参数因此初始化块对同一种类的所有对象所进行的的初始化处理完全相似假如两个构造器中有相容的初始化代码，且这些初始化代码不必接受参数，就可以把它们放在初始化块中定义当创立java对象时，系统总是先调用该类里定义的初始化块，相似类型的初始化块之间按次序执行初始化块在执行构造器之前执行与构造器类型，创立一种java对象时，不仅会执行该类的一般初始化块和构造器，并且系统会一直上溯到java.lang.Object类，先执行java.lang.Object类的初始化块，再开始执行java.lang.Object的构造器，依次向下执行其子类的初始化块，再开始执行其子类的构造器…最终才执行该类的初始化块和构造器，返回该类的对象静态初始化块假如定义初始化块时使用了static修饰符，则这个初始化块就变成了静态初始化块，也被称为类初始化块（一般初始化块负责对对象执行初始化，类初始化块则负责对类进行初始化）静态初始化块总是类有关的，系统将在类初始化阶段执行静态初始化块，而不是在创立对象时才执行因此静态初始化块总是比一般初始化块先执行一般静态初始化块用于对类变量执行初始化处理与一般初始化块类型，系统在类初始化阶段执行静态初始化块时，不仅会执行本类的静态初始化块，并且还会一直上溯到java.lang.Object类，从最高父类开始一直到本类结束，依次执行每个类中的静态初始化块public classTest{public staticvoid mainString[]args{new Leafnew Leafclass Root{static{System,out.printlnC^Root的静态初始化块;}System.out.printin^Root的初始化块;}public Root{System,out.printlnC^Root的无参构造器”；class Midextends Root{static{System,out.printin^Mid的静态初始化块“;}System.out.println/zMid的初始化块”；}public MidO{System,out.printlnMid的无参构造器”；}public MidStringmsg{〃通过this调用同一类中重载的构造器this;System.out.printlnMid的带有参数的构造器;class Leafextends Mid{static{System,out.printin Leaf的静态初始化块”；}System.out.printin^Leaf的初始化块;}public Leaf{super abc;System,out.printin执行Leaf的构造器”；Root的静态初始化块Mid的静态初始化块Leaf的静态初始化块Root的初始化块Root的无参构造器Mid的初始化块Mid的无参构造器Mid的带有参数的构造器Leaf的初始化块执行Leaf的构造器Root的初始化块Root的无参构造器Mid的初始化块Mid的无参构造器Mid的带有参数的构造器Leaf的初始化块执行Leaf的构造器类初始化阶段，先执行最顶层父类的静态初始化块，然后依次向下，直到执行目前类的初始化块对象初始化阶段，先执行最顶层父类的初始化块、最顶层父类的构造器，然后依次向下，直到执行目前类的初始化块、目前类的构造器Java系统加载并初始化某个类时，总是保证该类的所有父类包括直接父类和间接父类所有加载并进行初始化静态初始化块和静态组员变量的执行次序与在源程序中排列次序相似第五章面向对象下
5.1java增强的包装类为了处理8种基本类型的变量不能当成Object类型变量使用的问题，java提供了包装类的概念除了int和char有点例外，其他的基本数据类型对应的包装类都是将其首字母大写即可自动装箱和自动拆箱使用方法public classAutoBoxingUnboxing{public staticvoid mainString[]args{//直接把一种基本类型变量赋给In teger对象Integer inObj=5;//直接把一种boolean类型变量赋给Object类型变量Object boolObj=true;//直接把一种Integer对象赋给int类型变量int it=inObj;ifboolObj instanceofBoolean{//先把Objec t对象强制类型转换为Boolean类型,再赋给boolean变量boolean b=BooleanboolObj;System,out.printin b;}包装类还可实现基本类型变量和字符串之间的转换把字符串类型的值转换为基本类型的值有两种方式:1运用包装类提供的parseXxxString s静态措施2运用包装类提供的XxxString s构造器String类提供了多种重载的valueOf措施，用于将基本类型变量转换成字符串public classPrimitive2String{public staticvoid mainString[]args{String intStr=123;//把一种特定的字符串转换成int变量int itl=Integer.parselntintStr;int it2=new IntegerintStr;System.out.printlnit2;String floatStr=
4.56”;//把一种特定的字符串转换成floa t变量float ftl=Float,oarse/7/方floatStr;float ft2=new FloatfloatStr;//把一种float变量转换成String变量String ftStr=String.valueOf^.345f;System.out.println ftStr;//把一种double变量转换成String变量String dbStr=String.valueOfia344;System,out.printlndbStr;//把一种boolean变量转换成String变量String boolStr=String.valueOf{tx\ie;System,out.printlnboolStr.toUpperCase;假如但愿把基本类型变量转换成字符串，尚有一种更简朴的措施将基本类型变量和””进行连接运算，系统会自动把基本类型变量转换成字符串o虽然包装类型的变量时引用数据类型，但包装类的实例可以与数值类型的值进行比较，这种比较是直接取出包装类实例所包装的数值来进行比较的.public classTestDemo{public staticvoid mainString[]args{Integer a=new Integer6;System.out.println a5;//两个包装类实例进行比较时,只有两个包装类引用指向同一种对象时才返回tureSystem.out.println new Integer2==new Integer2;系统把一种-128-127之间的证书自动装箱成Integer实例，并放入了一种名为cache的数组中缓存起来假如后来把一种-128T27之间的整数自动装箱成一种Integer实例时，实际上是直接指向对应的数组元素，因此-128-127之间的同一种整数自动装箱成Integer实例时，永远都是引用cache数组的同一种数组元素，因此它们都相等但假如整数不在这个范围内，则会重新创立一种Integer实例public classTestDmo2{public staticvoid mainString[]args{Integer a=2;Integer b=2;System.out.println a==b;//trueInteger biga=128;Integer bigb=128;System.out.printlnbiga==bigb;//false
5.2处理对象对象打印的误区.public classPrintobject{public staticvoid mainString[]args{Person p=new PersonPeter;//假如想打印P对象的内容,下面两种措施都不可以,打出来的都是地址值//Object类提供的toString措施总是返回该对象实现类的“类名+@+hashCode”的值System.out.printin p;System,out.printin p.toString;}class Personprivate String name;public PersonString name{this.name=name;重写toString措施，通过重写,就可以让系统在打印Apple对象时打印该对象的“自我描述”内容public classToStringTest{public staticvoid mainString[]args{Apple a=new Applered”,100;//打印Apple对象System,out.printlna;}class Apple{private String color;private double weight;//提供有参数的构造器public AppleString color,double weight{this.color=color;this.weight=weight;public StringgetColor{return color;public voidsetColor String color{this.color=color;public doublegetWeight{return weight;public voidsetWeigthdouble weigth{this.weight二weight;//重写toString措施public StringtoString{return color+”,+weight;}
5.
2.2==和equals措施Java中测试两个变量与否相等有两种方式，一种是运用二运算符，一种是运用equals措施当使用==来判断两个变量与否相等时，假如两个变量是基本类型变量，且都是数值类型不一定规定数据类型严格相似，则只要两个变量的值相等，就将返回true.对于两个引用类型变量，只有他们指向同一种对象时，=判断才会返回trueo=不可用于比较类型上没有父子关系的两个对象public classEqualTest{public staticvoid mainString[]args{int it=65;float fl=
65.Of;System,out.printin65和
65.0与否相等？”+it==fl;//truechar ch=A，;System,out.print In65和A与否相等？”+it=ch;//trueString strl=new Stringhello;String str2=new Stringhello;System,out.println strl和str2与否相等”+strl==str2;//falseSystem,out.println^strl与否equals str2”+strl・equals str2;//true}当Java程序直接使用形如hello”的字符串直接量包括可以在编译时就计算出来的字符串值时，JVM将会使用常量池来管理这些字符串；当使用new Stringhello时，JVM会先使用常量池来管理“hello”直接量，再调用String类的构造器来创立一种新的String对象，新创立的String对象被保留在堆内存中换句话说，new Stringhello一共产生了两个字符串对象public classStringCompareTest{public staticvoid mainString[]args{//si直接引用常量池中的“疯狂java”String si=疯狂java”;String s2=疯狂；String s3=java;//s4s5背面的字符串值可以在编译时就确定下来,它们都直接引用常量池中的“疯狂java”String s4=疯狂+java;String s5=疯狂+java;//s6背面的字符串值不能在编译时就确定下来String s6=s2+s3;//s7引用堆内存中新创立的S tring对象String s7=new String疯狂java;//trueSystem,out.println sl==s4;//trueSystem.out.println sl==s5;//falseSystem,out.println sl==s6;//falseSystem,out.println sl==s7;}JVM常量池保证相似的字符串直接量只有一种，不会产生多种副本String已经重写了Object的equals措施，String的equals措施判断两个字符串相等的原则是只要两个字符串所包括的字符序列相似，通过equals比较将返回true,否则返回false类组员不能访问实例组员假如一种类一直只能创立一种实例，则这个类被称为单例类public class SingletonTest{public staticvoid mainString[]args{//创立Singleton对象不能通过构造器,只能通过ge tinstance措施得到实例Singleton sl=Singleton.getlnstance^;Singleton s2=Singleton.getlnstance0;System.out.printinsl==s2;}classSingleton{//使用一种类变量来缓存曾经创立的实例private staticSingleton instance;//对构造器使用private修饰,隐藏该构造器private Singleton{}//提供一种静态措施,用于返回Singleton实例//该措施可以加入自定义控制,保证只产生一种Singleton对象public staticSingleton getlnstance{//假如Instance为Null,,则表明还不曾创一立singleton对象//假如intstance不为null,则表明已经创立了Singleton对象,将不会重新创立新的实例if力7s3〃ce=nun{instance^new Singleton;}return instance]
5.4final修饰符Final修饰的变量不可被变化，一旦获得了初始值，该final变量的值就不能被重新赋值因此java语法规定final修饰的组员变量必须由程序员显式的指定初始值Final修饰的类变量、实例变量能指定初始值的地方如下类变量必须在静态初始化块中指定初始值或申明该类型变量时指定初始值，并且只能在两个地方的其中之一指定实例变量必须在非静态初始化块、申明该实例变量或构造器中指定初始值，并且只能在三个地方的其中之一指定实例变量不能在静态初始化块中指定初始值，由于静态初始化块时静态组员，不可访问实例变量一一非静态组员；类变量不能在一般初始化块中指定初始值，由于类变量在类初始化阶段已经被初始化了，一般初始化块不能对其重新赋值public classFinalVariableTest{//定义组员变量时指定默认值,合法final int a=6;//下面这三个变量将在构造器或初始化块中指定初始值final String str;final intc;final staticdouble d;//ch既没有指定默认值,有无在初始化块、构造器中指定初始值//final charch;//初始化块,对没有指定默认值的实例变量指定初始值{//在初始化块中为实例变量指定初始值,合法str=hello”;//定义a实例变量时,已经指定了默认值,不能重新为a赋值//a=9;}static{//在静态初始化块中为类变量指定初始值,合法户
5.6;public FinalVariableTest{//str在初始化块中已定义初始值,不可重新赋值//str=java;//构造器,可对既没有指定默认值，又没有在初始化块中指定初始值的实例变量指定初始值c=5;public voidchangeFinal{//一般措施不能为final修饰的组员变量赋值//d=l.2;〃不能在一般措施中为final组员变量指定初始值//ch=，a;public staticvoid mainString[]args{FinalVariableTest ft=new FinalVariableTest;System.out.printin ft.a;System.out.printin ft.c;System.out.printin ft.d;Final局部变量系统不会对局部变量进行初始化，局部变量必须由程序员显式初始化因此final修饰局部变量时，既可以在定义时指定默认值，也可以不指定默认值假如final修饰的局部变量在定义时没有指定默认值，则可以在背面代码中对该final变量赋初始值，但只能一次，不能反复赋值当使用final修饰基本类型变量时，不能对基本类型变量重新赋值，因此基本列表变量不能变化但对于引用类型变量而言，它保留的仅仅是一种引用，final只保证这个引用类型变量所引用的地址不会变化，即一直引用同一种对象，但这个对象完全可以变化public classFinalReferenceTest{public staticvoid mainString[]args{//final修饰数组变量,iA门是一种引用变量final int[]iArr={5,6,12,9;System.out.printin Arrays.toString{ikrr};//对数组元素排序,合法Arrays.sorZiArr;System.out.printin Arrays.toString{ikrr};//对数组元素赋值,合法iArr
[2]=-8;System.out.printin Arrays.toString{ikrr;〃对iArr重新赋值,非法//iArr=null;//final修饰Person变量,p是一种引用变量final Person p=new Person45;//变化P对象的age实例变量,合法p.setAge23;System.out.printin p.getAgeO;//对p重新赋值,非法//p=null;}}class Person{private int age;public PersonO{}//有参数的构造器public Personint age{this.age=age;public voidsetAgeint age{this.age=age;public intgetAge{return age;}可执行“宏替代”的final变量对于一种final变量来说，不管它是类变量、实例变量，还是局部变量，只要该变量满足三个条件，这个final变量就不再是一种变量，而是相称于一种直接量1使用final修饰符修饰2在定义该final变量时指定了初始值3该初始值可以在编译时就被确定下来假如被赋的体现式只是基本的算术体现式或字符串连接运算，没有访问一般变量，调用措施，java编译器同样会将这种final变量当成“宏变量”处理public classFinalReplaceTest{public staticvoid mainString[]args{//下面定义了4个final宏变量,由于编译器在编译时就可以确定final int a=5+2;final double b=l.2/3;final String str=疯狂+java;final Stringbook=疯狂java讲义”+
99.0;〃下面的book2变量的值由于调用了措施,因此无法在编译时被确定下来final Stringbook2=”疯狂java讲义/Z+String.valueOf^.0;System,out.printin book二二”疯狂Java讲义
99.0;//相等System,out.printin book2二二”疯狂java讲义
99.0;〃不相等}Java会使用常量池来管理曾经用过的字符串直接量，例如执行String a=java”，语句之后，常量池中就会缓存一种字符串“Java；假如程序再执行Stringb=java”，系统将会让b直接指向常量池中的“java”字符串，因此a==b将会返回true.public classStringJoinTest{public staticvoid mainString[]args{String si=疯狂java”;//s2变量引用的字符串可以在编译时就确定下来,因此s2的直接引用常量池中已经有的“疯狂java〃字符串String s2=疯狂+java;System,out.prhitlnsl=s2;String strl=疯狂;Stringstr2=java;//str3由strl和str2进行连接运算后得到的由于strl和str2只是两个一般变量,编译器不会执行“宏替代”，因而不能在//编译时确定S3的值,也就无法让S3指定字符串池中缓存的“疯狂Java”Strings3=strl+str2;System,out.printlnsl==s3;//只要让编译器对strips tr2两个变量执行“宏替代”，这样编译器即可在编译阶段就确定s3的值,就会让s3指向字符串池不属于该类的单个实例，因此通过把static修饰的组员变量和措施被称为类变量、类措施（静态组员变量，静态组员措施）不使用static修饰的组员变量和措施称为实例变量和实例措施（非静态组员变量，非静态组员措施）静态组员不能直接访问非静态组员static的真正作用就是用于辨别组员变量、措施、内部类、初始化块，这四种组员究竟属于类自身还是属于实例有static修饰的组员属于类自身，没有类修饰的组员属于该类的实例java类大体有如下作用定义变量创立对象调用类的类措施或访问类的类变量定义一种类就是为了反复创立该类的实例，同一种类的多种实例具有相似的特性，而类则是定义了多种实例的共同特性类里定义的措施和组员变量都可以通过类或实例来调用Static修饰的措施和组员变量，既可通过类来调用，也可通过实例来调用；没有使用static修饰的一般措施组员变量，只可通过实例来调用Person p=new Person；这行代码创立了一种Person实例，也被称为Person对象，这个Person对象被赋给p变量在这行代码中实际上产生了两个东西，一种是p变量，一种是Person对象P引用变量自身只存储了一种地址值，并未包括任何实际数据，但它指向实际的Person对象Person对象由多块内存构成，不一样内存块分别存储了Person对象的不一样组员变量类是一种引用数据类型，因此程序中定义的Person类型的变量实际上是一种引用，它被寄存在栈内存里，指向实际的Person对象；而真正的Person对象则寄存在堆内存中.当一种对象被创立成功后来，这个对象将保留在堆内存中，java程序不容许直接访问堆内存中的对象，只能通过该对象的引用操作该对象堆内存里的对象可以有多种引用，即多种引用变量指向同一种对象假如堆内存里的对象没有任何变量指向该对象，那么程序将无法再访问该对象，这个对象也就变成了垃圾，java垃圾回收机制将回收该对象，释放该对象所占的内存区对象的this引用Java提供了一种this关键字，this关键字总是指向调用该措施的对象This作为对象的默认引用有两种情形构造器中引用该构造器正在初始化的对象；在措施中引用调用该措施的对象This关键字最大的作用就是让类中一种措施，访问该类里的另一种措施或者实例变量Java容许对象的一种组员直接调用另一种组员，可以省略this前缀.假如在static修饰的措施中使用this关键字，则这个关键字就无法指向合适的对象，因此，static修饰的措施中不能使用this引用Java编程时不要使用对象去调用static修饰的组员变量、措施、而是应当使用类去调用static修饰的组员变量、措施假如确实需要在静态措施中访问另一种一般措施，则只能重新创立一种对象大部分的时候，一般措施访问其他措施、组员变量时不必使用this前缀，但假如措施里有个局部变量和组员变量同名，但程序又需要在该措施里访问这个被覆盖的组员变量，则必须使用this前缀This引用也可以用于构造器中作为默认引用，由于构造器时直接使用new关键字来调用，而不是使用对象来调用的，因此this在构造器中代表该构造器正在初始化对象措施Java里的措施不能独立存在，所有的措施都必须定义在类里假如这个措施是用来static修饰，则这个措施属于这个类，否则这个措施属于这个类的实例执行措施时，必须使用类或者对象作为调用者同一种类的一种措施调用此外一种措施时，假如被调措施是一般措施，则默认使用this作为调用者；假如被调用措施是静态措施，则默认使用//中缓存的“疯狂java”也就是,只要将strl和str2使用final修饰即可}Final措施Final修饰的措施不可被重写，不过可以重载Final类Final修饰的类不可以有子类因而为了保证某个类不可被继承，则可以使用final修饰这个类
5.5抽象类抽象措施和抽象类必须使用abstract修饰符来定义，有抽象措施的类只能被定义成抽象类，抽象类里可以没有抽象措施抽象措施和抽象类的规则如下1抽象类必须使用abstract修饰符来修饰，抽象措施也必须使用abstract修饰符来修饰，抽象措施不能有措施体2抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创立抽象类的实例虽然抽象类里不包括抽象措施，这个抽象类也不能创立实例3抽象类可以包括组员变量、措施一般措施和抽象措施都可以、构造器、初始化块、内部类接口、枚举5种成分抽象类的构造器不能用于创立实例，重要是用于被其他子类调用4具有抽象措施的类包括直接定义了一种抽象措施；或继承了一种抽象父类，但没有完全实现父类包括的抽象措施；或实现了一种接口，但没有完全实现接口包括的抽象措施三种状况只能被定义成抽象类抽象类多了一种能力，抽象类可以包括抽象措施；失去了一种能力，抽象类不能用于创立实例定义抽象措施只需在一般措施上增长abstract修饰符，并把一般措施的措施体也就是措施后花括号括起来的部分所有去掉，并在措施后增长分号即可定义抽象类只需在一般类上增长abstract修饰符即可/***Crea tedby AIwen on/5/
19.*/public abstractclass Shape{System,out.printin执行shape的初始化块・・・;private String color;//定义一种计算周长的抽象措施public abstractdouble calPerimeter;//定义一种返回形状的抽象措施public abstractString getType;//定义Shape的构造器,该构造器并不是用于创立Shape对象,而是用于被子类调用public Shape{public ShapeString color{System.out.print In执行Shape构造器“;this.color=color;public voidsetColor String color{this.color=color;public StringgetColor{return color;public classTriangle extendsShape{private double a;private double b;private double c;public TriangleStringcolor,doublea,doubleb,double c{super color;this.setSides a,b,c;public voidsetSides doublea,doubleb,doublec{ifa=b+c||b=a+c||c=a+b{System.out.printin三角形两边之和必须不小于第三边;return;}this.a=a;this.b=b;this.c=c;public doublecalPerimeter{return a+b+c;public StringgetType{return三角形；public classCircle extendsShape{private double radius;public CircleStringcolor,doubleradius{super color;this.radius=radius;public voidsetRadiusdouble radius{this.radius=radius;public doublecalPerimeter{return2*Math.TT*radius;public StringgetType{return getColor+圆形；public staticvoid mainString]]args{Shape sl=new Triangle黑色”,3,4,5;Shape s2=new Circle黄色”,3;System.out.printlnsl.getType;System.out.printlnsl.calPerimeter;System.out.printlns
2.getType;System.out.printlns
2.calPerimeter;当使用abstract修饰类时，表明这个类只能被继承；当使用abstract修饰措施时，表明这个措施必须由子类提供实现（即重写）而final修饰的类不能被继承，final修饰的措施不能被重写因此final和abstract永远不能同步使用Abstract不能修饰变量，也不能用于修饰构造器Static和abstract不能同步修饰某个措施，但它们可以同步修饰内部类Private和abstract不能同步修饰措施抽象类不能创立实例，只能当成父类来被继承抽象类体现的就是一种模板模式的设计假如编写一种抽象父类，父类提供了多种子类的通用措施，并把一种或多种措施留给其子类实现，这就是一种模板模式，模板模式也是十分常见且简朴的设计模式之一public abstractclass SpeedMeter{private doubleturnRate;public SpeedMeter{//把返回车轮半径的措施定义成抽象措施public abstractdouble getRadius;public voidsetTurnRatedouble turnRate{this.turnRate=turnRate;public doublegetSpeed{return java.lang.Math./^2*getRadius*turnRate;}public classCarSpeedMeter extendsSpeedMeter{public doublegetRadius{return
0.28;public staticvoid mainString[]args{CarSpeedMeter csm=new CarSpeedMeter;csm.setTurnRate15;System.out.printin csm.getSpeed;
5.6java8改善的接口接口里不能包括一般措施，接口里的所有措施都是抽象措施Java8对接口进行了改善，容许在接口中定义默认措施，默认措施可以提供措施实现接口定义了某一批类所需要遵守的规范，接口不关怀这些类的内部状态数据，也不关怀这些类里措施的实现细节，它只规定这批类里必须提供某些措施，提供这些措施的类就可满足实际需要接口是从多种相似类中抽象出来的规范，接口不提供任何实现定义接口使用interface关键字1）修饰符可以是public或者省略，假如省略了public访问控制符，则默认采用包访问控制符，即只有在相似包构造下才可以访问该接口2）接口名应与类名采用相似的命名规则，接口名一般可以使用形容词3）一种接口可以有多种直接父接口，但接口只能继承接口，不能继承类由于接口定义的是一种规范，因此接口里不能包括构造器和初始化块定义接口里可以包括组员变量（只能是静态常量）、措施（只能是抽象实例措施、类措施或默认措施）、内部类（包括内部接口、枚举）定义接口里定义的是多种类共同的公共行为规范，因此接口里的所有组员，包括常量、措施、内部类和内部枚举都是public访问权限定义接口组员时，可以省略访问控制修饰符，假如指定访问控制修饰符，则只能使用public访问控制修饰符对于接口里的定义的静态常量而言，它们是接口有关的，因此系统会自动为这些组员变量增长static和final两个修饰符也就是说，在接口中定义组员变量时，不管与否使用public staticfinal修饰符，接口里的组员变量总是使用这三个修饰符来修饰并且接口里没有构造器和初始化块，因此接口里定义的组员变量只能在定义时指定默认值接口里定义的措施只能是抽象措施、类措施或默认措施，因此假如不是定义默认措施，系统将自动为一般措施增长abstract修饰符；定义接口里的一般措施时不管与否使用public abstract修饰符，接口里的一般措施总是使用public abstract来修饰接口里的一般措施不能有措施实现措施体；但类措施、默认措施都必须由措施实现措施体.接口里定义的内部类、内部接口、内部枚举默认都采用public static两个修饰符public interfaceOutput{〃接口里定义的组员变量只能是常量int MAX_CACHE_LIN^5S,//接口里定义的一般措施只能是public的抽象措施void out;void getDataStringmsg;//接口中定义的默认措施,需要使用defualt修饰default voidprint String...msgs{forString msg:msgs{System.out.printin msg;}default void test{System,out.printin默认的test措施“;}//在接口中定义类措施,需要使用static修饰static StringstaticTest{return〃接口中的类措施〃；}Java8容许在接口中定义默认措施，默认措施必须使用default修饰，该措施不能使用static修饰，无论程序与否指定，默认措施总是使用public修饰由于默认措施不能使用static修饰，因此不能直接使用接口来调用默认措施，需要使用接口的实现类的实例来调用这些默认措施Java8容许在接口中定义类措施，类措施必须使用static修饰，该措施不能使用default修饰无论程序与否指定，类措施总是使用public修饰类措施可以直接使用接口来调用接口中的组员变量默认是使用public staticfinal修饰，因此虽然另一种类处在不一样包下，也可以通过接口来访间接口里的组员变量从某个角度来看，接口可被当成一种特殊的类，因此一种java源文献里最多只能有一种Public接口，假如一种java源文献里定义了一种public接口，则该源文献的主文献名必须与该接口名相似接口的继承接口的继承和类继承不一样样，接口完全支持多继承，即一种接口可以有多种直接父接口和类继承相似，子接口扩展某个父接口，将会获得父接口里定义的所有抽象措施、常量一种接口继承多种父接口，多种父接口排在extends关键字之后，多种父接口之间以英文逗号隔开public classInterfaceExtendsTest{public staticvoid mainString[]args{System.out.printin interfaceC.PROP_A;System.out.print In interfaceC.PROP_B;System.out.printin interfaceC.PROP_C;interface interfaceA{int PROPM;void testAO;}interface interfaceB{int PR0P_±6void testB;}interface interfaceCextends interfaceA,interfaceB{int PROP©•,void testC;一种类可以实现一种或者多种接口，继承使用extends关键字，实现则使用implements关键字一种类可以继承一种父类，并同步实现多种接口，implements部分必须放在extends部分之后一种类实现类一种或多种接口之后，这个类必须完全实现这些接口里所定义的所有抽象措施也就是重写这些抽象措施；否则，该类将保留从父接口那里继承到的抽象措施，该类也必须定义成抽象类接口和抽象类相似点接口和抽象类都不能实例化，都包括抽象措施不一样点1接口里只能包括抽象措施和默认措施，不能为一般措施提供措施实现；抽象类则完全可以包括一般措施2接口里不能定义静态措施；抽象类里可以定义静态措施3接口里只能定义静态常量，不能定义一般组员变量；抽象类里既可以定义一般组员变量，也可以定义静态常量4接口里不包括构造器；抽象类里可以包括构造器，抽象类里的构造器并不是用于创立对象，而是让其子类调用这些构造器来完毕属于抽象类的初始化操作5接口里不能包括初始化块；但抽象类则完全可以包括初始化块6一种类最多只能有一种直接父类，包括抽象类；但一种类可以直接实现多种接口，通过实现多种接口可以弥补java单继承的局限性
5.7内部类1内部类提供了更好的封装，把内部类隐藏在外部类之内，不容许同一种包中的其他类访问该类2内部类组员可以直接访问外部类的私有数据，由于内部类被当成其他外部类组员，同一种类的组员之间可以互相访问但外部类不能访问内部类的实现细节，例如内部类的组员变量3匿名内部类合用于创立那些仅需要一次使用的类内部类除了需要定义在其他类里面之外，还存在如下两点1内部类比外部类可以多使用三个修饰符private、protected、static—外部类不可以使用这三个修饰符2非静态内部类不能拥有静态组员在非静态内部类中可以直接访问外部类的private的实例变量public classCow{private double weight;public Cow{}public Cowdoubleweigth{this.weight=weight;private classCowLeg〃非静态内部类的两个实例变量private doublelength;private Stringcolor;public CowLeg{}//非静态内部类的两个重载的构造器public CowLegdoublelength,Stringcolor{this.length=length;this.color=color;public voidsetLengthdouble length{this,length=length;public doublegetLengthO{return length;public voidsetColorString color{this.color=color;public StringgetClor{return color;//非静态内部类的实例措施public voidinfo{System.out.printin目前牛的颜色:+color+高*+length;//直接访问外部类的private修饰的组员变量System.printing本牛腿所在奶牛重+weight;public voidtest{CowLeg cl=new CowLegl.12,黑白相间；cl.info;public staticvoid mainString[]args{Cow cow=new Cow
378.9;cow.test;假如外部类组员变量、内部类组员与内部类里措施的局部变量同名，则可通过使用this、外部类类名.this作为限定来辨别public classDiscernVariable{private String prop=外部类的实例变量”；private classInClass{private Stringprop=”内部类的实例变量”；public voidinfo{Stringprop=局部变量”；//System.ou t.printin〃外部类的实例变量:Discern Variable.prop;//通过外部类类名.this.varName访问外部类实例变量System,out.print In“外部类的实例变量*+DiscernVariable.this,prop;//通过this.varName访问内部类实例的变量System.out.printin局部变量的值+prop;public voidtest{TnClass in=new InClass;in.info;public staticvoid mainString[]args{new DiscernVariable.test;]___________________________________________________________________________________________________________________________非静态内部类的组员可以访问外部类的private组员，但反过来就不成立了非静态内部类的组员只在非静态内部类范围内是可知的，并不能被外部类直接使用假如外部类需要访问非静态内部类的组员，则必须显示创立非静态内部类对象来调用访问其实例组员public classouter{private intoutProp=9;class Inner{private intinprop=5;public voidacessOuterProp{〃非静态内部类可以直接访问外部类的private组员变量System.out.printin外部类的outProp值+outProp;public voidaccessInnerProp{//外部类不能直接访问非静态内部类的实例变量//Sys tem.out.printin〃内部类的inprop:〃+inprop;//如需访问内部类的实例变量，必须显示创立内部类对象System.out.printin“内部类的inprop:*+new Inner.inprop;public staticvoid mainString口args{outer out=new outer;out.accessInnerProp;}__________________________________________________________________________________________________________________________
5.
7.2静态内部类假如使用static修饰一种内部类，则这个内部类就属于外部类自身，而不属于外部类的某个对象静态内部类可以包括静态组员，也可以包括非静态组员静态内部类不能访问外部类的实例组员，只能访问外部类的类组员外部类仍然不能直接访问静态内部类的组员，但可以使用静态内部类的类名作为调用者来访问静态内部类的类组员，也可以使用静态内部类对象作为调用者来访问静态内部类的实例组员public classAccessStatidnnerClass{static classStaticInnerClass{private staticint prop1=3;private intprop2=9;public voidaccessInnerProp{//通过类名访问静态内部类的类组员System,out.printin StaticInnerClass.propl;//通过实例访问静态内部类的实例变量System,out.print Innew StaticInnerClass.prop2;public staticvoid mainString[]args{AccessStatidnnerClass asi=new AccessStaticInnerClass;asi.accessInnerProp;}__________________________________________________________________________________________________________________________接口内部类只能是静态内部类接口里定义的内部类默认使用public static修饰
5.
7.3使用内部类在外部类以外的地方使用内部类，内部类完整的类名应当是OuterClass.InnerClass；创立非静态内部类对象之前，必须先创立其外部类对象Outerinstance,new InnerConstructor;public classCreatelnnerInstance{public staticvoid mainString[]args{//非静态内部类的构造器必须使用外部类对象来调用Out.Inin=new Out.newIn测试信息”；class Out{class InpublicInString msg{System,out.printlnmsg;]__________________________________________________________________________________________________________________________在外部类以外使用静态内部类由于静态内部类是外部类类有关的，因此创立静态内部类对象时不必创立外部类对象在外部类以外的地方创立静态内部类实例的语法如下new OuterClass.InnerConstructor;public classCreateStaticInnerInstance{public staticvoid mainString[]args{StaticOut.Staticin in=new StaticOut.StaticInO;class StaticOut{static classStaticln{public StaticInO{System.out.printin静态内部类的构造器〃;不管是静态内部类还是非静态内部类，它们申明变量的语法完全同样区别是在创立内部类对象，静态内部类只需使用外部类即可调用构造器，而非静态内部类必须使用外部类对象来调用构造器匿名内部类匿名内部类必须继承一种父类或实现一种接口，但最多只能继承一种父类，或实现一种接口匿名内部类不能是抽象类；匿名内部类不能定义构造器最常用的创立匿名内部类的方式是需要创立某个接口类型的对象public classAnonymousTest{public voidtest Productp{System.printing购置了一种+p.getName+*,花掉了+p.getPrice;public staticvoid mainString[]args{AnonymousTest ta=new AnonymousTest;//调用一种test措施时,需要传入一种Product参数,此处传入其匿名内部类的实例ta.test newProduct{public doublegetPrice{return
567.8;public StringgetName{return”AGP显卡”；}；interface Product{public doublegetPrice;public StringgetName;]_______________________________________________________________________________________________________Test措施需要传入一种Product对象作为参数，但product只是一种接口，无法直接创立对象因此此处考虑创立一种Product接口实现类的对象传入该措施一一假如这个Product接口实现类需要反复使用，则应当将该实现类定义成一种独立类；假如这个Product接口实现类只需一次使用，则可以定义一种匿名内部类定义匿名内部类不必class关键字，而是在定义匿名内部类时直接生成该匿名内部类的对象由于匿名内部类不能是抽象类，因此匿名内部类必须实现它的抽象父类或者接口里包括的所有抽象措施
5.9枚举类一种类的对象是有限并且固定的，在java里被称为枚举类枚举类和其他类的区别1使用enum定义的枚举类默认继承了java.lang.Enum类，而不是默认继承的Object类2使用enum定义、非抽象的枚举类默认会使用final修饰，因此枚举类不能派生子类3枚举类的构造器只能使用private访问控制符默认和指定都是private4枚举类的所有实例必须在枚举类的第一行显式列出，系统会自动添加public staticfinal修饰public enumSeasonEnum{SPRING,SUMMER,FALL,WINTER;}public classEnumTest{public voidjudge（SeasonEnum s）{//switch语句里的体现式可以是枚举值switch（s）{case SPRING.System.out.printin（穿暖花开，恰好踏青”）;break;case SUMMER.System.out.printin（夏日炎炎，适合游泳）;break;case FALL,.System.out.printin（秋高气爽，进补及时“）;break;case WINTER:System.out.printin冬日雪飘，围炉赏雪”；break;public staticvoid mainString[]args{//枚举类默认有一种values措施,返回该枚举类的所有实例for SeasonEnums:SeasonEnum.values^{System,out.printin s;//使用枚举类实例时,可通过EnumClass.variable形式来访问new EnumTest.judge SeasonEnum.SPRING;}__________________________________________________________________________________________________________________________枚举类的实例只能是枚举值，而不是随意的通过new来创立枚举类对象String StringBufferStringBuilder类String类是不可变类，即一旦一种String对象被创立后，包括在这个对象中的字符序列是不可变化的，直到这个对象被销毁StringBuffer对象则代表一种字符序列可变的字符串,当一种StringBuffer被创立后来，通过StringBuffer提供的appendinsertreverse等措施可以变化这个字符串对象的字符序列一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toStringO措施将其装换为一种String对象StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，因此性能略高因此一般状况下，假如需要创立一种内容可变的字符串对象，则应当优先考虑使用StringBuilder类类作为调用者也就是说java中看起来某些措施可以被独立执行，但实际上还是使用this或者类来作为调用者Java里措施参数传递方式只有一种值传递所谓值传递，就是讲实际参数值的副本复制品传入措施内，而参数自身不会受到任何影响从JDK
1.5之后，java容许定义形参个数可变的参数，从而容许为措施指定数量不确定的形参假如在定义措施时，在最终一种形参的类型后增长三点…，则表明该形参可以接受多种参数值，多种参数值被当成数组传入public classVarargs{//定义形参可变的措施public staticvoidtestinta,String...books{//books被当成数组处理forString tmp:books{System,out.printin tmp;.System,out.printlna;}public staticvoid mainString[]args{//调用test措施test⑸”hello,world,aa;}}数组形式的形参可以处在形参列表的任意位置，但个数可变的形参只能处在形参表的最终也就是说最多只能有一种长度可变的形参形参可变和传入数组的区别public staticvoidtestinta,String...books;public staticvoidtestinta,String[]books;test5,aa,bb,cc;test5,new String[]{aa,bb,cc};措施重载Java容许同一种类里定义多种同名措施，只要形参列表不一样就行假如同一种类中包括了两个或两个以上措施的措施名相似，但形参列表不一样，则被称为措施的重载Java程序确定一种措施需要三个要素调用者；措施名；形参列表措施的重载规定就是两同一不一样同一种类中措施名相似，参数列表不一样至于措施的其他部分，如措施返回值类型、修饰符等，与措施重载没有任何关系public classOverloadVarargs{public voidtest Stringmsg{System,out.printin只有一种参数的test;}〃由于前面已经有了一种字符串参数的措施,则长度可变形参里不包括一种字符串参数的形式public voidtest String・・・books{System.o〃Z.printin形参可变的test措施”；public staticvoid mainString[]args{OverloadVarargs olv=new OverloadVarargs;〃下面两次调用将执行第二个test措施olv.test olv.testaa,bb;//将调用第一种test措施olv.test Caa^;.//将调用第二个test措施olv.testnew String[]{aa};Java中变量分为组员变量和局部变量组员变量被分为类变量和实例变量两种，定义组员变量时没有static修饰的就是实例变量，有static修饰的就是类变量•变量的命名从程序的可读性角度来看，应当是多种故意义的单词连缀而成，其中第一种单词首字母小写，背面每个单词首字母大写•假如通过一种实例修改了类变量的值，由于这个类变量并不属于它，而是属于它对应的类因此，修改的仍然是类变量，与通过该类来修改类变量的成果完全相似，这会导致该类的其他实例来访问这个类变量时也将获得这个被修改正的值•组员变量不必显式初始化，只要为一种类定义了类变量或实例变量，系统就会在这个类的初始化阶段或创立该类的实例时，进行默认初始化•实例变量随实例的存在而存在，而类变量则随类的存在而存在实例也可访问类变量，同一种类的所有实例访问类变量时，实际上访问的是该类自身的同一种变量，也就是说，访问了同一片内存区•局部变量根据定义形式的不一样，又可分为三种形式形参，措施局部变量，代码块局部变量；局部变量除了形参之外，都必须显示初始化•在同一种类里，组员变量的作用范围是整个类内有效，一种类里不能定义两个同名的组员变量，虽然一种是类变量，一种是实例变量也不行；一种措施里不能定义两个同名的措施局部变量，措施局部变量与形参也不能同名；同一种措施中不一样代码块内局部变量可以同名；假如先定义代码块局部变量，后定义措施局部变量，前面定义的代码块局部变量与背面定义的措施局部变量也可同名.•Java容许局部变量和组员变量同名，假如措施里的局部变量和组员变量同名，局部变量会覆盖组员变量，假如需要在这个措施里引用被覆盖的组员变量，则可使用this（对于实例变量）或类名（对于类变量）作为调用者来限定访问组员变量public classVariableOverrideTest//定义一种name实例变量private String name=李冈!!“；〃定义一种price类变量private staticdouble price=
1.查找该措施中与否有名为a的局部变量
2.查找目前类中与否包括名为a的组员变量
3.查找a的直接父类中与否包括名为a的组员变量，一次上溯a的所有父类，直到java.lang.Object类,假如最终不能找到名为a的组员变量，则系统出现编译错误假如被覆盖的是类变量，在子类的措施中则可以通过父类名作为调用者来访问被覆盖的类变量当程序创立一种子类对象时，系统不仅会为该类中定义的实例变量分派内存，也会为它从父类继承得到的所有实例变量分派内存，虽然子类定义了与父类中同名的实例变量假如在子类里定义了与父类中已经有变量同名的变量，那么子类中定义的变量会隐藏父类中定义的变量注意不是完全覆盖，因此系统在创立子类对象时，仍然会为父类中定义的、被隐藏的变量分派内存空间.public classParent{public Stringtag=helloworld”;public classDerived extendsParent{〃定义一种私有的tag实例变量来隐藏父类的tag实例变量privateStringtag=abc;public classHideTest{public staticvoid mainString[]args{Derived d=new Derived;//程序不可访问d的私有变量tag,因此会出现编译错误//System,out.print Ind.tag;//将d变量显式的向上转型为Parent后,即可访问tag实例变量System,out.printin Parentd.tag;}调用父类构造器._______________________________子类不会获得父类的构造器，但子类构造器里可以调用父类构造器的初始化代码在一种构造器里调用另一种重载的构造器使用this调用来完毕，在子类构造器中调用父类构造器使用super调用来完毕public classBase{publicdoublesize;public Stringname;public Basedoublesize,Stringname{this.size=size;this.name=name;}public classSub extendsBase{public Stringcolor;public Subdoublesize,Stringname,Stringcolor{//m super调用父类构造器的初始化过程supersize,name;this.color=color;}public staticvoid mainString[]args{Sub s=new Sub
5.6,测试，red;System,out.printlns.size+”,+s.name+”,+s・color;}}Super调用的是其父类的构造器，而this调用的是同一种类中重载的构造器；因此，使用super调用父类的构造器也必须出目前子类构造器执行体的第一行，因此this调用和super调用不会同步出现当调用子类构造器来初始化子类对象时，父类构造器总会在子类构造器之前执行；不仅如此，执行父类构造器时，系统会再次上溯执行其父类的构造器……依次类推，创立任何java对象，最先执行的总是java.lang.Object类的构造器public classCreature{public Creature{System,out.printin无参”;}public classAnimal extendsCreature{public AnimalStringname{System,out.printin^Animal带一种参数的构造器+name;public AnimalStringname,intage{.〃this调用同一种重载构造器thisname;System,out.printin Animal带两个参数的构造器+age;}public classWolf extendsAnimal{public Wolf{.super“灰太狼”,4;System,out.printin^wolf无参构造器;public staticvoid mainStringargs{Wolf wf=new Wolf;//虽然main措施只创立了一种Wolf对象,但系统在底层完毕了复杂的操作,运行将会得到//无参//Animal带一种参数的构造器灰太狼//Animal带两个参数的构造器4。
个人认证
优秀文档
获得点赞 0
