java基础知识资料点情况总结分析.doc

《java基础知识资料点情况总结分析.doc》由会员分享，可在线阅读，更多相关《java基础知识资料点情况总结分析.doc（34页珍藏版）》请在得力文库 - 分享文档赚钱的网站上搜索。

1、Created by AIwen on 2017/5/14.java是面向对象的程序设计语言；类可被认为是一种自定义的数据类型，可以使用类来定义变量，所有使用类定义的变量都是引用变量，它们将会引用到类的对象。类用于描述客观世界里某一类对象的共同特征，而对象则是类的具体存在，java程序使用类的构造器来创建该类的对象。java也支持面向对象的三大特征：封装、继承、和多态。java提供了private、protected、和public三个访问控制修饰符来实现良好的封装，提供了extends关键字让子类继承父类，子类继承父类就可以继承到父类的成员变量和和方法，如果访问控制允许，子类实例可以直接调用

2、父类里定义的方法。继承是实现类复用的重要手段。使用继承关系来实现复用时，子类对象可以直接赋给父类变量，这个变量具有多态性。面向对象的程序设计过程中有两个重要的概念：类（Class)和对象（object，也被称为实例，instance）。类可以包含三种最常见的成员：构造器、成员变量、和方法。构造器用于构造该类的实例，java语言通过new关键字类调用构造器，从而返回该类的实例。构造器是一个类创建对象的根本途径，如果一个类没有构造器，这个类通常无法创建实例。因此java语言提供了一个功能：如果程序员没有为一个类编写构造器，则系统会为该类提供一个默认的构造器，这个构造器总是没有参数的。一旦程序员为一

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

4、回值，编译时不会出错，但java会把这个所谓的构造器当成方法来处理它就不再是构造器。实际上类的构造器是有返回值的，当使用new关键字来调用构造器时，构造器返回该类的实例，可以把这个类的实例当成构造器的返回值。因此构造器的返回值类型总是当前类，无须定义返回值类型。不要在构造器里显式的使用return来返回当前类的对象，因为构造器的返回值是隐式的。java类名必须是由一个或多个有意义的单词连缀而成的，每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。成员变量：成员变量的修饰符：public、protected、private、static、final前三个只能出现一个再和后面

5、的修饰符组合起来修饰成员变量，也可省略。成员变量：由一个或者多个有意义的单词连缀而成，第一个单词首字母小写，后面每个单词首字母大写，其他字母全部小写，单词与单词之间不要使用任何分隔符。类型：可以是java语言允许的任何数据类型，包括基本类型和引用类型。成员方法：方法修饰符：public、protected、private、static、final、abstract，前三个只能出现一个，static和final最多只能出现其中的一个，和abstract组合起来使用。也可省略。返回值类型：可以是java语言的允许的任何数据类型，包括基本类型和引用类型。方法名：和成员变量的方法命名规则相同，通常建议

6、方法名以英文动词开头。方法体里多条可执行语句之间有严格的执行顺序，排在方法体前面的语句总先执行，排在方法体后面的语句总是后执行。static是一个特殊的关键字，它可用于修饰方法、成员变量等成员。static修饰的成员表明它属于这个类本身，而不属于该类的单个实例，因此通过把static修饰的成员变量和方法被称为类变量、类方法（静态成员变量，静态成员方法）；不使用static修饰的成员变量和方法称为实例变量和实例方法（非静态成员变量，非静态成员方法）。静态成员不能直接访问非静态成员。static的真正作用就是用于区分成员变量、方法、内部类、初始化块，这四种成员到底属于类本身还是属于实例。有stat

7、ic修饰的成员属于 类本身，没有类修饰的成员属于该类的实例。java类大致有如下作用：定义变量创建对象调用类的类方法或访问类的类变量。定义一个类就是为了重复创建该类的实例，同一个类的多个实例具有相同的特征，而类则是定义了多个实例的共同特征。类里定义的方法和成员变量都可以通过类或实例来调用。Static修饰的方法和成员变量，既可通过类来调用，也可通过实例来调用；没有使用static修饰的普通方法成员变量，只可通过实例来调用。 Person p=new Person();这行代码创建了一个Person实例，也被称为Person对象，这个Person对象被赋给p变量。在这行代码中实际上产生了两个东西

