[关闭]
@hainingwyx 2017-06-07T01:30:05.000000Z 字数 8099 阅读 656

面向对象上

Java


类和对象

定义类

  1. [修饰符] class 类名 {….类体…..}

定义成员变量

  1. [修饰符] 类型 成员变量名[=默认值];

定义方法

  1. [修饰符] 方法返回值类型 方法名(形参列表) {….方法体….}

定义构造器

  1. [修饰符] 构造器名(形参列表) {……}

创建对象

  1. // 定义p变量的同时,为p变量赋值
  2. // 引用型变量p里存放的仅仅是一个引用,它指向实际的对象
  3. // 引用变量存放在栈内存中,实际对象存放在堆内存中
  4. Person p = new Person();
  1. // 多个引用变量指向同一个对象
  2. Person p2=p;

如果堆内存里的对象没有任何变量指向该对象,这个对象就变成了垃圾,Java的垃圾回收机制将回收该对象,释放该对象所占的内存。即切断引用变量和对象之间的关系,将引用变量赋值为null。

调用实例/方法

  1. 类.类变量|方法
  2. 实例.实例变量|方法

对象的this引用
this 关键字总是指向调用该方法的对象.

特别的,Java允许允许一个成员直接调用另一个成员,此时可以省略this前缀。一般来说,如果调用static修饰的成员时省略了主调(调用成员、方法的对象),默认使用该类作为主调;如果调用没有用static修饰的成员时省略了主调,默认使用this作为主调.

如果普通方法中有个局部变量和成员变量同名,程序又需要在该方法中访问被覆盖的成员变量,则必须使用this前缀。

方法

Java中方法不能独立存在,必须属于一个类或对象。

方法的参数传递机制
值传递:将实际参数值的副本传入方法内,参数本身不会受到任何影响。
特别注意:引用类型的参数传递仍然是值传递。

  1. class DataWrap
  2. {
  3. int a;
  4. int b;
  5. }
  6. public class ReferenceTransferTest
  7. {
  8. public static void swap(DataWrap dw)
  9. {
  10. // 下面三行代码实现dw的a、b两个成员变量的值交换。
  11. // 定义一个临时变量来保存dw对象的a成员变量的值
  12. int tmp = dw.a;
  13. // 把dw对象的b成员变量值赋给a成员变量
  14. dw.a = dw.b;
  15. // 把临时变量tmp的值赋给dw对象的b成员变量
  16. dw.b = tmp;
  17. System.out.println("swap方法里,a成员变量的值是"
  18. + dw.a + ";b成员变量的值是" + dw.b);
  19. // 把dw直接赋为null,让它不再指向任何有效地址。
  20. dw = null;
  21. }
  22. public static void main(String[] args)
  23. {
  24. DataWrap dw = new DataWrap();
  25. dw.a = 6;
  26. dw.b = 9;
  27. swap(dw);
  28. System.out.println("交换结束后,a成员变量的值是"
  29. + dw.a + ";b成员变量的值是" + dw.b);//9,6;9,6
  30. }
  31. }

上面的程序中dw仅仅是一个引用变量,在main栈区会创建dw引用变量,之后再swap栈区会创建其副本,完成对堆内存中的对象的引用。在swap方法中操作堆内存中的DataWrap对象,因此最后在main方法中dw引用的DataWrap成员变量的值交换了。

形参个数可变的方法
如果在定义方法时,在最后一个参数的类型后增加三点…,则表明该形参接受多个参数值,多个参数值被当成数组传入。长度可变的形参只能位于最后一个参数,并一个方法里只能有一个可变长度的参数。

  1. public class Varargs
  2. {
  3. // 定义了形参个数可变的方法
  4. public static void test(int a , String... books)
  5. {
  6. // books被当成数组处理
  7. for (String tmp : books)
  8. {
  9. System.out.println(tmp);
  10. }
  11. // 输出整数变量a的值
  12. System.out.println(a);
  13. }
  14. public static void main(String[] args)
  15. {
  16. // 调用test方法
  17. test(5 , "疯狂Java讲义" , "轻量级Java EE企业应用实战");
  18. }
  19. }

也可以使用数组形参来定义方法

  1. public static void test(int a , String[] books)

但是调用时必须传入数组:

  1. test(5 , new String[] {"疯狂Java讲义" , "轻量级Java EE企业应用实战"});

递归方法
递归就是在方法中再次调用自己。递归一定要向已知方向递归.

方法重载
Java 允许在一个类里定义多个同名方法,只要形参列表不同即可.

成员变量和局部变量

成员变量初始化
1. 当类被加载时,类成员就在内存中分配了一块空间,并指定默认值。
2. 当对象被创建时,实例成员就在内存中分配了内存空间,并指定初始值。
3. 为实例变量赋值。
实例变量与实例共存亡;类变量与类本身共存亡。

  1. Person p1 = new Person();
  2. Person p2 = new Person();
  3. // 为实例变量赋值
  4. p1.name = "张三";
  5. p2.name = "孙悟空";
  6. //为类变量赋值
  7. p1.eyeNum = 2;
  8. p2.eyeNum = 3;

