java基础知识点总结.docx

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 声明构造器没有返回值。如果为构造器定义了返回值

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

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

6、，包括基本类型和引用类型。方法名：和成员变量的方法命名规则相同，通常建议方法名以英文动词开头。方法体里多条可执行语句之间有严格的执行顺序，排在方法体前面的语句总先执行，排在方法体后面的语句总是后执行。static 是一个特殊的关键字，它可用于修饰方法、成员变量等成员。static 修饰的成员表明它属于这个类本身，而不属于该类的单个实例，因此通过把 static 修饰的成员变量和方法被称为类变量、类方法（静态成员变量，静态成员方法）；不使用 static 修饰的成员变量和方法称为实例变量和实例方法（非静态成员变量，非静态成员方法）。静态成员不能直接访问非静态成员。static 的真正作用就是用于

7、区分成员变量、方法、内部类、初始化块，这四种成员到底属于类本身还是属于实例。有static 修饰的成员属于 类本身，没有类修饰的成员属于该类的实例。java 类大致有如下作用：定义变量创建对象调用类的类方法或访问类的类变量。定义一个类就是为了重复创建该类的实例，同一个类的多个实例具有相同的特征，而类则是定义了多个实例的共同特征。类里定义的方法和成员变量都可以通过类或实例来调用。Static 修饰的方法和成员变量，既可通过类来调用，也可通过实例来调用；没有使用 static 修饰的普通方法成员变量，只可通过实例来调用。Person p=new Person();这行代码创建了一个 Person

8、实例，也被称为 Person 对象，这个 Person 对象被赋给 p 变量。在这行代码中实际上产生了两个东西，一个是 p 变量，一个是 Person 对象。P 引用变量本身只存储了一个地址值，并未包含任何实际数据，但它指向实际的 Person 对象。Person 对象由多块内存组成，不同内存块分别存储了 Person 对象的不同成员变量。类是一种引用数据类型，因此程序中定义的 Person 类型的变量实际上是一个引用，它被存放在栈内存里，指向实际的 Person 对象；而真正的 Person对象则存放在堆内存中。当一个对象被创建成功以后，这个对象将保存在堆内存中，java 程序不允许直接访问

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

10、员，可以省略 this 前缀。如果在 static 修饰的方法中使用 this 关键字，则这个关键字就无法指向合适的对象，所以，static 修饰的方法中不能使用 this 引用。Java 编程时不要使用对象去调用 static 修饰的成员变量、方法、而是应该使用类去调用 static 修饰的成员变量、方法。如果确实需要在静态方法中访问另一个普通方法，则只能重新创建一个对象。大部分的时候，普通方法访问其他方法、成员变量时无须使用 this 前缀，但如果方法里有个局部变量和成员变量同名，但程序又需要在该方法里访问这个被覆盖的成员变量，则必须使用 this 前缀。This 引用也可以用于构造器中作

11、为默认引用，由于构造器时直接使用 new 关键字来调用，而不是使用对象来调用的，所以 this 在构造器中代表该构造器正在初始化对象。方法：Java 里的方法不能独立存在，所有的方法都必须定义在类里。如果这个方法是用来 static 修饰，则这个方法属于这个类，否则这个方法属于这个类的实例。执行方法时，必须使用类或者对象作为调用者。同一个类的一个方法调用另外一个方法时，如果被调方法是普通方法，则默认使用 this 作为调用者；如果被调用方法是静态方法，则默认使用类作为调用者。也就是说 java 中看起来某些方法可以被独立执行，但实际上还是使用 this 或者类来作为调用者。Java 里方法参数

12、传递方式只有一种：值传递。所谓值传递，就是讲实际参数值的副本（复制品）传入方法内，而参数本身不会受到任何影响。从 JDK1.5 之后，java 允许定义形参个数可变的参数，从而允许为方法指定数量不确定的形参。如果在定义方法时，在最后一个形参的类型后增加三点（）,则表明该形参可以接受多个参数值，多个参数值被当成数组传入。public class Varargs /定义形参可变的方法public static void test(int a,String. books)/books 被当成数组处理for(String tmp:books)System.out.println(tmp);System