8、，一个是p变量，一个是Person对象。P引用变量本身只存储了一个地址值，并未包含任何实际数据，但它指向实际的Person对象。Person对象由多块内存组成，不同内存块分别存储了Person对象的不同成员变量。类是一种引用数据类型，因此程序中定义的Person类型的变量实际上是一个引用，它被存放在栈内存里，指向实际的Person对象；而真正的Person对象则存放在堆内存中。当一个对象被创建成功以后，这个对象将保存在堆内存中，java程序不允许直接访问堆内存中的对象，只能通过该对象的引用操作该对象。堆内存里的对象可以有多个引用，即多个引用变量指向同一个对象。如果堆内存里的对象没有任何变量指向

9、该对象，那么程序将无法再访问该对象，这个对象也就变成了垃圾，java垃圾回收机制将回收该对象，释放该对象所占的内存区。对象的this引用Java提供了一个this关键字，this关键字总是指向调用该方法的对象。This作为对象的默认引用有两种情形：构造器中引用该构造器正在初始化的对象；在方法中引用调用该方法的对象。This关键字最大的作用就是让类中一个方法，访问该类里的另一个方法或者实例变量。Java允许对象的一个成员直接调用另一个成员，可以省略this前缀。如果在static修饰的方法中使用this关键字，则这个关键字就无法指向合适的对象，所以，static修饰的方法中不能使用this引用。

10、Java编程时不要使用对象去调用static修饰的成员变量、方法、而是应该使用类去调用static修饰的成员变量、方法。如果确实需要在静态方法中访问另一个普通方法，则只能重新创建一个对象。大部分的时候，普通方法访问其他方法、成员变量时无须使用this前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用this前缀。This引用也可以用于构造器中作为默认引用，由于构造器时直接使用new关键字来调用，而不是使用对象来调用的，所以this在构造器中代表该构造器正在初始化对象。方法：Java里的方法不能独立存在，所有的方法都必须定义在类里。如果这个方

11、法是用来static修饰，则这个方法属于这个类，否则这个方法属于这个类的实例。执行方法时，必须使用类或者对象作为调用者。同一个类的一个方法调用另外一个方法时，如果被调方法是普通方法，则默认使用this作为调用者；如果被调用方法是静态方法，则默认使用类作为调用者。也就是说java中看起来某些方法可以被独立执行，但实际上还是使用this或者类来作为调用者。Java里方法参数传递方式只有一种：值传递。所谓值传递，就是讲实际参数值的副本（复制品）传入方法内，而参数本身不会受到任何影响。从JDK1.5之后，java允许定义形参个数可变的参数，从而允许为方法指定数量不确定的形参。如果在定义方法时，在最后一

12、个形参的类型后增加三点（）,则表明该形参可以接受多个参数值，多个参数值被当成数组传入。public class Varargs /定义形参可变的方法 public static void test(int a,String. books) /books被当成数组处理 for(String tmp:books) System.out.println(tmp); System.out.println(a); public static void main(String args) /调用test方法 test(5,hello,world,aa); 数组形式的形参可以处于形参列表的任意位置，但个数可

13、变的形参只能处于形参表的最后。也就是说最多只能有一个长度可变的形参。形参可变和传入数组的区别：public static void test(int a,String. books);public static void test(int a,String books);test(5,aa,bb,cc);test(5,new Stringaa,bb,cc);方法重载：Java允许同一个类里定义多个同名方法，只要形参列表不同就行。如果同一个类中包含了两个或两个以上方法的方法名相同，但形参列表不同，则被称为方法的重载。Java程序确定一个方法需要三个要素：调用者；方法名；形参列表。方法的重载要求就

14、是两同一不同：同一个类中方法名相同，参数列表不同。至于方法的其他部分，如方法返回值类型、修饰符等，与方法重载没有任何关系。public class OverloadVarargs public void test(String msg) System.out.println(只有一个参数的test); /因为前面已经有了一个字符串参数的方法，则长度可变形参里不包含一个字符串参数的形式 public void test(String .books) System.out.println(形参可变的test方法); public static void main(String args) Over

15、loadVarargs olv=new OverloadVarargs(); /下面两次调用将执行第二个test方法 olv.test(); olv.test(aa,bb); /将调用第一个test方法 olv.test(aa); /将调用第二个test方法 olv.test(new Stringaa); Java中变量分为：成员变量和局部变量。成员变量被分为类变量和实例变量两种，定义成员变量时没有static修饰的就是实例变量，有static修饰的就是类变量。l 变量的命名：从程序的可读性角度来看，应该是多个有意义的单词连缀而成，其中第一个单词首字母小写，后面每个单词首字母大写。l 如果通过