局部变量的初始化
局部变量仅在方法内有效。它总是保存在所在方法的栈内存中。如果局部变量是基本类型的变量,直接把这个变量的值保存在该变量对应的内存中;如果是引用变量,则局部变量保存的是地址,通过该地址引用到该变量实际引用的对象或数组。栈内存中的变量无须系统垃圾回收,当方法执行完成时,局部变量便会自动销毁。

变量使用
局部变量的作用范围越小,它在内存中停留的时间就越短,程序运行性能就越好。

隐藏和封装

访问控制符

基本原则:

  1. 绝大部分成员变量应该使用private修饰,只有static修饰的、类似全局变量的成员变量才能使用public修饰。工具方法也应该使用private修饰。
  2. 父类的大部分方法可能仅希望被其子类重写,而不希望被外界直接调用,应该使用protected修饰。
  3. 希望暴露出来给其他类自由调用的方法应该使用public修饰。因此类的构造器通过使用public修饰,从而允许在其他地方创建该类的实例。

package
Java允许将一组功能相关的类放在一个package下。

包名应该全部是小写字母,可以使用公司域名倒写来作为包名。

  1. javac -d . Hello.java

以上是在当前路径下编译改文件,结果保存在当前路径新建的包文件夹中。-d用于设置编译生成class文件的保存位置。
切换到lee文件夹所在目录

  1. java lee.Hello

以上是执行时的命令。注意优先搜索CLASSPATH下的子路径,然后按照与包层次对应的目录结构查找class文件。

当需要导入两个包包含同一个名称的类时,不能使用import,需要使用类的全名

  1. java.sql.Date d = new java.sql.Date();

import 引入包格式。分为两种:
+ 非静态导入,导入的是包下所有的类。如:import package.subpackage.*;
+ 静态导入,导入的是类的静态属性。如:import static package.className.*;

java常用包

构造器

构造器是一个特殊的方法,用于在创建对象时执行初始化。注意:当系统执行构造器的执行体之前,系统已经创建了一个对象,只是这个对象还不能被外部程序访问。

构造器重载
构造器的重载和方法的重载一样,都是方法名相同,形参列表不相同。在构造器中可通过this来调用另外一个重载的构造器。

类的继承

Java的继承是单继承,每个子类最多只有一个直接父类。
子类继承父类的语法格式如下:修饰符 class subclass extends superclass {}
子类扩展了父类,将可以获得父类的全部属性和方法,但不能获得父类构造器.

重写父类方法
方法的重写要遵循“两同两小一大”,指的是:方法名相同,形参列表相同。返回值类型更小或相同,抛出的异常更小或相同,访问控制权限要更大。
如果父类方法是private的权限,子类无法重写该方法。

重载与重写?
重载是overload,重写是override。前者是同一个类的多个同名方法之间,后者是发生在子类与父类同名方法之间。当然父类与子类也可能发生重载:子类进程父类方法,并定义了一个与父类方法函数名相同,参数列表不同的方法。

super
通过关键字super来调用父类的被覆盖的实例方法或隐藏属性。没有被覆盖的属性可以直接调用。

调用父类构造器
子类构造器总会调用父类构造器。
如果子类构造器没有显式使用super调用父类构造器,子类构造器默认会调用父类无参数的构造器。
创建一个子类实例时,总会先调用最顶层父类的构造器。

多态

Java 引用变量有两个类型:一个是编译时的类型,一个是运行时的类型,编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给该变量的对象决定。如果编译时类型和运行时的类型不一致,这就有可能出现所谓的多态。
两个相同类型的引用变量,由于它们实际引用的对象的类型不同,当它们调用同名方式时,可能呈现出多种行为特征,这就是多态。

  1. class BaseClass
  2. {
  3. public int book = 6;
  4. public void base()
  5. {
  6. System.out.println("父类的普通方法");
  7. }
  8. public void test()
  9. {
  10. System.out.println("父类的被覆盖的方法");
  11. }
  12. }
  13. public class SubClass extends BaseClass
  14. {
  15. //重新定义一个book实例变量隐藏父类的book实例变量
  16. public String book = "轻量级Java EE企业应用实战";
  17. public void test()
  18. {
  19. System.out.println("子类的覆盖父类的方法");
  20. }
  21. public void sub()
  22. {
  23. System.out.println("子类的普通方法");
  24. }
  25. public static void main(String[] args)
  26. {
  27. // 下面编译时类型和运行时类型完全一样,因此不存在多态
  28. BaseClass bc = new BaseClass();
  29. // 输出 6
  30. System.out.println(bc.book);
  31. // 下面两次调用将执行BaseClass的方法
  32. bc.base();
  33. bc.test();
  34. // 下面编译时类型和运行时类型完全一样,因此不存在多态
  35. SubClass sc = new SubClass();
  36. // 输出"轻量级Java EE企业应用实战"
  37. System.out.println(sc.book);
  38. // 下面调用将执行从父类继承到的base()方法
  39. sc.base();
  40. // 下面调用将执行从当前类的test()方法
  41. sc.test();
  42. // 下面编译时类型和运行时类型不一样,多态发生
  43. BaseClass ploymophicBc = new SubClass();
  44. // 输出6 —— 表明访问的是父类对象的实例变量
  45. System.out.println(ploymophicBc.book);
  46. // 下面调用将执行从父类继承到的base()方法
  47. ploymophicBc.base();
  48. // 下面调用将执行从当前类的test()方法
  49. ploymophicBc.test();//子类覆盖的父类方法
  50. // 因为ploymophicBc的编译类型是BaseClass,
  51. // BaseClass类没有提供sub方法,所以下面代码编译时会出现错误。
  52. // ploymophicBc.sub();
  53. }
  54. }