13、.out.println(a);public static void main(String args)/调用 test 方法test(5,“hello“,“world“,“aa“);数组形式的形参可以处于形参列表的任意位置，但个数可变的形参只能处于形参表的最后。也就是说最多只能有一个长度可变的形参。形参可变和传入数组的区别：public static void test(int a,String. books);public static void test(int a,String books);test(5,“aa“,“bb“,“cc“);test(5,new String“aa“,“b

14、b“,“cc“);方法重载：Java 允许同一个类里定义多个同名方法，只要形参列表不同就行。如果同一个类中包含了两个或两个以上方法的方法名相同，但形参列表不同，则被称为方法的重载。Java 程序确定一个方法需要三个要素：调用者；方法名；形参列表。方法的重载要求就是两同一不同：同一个类中方法名相同，参数列表不同。至于方法的其他部分，如方法返回值类型、修饰符等，与方法重载没有任何关系。public class OverloadVarargs public void test(String msg)System.out.println(“只有一个参数的 test“);/因为前面已经有了一个字符串参数

15、的方法，则长度可变形参里不包含一个字符串参数的形式public void test(String .books)System.out.println(“形参可变的 test 方法“);public static void main(String args)OverloadVarargs olv=new OverloadVarargs();/下面两次调用将执行第二个 test 方法olv.test();olv.test(“aa“,“bb“);/将调用第一个 test 方法olv.test(“aa“);/将调用第二个 test 方法olv.test(new String“aa“);Java 中变量

16、分为：成员变量和局部变量。成员变量被分为类变量和实例变量两种，定义成员变量时没有 static 修饰的就是实例变量，有 static 修饰的就是类变量。 变量的命名：从程序的可读性角度来看，应该是多个有意义的单词连缀而成，其中第一个单词首字母小写，后面每个单词首字母大写。 如果通过一个实例修改了类变量的值，由于这个类变量并不属于它，而是属于它对应的类。因此，修改的依然是类变量，与通过该类来修改类变量的结果完全相同，这会导致该类的其他实例来访问这个类变量时也将获得这个被修改过的值。 成员变量无须显式初始化，只要为一个类定义了类变量或实例变量，系统就会在这个类的初始化阶段或创建该类的实例时，进行默

17、认初始化。 实例变量随实例的存在而存在，而类变量则随类的存在而存在。实例也可访问类变量，同一个类的所有实例访问类变量时，实际上访问的是该类本身的同一个变量，也就是说，访问了同一片内存区。 局部变量根据定义形式的不同，又可分为三种形式：形参，方法局部变量，代码块局部变量；局部变量除了形参之外，都必须显示初始化。 在同一个类里，成员变量的作用范围是整个类内有效，一个类里不能定义两个同名的成员变量，即使一个是类变量，一个是实例变量也不行；一个方法里不能定义两个同名的方法局部变量，方法局部变量与形参也不能同名；同一个方法中不同代码块内局部变量可以同名；如果先定义代码块局部变量，后定义方法局部变量，前面

18、定义的代码块局部变量与后面定义的方法局部变量也可同名. Java 允许局部变量和成员变量同名，如果方法里的局部变量和成员变量同名，局部变量会覆盖成员变量，如果需要在这个方法里引用被覆盖的成员变量，则可使用 this(对于实例变量)或类名（对于类变量）作为调用者来限定访问成员变量。public class VariableOverrideTest /定义一个 name 实例变量private String name=“李刚“;/定义一个 price 类变量private static double price=78.0;public static void main(String args)/方

19、法里局部变量覆盖成员变量，将输出 price 的局部变量 65int price=65;System.out.println(price);/使用类名作为 price 变量的限定，将输出 price 类变量的值System.out.println(VariableOverrideTest.price);new VariableOverrideTest().info();public void info()/方法里的局部变量，局部变量覆盖成员变量，输出 name 局部变量的值：孙悟空String name=“孙悟空“;System.out.println(name);/将输出 name 实例的值

20、：李刚System.out.println(this.name);当系统加载类或创建该类的实例时，系统自动为成员变量分配内存空间，并在分配内存空间后，自动为成员变量指定初始值。Person p1=new Person();时，如果这行代码是第一次使用 Person 类，则系统通常会在第一次使用 Person 类时加载这个类，并初始化这个类。局部变量定以后，必须经过显式初始化后才能使用，系统不会为局部变量执行初始化。局部变量不属于任何类或者实例，因此它总是保存在其所在方法的栈内存中。如果局部变量时基本类型的变量，则直接把这个变量的值保存在该变量对应的内存中；如果局部变量是一个引用类型的变量，则这