16、一个实例修改了类变量的值，由于这个类变量并不属于它，而是属于它对应的类。因此，修改的依然是类变量，与通过该类来修改类变量的结果完全相同，这会导致该类的其他实例来访问这个类变量时也将获得这个被修改过的值。l 成员变量无须显式初始化，只要为一个类定义了类变量或实例变量，系统就会在这个类的初始化阶段或创建该类的实例时，进行默认初始化。l 实例变量随实例的存在而存在，而类变量则随类的存在而存在。实例也可访问类变量，同一个类的所有实例访问类变量时，实际上访问的是该类本身的同一个变量，也就是说，访问了同一片内存区。l 局部变量根据定义形式的不同，又可分为三种形式：形参，方法局部变量，代码块局部变量；局部变

17、量除了形参之外，都必须显示初始化。l 在同一个类里，成员变量的作用范围是整个类内有效，一个类里不能定义两个同名的成员变量，即使一个是类变量，一个是实例变量也不行；一个方法里不能定义两个同名的方法局部变量，方法局部变量与形参也不能同名；同一个方法中不同代码块内局部变量可以同名；如果先定义代码块局部变量，后定义方法局部变量，前面定义的代码块局部变量与后面定义的方法局部变量也可同名.l Java允许局部变量和成员变量同名，如果方法里的局部变量和成员变量同名，局部变量会覆盖成员变量，如果需要在这个方法里引用被覆盖的成员变量，则可使用this(对于实例变量)或类名（对于类变量）作为调用者来限定访问成员变

18、量。public class VariableOverrideTest /定义一个name实例变量 private String name=李刚; /定义一个price类变量 private static double price=78.0; public static void main(String args) /方法里局部变量覆盖成员变量，将输出price的局部变量65 int price=65; System.out.println(price); /使用类名作为price变量的限定，将输出price类变量的值 System.out.println(VariableOverrideTe

19、st.price); new VariableOverrideTest().info(); public void info() /方法里的局部变量，局部变量覆盖成员变量，输出name局部变量的值：孙悟空 String name=孙悟空; System.out.println(name); /将输出name实例的值：李刚 System.out.println(this.name); 当系统加载类或创建该类的实例时，系统自动为成员变量分配内存空间，并在分配内存空间后，自动为成员变量指定初始值。Person p1=new Person();时，如果这行代码是第一次使用Person类，则系统通常会在

20、第一次使用Person类时加载这个类，并初始化这个类。局部变量定以后，必须经过显式初始化后才能使用，系统不会为局部变量执行初始化。局部变量不属于任何类或者实例，因此它总是保存在其所在方法的栈内存中。如果局部变量时基本类型的变量，则直接把这个变量的值保存在该变量对应的内存中；如果局部变量是一个引用类型的变量，则这个变量里存放的是地址，通过该地址引用到该变量实际引用的对象或者数组。栈内存中的变量无须系统垃圾回收，往往随是方法或代码块的运行结束而结束。如果定义的某个变量是用于描述某个类或某个对象的固有信息的，这种变量应该定义成成员变量。如果这种信息对这个类的所有实例完全相同，或者说它是类相关的，则该

21、定义成类变量；如果这个信息是实例相关的，则应该定义成实例变量。用于保存某个类或某个实例状态信息的变量通常应该使用成员变量。如果某个信息需要在某个类的多个方法之间进行共享，则这个信息应该使用成员变量来保存。隐藏和封装访问控制符用于控制一个类的成员是否可以被其他类访问。Java提供了3个访问控制修饰符：private，protected，和public,还有一个默认访问控制修饰符defaultPrivate(当前类访问权限)；default（包访问权限）；protected（子类访问权限）：如果一个成员使用protected访问修饰符修饰，那么这个成员既可以被同一个包中的其他类访问，也可以被不同包

22、中子类访问。通常情况下，使用protected修饰的方法，通常希望其子类来重写这个方法。Public（公共访问权限）对于局部变量而言，其作用域就是它所在的方法，不可能被其他类访问，因此不能使用访问控制符来修饰。外部类只能有两种访问控制级别：public和默认，不能使用private和protectedpublic class Person private String name; private int age; public void setName(String name) if(name.length()6|name.length() 100 | age 0) System.out.pr