第三个引用变量比较特殊,编译时类型是BaseClass,运行时类型是SubClass。当调用引用变量的Test方法时,实际执行的是SubClass中覆盖后的Test方法。
子类对象赋给父类引用变量,是向上转型,系统自动完成。当调用引用变量的方法时总是表现出子类方法的行为特征。而不是父类。对于子类中新的方法因为编译时为BaseClass就无法调用了,所以运行时无法调用。
实例变量不具备多态,输出BaseClass类的实例变量。官方的话:引用变量访问实例变量时,总是试图访问编译时类型所定义的成员变量。

引用变量的类型转换
强制类型转换: 类型转换运算符是小括号,语法如下(type)variable
注意:

instanceof
前一个操作通常是一个引用类型的变量,后一个操作通常是一个类(也可以是接口)。如果是返回true 否返回false。

  1. public class InstanceofTest
  2. {
  3. public static void main(String[] args)
  4. {
  5. // 声明hello时使用Object类,则hello的编译类型是Object,
  6. // Object是所有类的父类, 但hello变量的实际类型是String
  7. Object hello = "Hello";
  8. // String与Object类存在继承关系,可以进行instanceof运算。返回true。
  9. System.out.println("字符串是否是Object类的实例:"
  10. + (hello instanceof Object));
  11. System.out.println("字符串是否是String类的实例:"
  12. + (hello instanceof String)); // 返回true。
  13. // Math与Object类存在继承关系,可以进行instanceof运算。返回false。
  14. System.out.println("字符串是否是Math类的实例:"
  15. + (hello instanceof Math));
  16. // String实现了Comparable接口,所以返回true。
  17. System.out.println("字符串是否是Comparable接口的实例:"
  18. + (hello instanceof Comparable));
  19. String a = "Hello";
  20. // // String类与Math类没有继承关系,所以下面代码编译无法通过
  21. // System.out.println("字符串是否是Math类的实例:"
  22. // + (a instanceof Math));
  23. }
  24. }

初始化块

格式:[修饰符]{//可执行代码}
修饰符只能是static。static修饰的初始化块称为静态初始化块。
系统总是先调用初始化块,然后是构造器。初始化块只在创建Java对象时隐式执行。

初始化块是构造器的补充,是一段固定执行的代码,不能接受参数。实际上初始化块在使用javac命令编译类之后,初始化块会被还原到每个构造器中,且位于构造器所有代码的前面。

顺序:以此执行父类的初始化块、构造器、初始化块、构造器...

静态初始化块
静态初始化块将在类初始化阶段执行静态初始化块,比普通初始化块优先级更高。同样也需要上溯父类的静态初始化块。

  1. class Root
  2. {
  3. static{
  4. System.out.println("Root的静态初始化块");
  5. }
  6. {
  7. System.out.println("Root的普通初始化块");
  8. }
  9. public Root()
  10. {
  11. System.out.println("Root的无参数的构造器");
  12. }
  13. }
  14. class Mid extends Root
  15. {
  16. static{
  17. System.out.println("Mid的静态初始化块");
  18. }
  19. {
  20. System.out.println("Mid的普通初始化块");
  21. }
  22. public Mid()
  23. {
  24. System.out.println("Mid的无参数的构造器");
  25. }
  26. public Mid(String msg)
  27. {
  28. // 通过this调用同一类中重载的构造器
  29. this();
  30. System.out.println("Mid的带参数构造器,其参数值:"
  31. + msg);
  32. }
  33. }
  34. class Leaf extends Mid
  35. {
  36. static{
  37. System.out.println("Leaf的静态初始化块");
  38. }
  39. {
  40. System.out.println("Leaf的普通初始化块");
  41. }
  42. public Leaf()
  43. {
  44. // 通过super调用父类中有一个字符串参数的构造器
  45. super("疯狂Java讲义");
  46. System.out.println("执行Leaf的构造器");
  47. }
  48. }
  49. public class Test
  50. {
  51. public static void main(String[] args)
  52. {
  53. new Leaf();
  54. new Leaf();
  55. }
  56. }

静态初始化块与静态成员变量定义的执行顺序与源程序中排列顺序相同。

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注