21、个变量里存放的是地址，通过该地址引用到该变量实际引用的对象或者数组。栈内存中的变量无须系统垃圾回收，往往随是方法或代码块的运行结束而结束。如果定义的某个变量是用于描述某个类或某个对象的固有信息的，这种变量应该定义成成员变量。如果这种信息对这个类的所有实例完全相同，或者说它是类相关的，则该定义成类变量；如果这个信息是实例相关的，则应该定义成实例变量。用于保存某个类或某个实例状态信息的变量通常应该使用成员变量。如果某个信息需要在某个类的多个方法之间进行共享，则这个信息应该使用成员变量来保存。隐藏和封装访问控制符用于控制一个类的成员是否可以被其他类访问。Java 提供了 3 个访问控制修饰符：pri

22、vate，protected，和 public,还有一个默认访问控制修饰符 defaultPrivate(当前类访问权限)；default（包访问权限） ；protected（子类访问权限）：如果一个成员使用 protected 访问修饰符修饰，那么这个成员既可以被同一个包中的其他类访问，也可以被不同包中子类访问。通常情况下，使用protected 修饰的方法，通常希望其子类来重写这个方法。Public（公共访问权限）对于局部变量而言，其作用域就是它所在的方法，不可能被其他类访问，因此不能使用访问控制符来修饰。外部类只能有两种访问控制级别：public 和默认，不能使用 private 和 p

23、rotectedpublic class Person private String name;private int age;public void setName(String name)if(name.length()6|name.length() 100 | age 0) System.out.println(“error“); else this.age = age;public int getAge()return this.age;public class PersonTest public static void main(String args)Person p=new Pe