23、intln(error); else this.age = age; public int getAge() return this.age; public class PersonTest public static void main(String args) Person p=new Person(); /下面的变量不会运行错误，但是会提示错误 p.setAge(1000); /因为上面没有成功设置p的age成员，故输出0 System.out.println(p.getAge(); /成功设置p的age成员 p.setAge(30); System.out.println(p.getA

24、ge(); /成功设置p的name成员 p.setName(李刚); System.out.println(p.getName(); 构造器：构造器最大的用途是创建对象时执行初始化。当创建一个对象时，系统为这个对象的实例变量进行默认初始化，这种默认的初始化把所有基本类型的实例变量设为0（对数值型实例变量）或false（对布尔型实例变量），把所有引用类型的实例变量设为null。如果想改变这种默认的初始化，想让系统创建对象时就位该对象的实例变量显式指定初始值，就可以通过构造器来实现。因为构造器主要用于被其他方法调用，用以返回该类的实例，因而通常把构造器设置成public访问权限，从而允许系统中任何

25、位置的类来创建该类的对象。如果设置成protected，主要用于被子类调用；设置为private，阻止其他类创建该类的实例。如果系统中包含了多个构造器，其中一个构造器B的执行体里完全包含另一个构造器A的执行体。为了这构造器B中调用构造器A中的初始化代码，又不会重新创建一个java对象，可以使用this关键字来调用相应的构造器。public class Apple public String name; public String color; public double weight; /两个参数的构造器 public Apple(String name,String color) this.

26、name=name; this.color=color; /三个参数的构造器 public Apple(String name,String color,double weight) /通过this调用另一个重载的构造器的初始化代码 this(name,color); /通过this引用该构造器正在初始化的Java对象 this.weight=weight; 使用this调用另一个重载的构造器只能在构造器中使用，而且必须作为构造器执行体的第一条语句。使用this调用重载的构造器时，系统会根据this后括号里的实参来调用形参列表与之对应的构造器类的继承：Java继承通过extends关键字来实现

27、实现继承的类被称为子类，被继承的类被称为父类，有的也称为基类、超类。因为子类是一种特殊的父类，因此父类包含的范围总比子类包含的范围要大。Java子类不能获得父类的构造器public class Fruit public double weight; public void info() System.out.println(weight); public class Apple extends Fruit /Apple类继承了Fruit类，所以Apple对象也就有了weight成员变量和info()方法 public static void main(String args) Apple a=

28、new Apple(); /Apple对象本身没有weight成员变量，但是，Apple父类有weight成员变量，所以，也可以访问Apple对象的weight成员变量 a.weight=56; /调用Apple对象的info()方法 a.info(); Java类只能有一个直接父类，实际上,Java类可以有无限多个间接父类。重写父类方法：子类扩展了父类，子类是一个特殊的父类。大部分时候，子类总是以父类为基础，额外增加新的成员变量和方法。但有一种情况例外：子类需要重写父类方法。public class Bird /Bird类的fly()方法 public void fly() System.o

29、ut.println(我在天空中飞); public class Ostrich extends Bird /重写Bird类的fly()方法 public void fly() System.out.println(我在陆地上飞); public static void main(String args) /创建Ostrich对象 Ostrich or=new Ostrich(); /执行Ostrich对象的fly（）方法，将输出“我在陆地上飞” or.fly(); 这种子类包含与父类同名方法的现象被称为方法重写（Override），也被称为方法覆盖。可以说子类重写了父类的方法，也可以说子类覆

30、盖了父类的方法。方法的重写要遵循“两同两小一大”规则，“两同”即方法名相同、形参列表相同；“两小”指的是子类方法的返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类声明抛出的异常类更小或相等；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法。当子类覆盖了父类方法后，子类的对象将无法访问父类中被覆盖的方法，但可以在子类方法中调用被覆盖的方法。如果需要在子类方法中调用父类中被覆盖的方法，则可以使用super（被覆盖的是实例方法）或者父类类名（被覆盖的是类方法）作为调用者来调用父类中被覆盖的方法。如果父类

31、方法具有private访问权限，则该方法对其子类是隐藏的，因此其子类无法访问该方法，也就是无法重写该方法。重载只要发生在同个类多个同名方法之间，而重写发生在子类和父类同名方法之间。父类方法和子类方法之间也可能发生重载。Super限定：Super是Java提供的一个关键字，super用于限定该对象调用它从父类继承得到的实例变量或方法。Super不能出现在static修饰的方法中。Static修饰的方法是属于类的，该方法的调用者可能是一个类，而不是对象，因而super限定就失去了意义。如果在构造器中使用super,则super用于限定该构造器初始化的是该对象从父类继承得到的实例变量，而不是该类自己

32、定义的实例变量。如果子类定义了和父类同名的实例变量，则会发生子类实例变量隐藏父类实例变量的情形。在正常情况下，子类里定义的方法直接访问该实例变量，默认会访问到子类中定义的实例变量，无法访问到父类中被隐藏的实例变量。在子类定义的实例方法中可以通过super来访问父类中被隐藏的实例变量。public class BaseClass public int a=5;public class SubClass extends BaseClass public int a=7; public void accessOwner() System.out.println(a); public void acc

33、essBase() /通过super来限定访问从父类继承得到的a实例变量 System.out.println(super.a); public static void main(String args) SubClass sb=new SubClass(); sb.accessBase(); /输出5 sb.accessOwner(); /输出7 如果在某个方法中访问名为a的成员变量，但没有显式指定调用者，则系统查找a的顺序为：1. 查找该方法中是否有名为a的局部变量2. 查找当前类中是否包含名为a的成员变量3. 查找a的直接父类中是否包含名为a的成员变量，一次上溯a的所有父类，直到java

34、.lang.Object类，如果最终不能找到名为a的成员变量，则系统出现编译错误。如果被覆盖的是类变量，在子类的方法中则可以通过父类名作为调用者来访问被覆盖的类变量当程序创建一个子类对象时，系统不仅会为该类中定义的实例变量分配内存，也会为它从父类继承得到的所有实例变量分配内存，即使子类定义了与父类中同名的实例变量。如果在子类里定义了与父类中已有变量同名的变量，那么子类中定义的变量会隐藏父类中定义的变量。注意不是完全覆盖，因此系统在创建子类对象时，依然会为父类中定义的、被隐藏的变量分配内存空间。public class Parent public String tag=helloworld;pu

35、blic class Derived extends Parent /定义一个私有的tag实例变量来隐藏父类的tag实例变量 private String tag=abc;public class HideTest public static void main(String args) Derived d=new Derived(); /程序不可访问d的私有变量tag，所以会出现编译错误/ System.out.println(d.tag); /将d变量显式的向上转型为Parent后，即可访问tag实例变量 System.out.println(Parent)d).tag); 调用父类构造器

36、：子类不会获得父类的构造器，但子类构造器里可以调用父类构造器的初始化代码。在一个构造器里调用另一个重载的构造器使用this调用来完成，在子类构造器中调用父类构造器使用super调用来完成。public class Base public double size; public String name; public Base(double size,String name) this.size=size; this.name=name; public class Sub extends Base public String color; public Sub(double size,Strin

37、g name,String color) /通过super调用父类构造器的初始化过程 super(size,name); this.color=color; public static void main(String args) Sub s=new Sub(5.6,测试,red); System.out.println(s.size+,+s.name+,+s.color); Super调用的是其父类的构造器，而this调用的是同一个类中重载的构造器；因此，使用super调用父类的构造器也必须出现在子类构造器执行体的第一行，所以this调用和super调用不会同时出现。当调用子类构造器来初始化

38、子类对象时，父类构造器总会在子类构造器之前执行；不仅如此，执行父类构造器时，系统会再次上溯执行其父类的构造器依次类推，创建任何java对象，最先执行的总是java.lang.Object类的构造器。public class Creature public Creature() System.out.println(无参); public class Animal extends Creature public Animal(String name) System.out.println(Animal带一个参数的构造器+name); public Animal(String name,int a

39、ge) /this调用同一个重载构造器 this(name); System.out.println(Animal带两个参数的构造器+age); public class Wolf extends Animal public Wolf() super(灰太狼,4); System.out.println(wolf无参构造器); public static void main(String args) Wolf wf=new Wolf(); /虽然main方法只创建了一个Wolf对象，但系统在底层完成了复杂的操作，运行将会得到/ 无参/ Animal带一个参数的构造器灰太狼/ Animal带两个

40、参数的构造器4/ wolf无参构造器 创建任何对象总是从该类所在继承树最顶层类的构造器开始执行，然后依次向下执行，最后才执行本类的构造器。如果某个父类通过this调用了同类中重载的构造器，就会依次执行此父类的多个构造器。4.7多态：Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态。public class BaseClass public int book=6; public void base() System.out.println(父类的普通

41、方法); public void test() System.out.println(父类被覆盖的方法); public class SubClass extends BaseClass /重写定义一个book实例变量隐藏父类的book实例变量 public String book=abc; public void test() System.out.println(子类的覆盖父类的方法); public void sub() System.out.println(子类的普通方法); public static void main(String args) /编译时类型和运行时类型完全一样，因此不存在多态 BaseClass bc=new BaseClass(); /输出父类bc对象的成员变量值：6 System.out.println(bc.book); bc.test(); bc.base(); /编译时类型和运行时类型完全一样，因此不存在多态 SubClass sbc=new SubClass(); /输出子类对象sbc的成员变量值：abc System.out.println(sbc.book); sbc.test()