24、rson();/下面的变量不会运行错误，但是会提示错误p.setAge(1000);/因为上面没有成功设置 p 的 age 成员，故输出 0 System.out.println(p.getAge();/成功设置 p 的 age 成员p.setAge(30);System.out.println(p.getAge();/成功设置 p 的 name 成员p.setName(“李刚“);System.out.println(p.getName();构造器：构造器最大的用途是创建对象时执行初始化。当创建一个对象时，系统为这个对象的实例变量进行默认初始化，这种默认的初始化把所有基本类型的实例变量设为

25、0（对数值型实例变量）或 false（对布尔型实例变量） ，把所有引用类型的实例变量设为 null。如果想改变这种默认的初始化，想让系统创建对象时就位该对象的实例变量显式指定初始值，就可以通过构造器来实现。因为构造器主要用于被其他方法调用，用以返回该类的实例，因而通常把构造器设置成 public 访问权限，从而允许系统中任何位置的类来创建该类的对象。如果设置成 protected，主要用于被子类调用；设置为 private，阻止其他类创建该类的实例。如果系统中包含了多个构造器，其中一个构造器 B 的执行体里完全包含另一个构造器 A 的执行体。为了这构造器 B 中调用构造器 A 中的初始化代码，

26、又不会重新创建一个 java 对象，可以使用 this 关键字来调用相应的构造器。public class Apple public String name;public String color;public double weight;/两个参数的构造器public Apple(String name,String color)this.name=name;this.color=color;/三个参数的构造器public Apple(String name,String color,double weight)/通过 this 调用另一个重载的构造器的初始化代码this(name,colo

27、r);/通过 this 引用该构造器正在初始化的 Java 对象this.weight=weight;使用 this 调用另一个重载的构造器只能在构造器中使用，而且必须作为构造器执行体的第一条语句。使用 this 调用重载的构造器时，系统会根据 this 后括号里的实参来调用形参列表与之对应的构造器类的继承：Java 继承通过 extends 关键字来实现实现继承的类被称为子类，被继承的类被称为父类，有的也称为基类、超类。因为子类是一种特殊的父类，因此父类包含的范围总比子类包含的范围要大。Java 子类不能获得父类的构造器public class Fruit public double wei

28、ght;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=new Apple();/Apple 对象本身没有 weight 成员变量，但是， Apple 父类有 weight 成员变量，所以，也可以访问Apple 对象的 weight 成员变量a.weight=56;/调用 Apple 对象

29、的 info()方法a.info();Java 类只能有一个直接父类，实际上,Java 类可以有无限多个间接父类。重写父类方法：子类扩展了父类，子类是一个特殊的父类。大部分时候，子类总是以父类为基础，额外增加新的成员变量和方法。但有一种情况例外：子类需要重写父类方法。public class Bird /Bird 类的 fly()方法public void fly()System.out.println(“我在天空中飞“);public class Ostrich extends Bird /重写 Bird 类的 fly()方法public void fly()System.out.print

30、ln(“我在陆地上飞“);public static void main(String args)/创建 Ostrich 对象Ostrich or=new Ostrich();/执行 Ostrich 对象的 fly（）方法，将输出 “我在陆地上飞 ”or.fly();这种子类包含与父类同名方法的现象被称为方法重写（Override） ，也被称为方法覆盖。可以说子类重写了父类的方法，也可以说子类覆盖了父类的方法。方法的重写要遵循“两同两小一大”规则， “两同”即方法名相同、形参列表相同；“两小”指的是子类方法的返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类声明抛出的

31、异常类更小或相等；“一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。覆盖方法和被覆盖方法要么都是类方法，要么都是实例方法。当子类覆盖了父类方法后，子类的对象将无法访问父类中被覆盖的方法，但可以在子类方法中调用被覆盖的方法。如果需要在子类方法中调用父类中被覆盖的方法，则可以使用 super（被覆盖的是实例方法）或者父类类名（被覆盖的是类方法）作为调用者来调用父类中被覆盖的方法。如果父类方法具有 private 访问权限，则该方法对其子类是隐藏的，因此其子类无法访问该方法，也就是无法重写该方法。重载只要发生在同个类多个同名方法之间，而重写发生在子类和父类同名方法之间。父类方法和子类

32、方法之间也可能发生重载。Super 限定：Super 是 Java 提供的一个关键字，super 用于限定该对象调用它从父类继承得到的实例变量或方法。Super 不能出现在 static 修饰的方法中。Static 修饰的方法是属于类的，该方法的调用者可能是一个类，而不是对象，因而 super限定就失去了意义。如果在构造器中使用 super,则 super 用于限定该构造器初始化的是该对象从父类继承得到的实例变量，而不是该类自己定义的实例变量。如果子类定义了和父类同名的实例变量，则会发生子类实例变量隐藏父类实例变量的情形。在正常情况下，子类里定义的方法直接访问该实例变量，默认会访问到子类中定义

33、的实例变量，无法访问到父类中被隐藏的实例变量。在子类定义的实例方法中可以通过 super 来访问父类中被隐藏的实例变量。public class BaseClass public int a=5;public class SubClass extends BaseClasspublic int a=7;public void accessOwner()System.out.println(a);public void accessBase()/通过 super 来限定访问从父类继承得到的 a 实例变量System.out.println(super.a);public static void

34、main(String args)SubClass sb=new SubClass();sb.accessBase(); /输出 5sb.accessOwner(); /输出 7如果在某个方法中访问名为 a 的成员变量，但没有显式指定调用者，则系统查找 a 的顺序为：1. 查找该方法中是否有名为 a 的局部变量2. 查找当前类中是否包含名为 a 的成员变量3. 查找 a 的直接父类中是否包含名为 a 的成员变量，一次上溯 a 的所有父类，直到 java.lang.Object 类，如果最终不能找到名为 a 的成员变量，则系统出现编译错误。如果被覆盖的是类变量，在子类的方法中则可以通过父类名作为

35、调用者来访问被覆盖的类变量当程序创建一个子类对象时，系统不仅会为该类中定义的实例变量分配内存，也会为它从父类继承得到的所有实例变量分配内存，即使子类定义了与父类中同名的实例变量。如果在子类里定义了与父类中已有变量同名的变量，那么子类中定义的变量会隐藏父类中定义的变量。注意不是完全覆盖，因此系统在创建子类对象时，依然会为父类中定义的、被隐藏的变量分配内存空间。public class Parent public String tag=“helloworld“;public class Derived extends Parent /定义一个私有的 tag 实例变量来隐藏父类的 tag 实例变量p

36、rivate 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);调用父类构造器：子类不会获得父类的构造器，但子类构造器里可以调用父类构造器的初始化代码。在一个构造器里调用另一个重载的构造器使用

37、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 Basepublic String color;public Sub(double size,String name,String color)/通过 super 调用父类构造器的初始化过程super(size,name);t

38、his.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 调用不会同时出现。当调用子类构造器来初始化子类对象时，父类构造器总会在子类构造器之前执行；不仅如此，执行父类构造器时，系统会再次上溯执行其父

39、类的构造器依次类推，创建任何 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 age)/this 调用同一个重载构造器this(name);System.out.pri

40、ntln(“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 带两个参数的构造器 4/ wolf 无参构造器创建任何对象总是从该类所在继承树最顶

41、层类的构造器开始执行，然后依次向下执行，最后才执行本类的构造器。如果某个父类通过 this 调用了同类中重载的构造器，就会依次执行此父类的多个构造器。4.7 多态：Java 引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就可能出现所谓的多态。public class BaseClass public int book=6;public void base()System.out.println(“父类的普通方法“);public void test()System.out.println(“父类被覆盖的方法“);public class SubClass extends BaseClass /重写定义一个 book 实例变量隐藏父类的 book 实例变量