[关闭]
@nextleaf 2018-08-03T13:06:44.000000Z 字数 2806 阅读 758

2018-8-3 工作日志

Java 递归


例(阶乘):

  1. import cn.hutool.core.lang.Console;
  2. public class RecursiveAlgorithm {
  3. public static void main(String[] args){
  4. long l=factorial(3);
  5. Console.log(l);
  6. }
  7. //使用递归实现阶乘运算
  8. public static long factorial(int n){
  9. if (n ==1){
  10. return 1;
  11. }else {
  12. return n*factorial(n-1);
  13. }
  14. }
  15. }

Java面向对象

Java继承(extends 和 implements)

继承的特性

  • 子类拥有父类非private属性,方法;不能继承父类构造方法。
  • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
  • 子类可以用自己的方式实现父类的方法(重写)。
  • Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。
    注:使用extends关键字只能继承一个类,使用implements关键字可以同时继承多个接口(接口跟接口之间采用逗号分隔)
  • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。

super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
this关键字:指向自己的引用。
final 关键字:声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写.

注:

被声明为 final 类的方法自动地声明为final,但是实例变量并不是final
实例变量也可以被定义为 final,被定义为 final 的变量不能被修改。

构造方法

如果父类的构造器带有参数,则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表

构造顺序

  1. 先执行内部静态对象(类变量)的构造方法
  2. 再调用父类的构造方法(父类还有父类的话,从最开始的基类开始调用)
  3. 按声明顺序将成员对象初始化
  4. 最后调用自身的构造方法

重写(Override)

子类对父类的允许访问的方法的实现过程进行重新编写, 返回值形参都不能改变.
重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常

方法的重写规则

重载(Overload)

重载(overloading) 是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。
每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

重载规则:

  • 被重载的方法必须改变参数列表(参数个数或类型不一样)
  • 被重载的方法可以改变返回类型;
  • 被重载的方法可以改变访问修饰符;
  • 被重载的方法可以声明新的或更广的检查异常;
  • 方法能够在同一个类中或者在一个子类中被重载。
  • 无法以返回值类型作为重载函数的区分标准。

重写与重载之间的区别

区别点 重载方法 重写方法
参数列表 必须修改 一定不能修改
返回类型 可以修改 一定不能修改
异常 可以修改 可以减少或删除,一定不能抛出新的或者更广的异常
访问 可以修改 一定不能做更严格的限制(可以降低限制)

总结:
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载可以理解成多态的具体表现形式。(方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。)

重写与重载之间的区别

Java 多态

多态是同一个行为具有多个不同表现形式或形态的能力。
多态就是同一个接口,使用不同的实例而执行不同操作,如图所示:
多态

多态的优点

  1. 消除类型之间的耦合关系
  2. 可替换性
  3. 可扩充性
  4. 接口性
  5. 灵活性
  6. 简化性

多态存在的三个必要条件

  • 继承
  • 重写
  • 父类引用指向子类对象

比如:

  1. Parent p = new Child();//向上转型

当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

多态的好处:可以使程序有良好的扩展,并可以对所有类的对象进行通用处理。

  1. public class PolymorphicTest {
  2. public static void main(String[] args) {
  3. // 以 Cat 对象调用 show 方法
  4. show(new Cats());
  5. // 以 Dog 对象调用 show 方法
  6. show(new Dogs());
  7. Animals a = new Cats();// 向上转型,多态的用法
  8. a.eat(); // 调用的是 Cats 的 eat
  9. Cats c = (Cats)a; // 向下转型
  10. c.work(); // 调用的是 Cats 的 work
  11. }
  12. public static void show(Animals a) {
  13. a.eat();
  14. // 类型判断
  15. if (a instanceof Cats) { // 猫做的事情
  16. Cats c = (Cats)a;
  17. c.work();
  18. } else if (a instanceof Dogs) { // 狗做的事情
  19. Dogs c = (Dogs)a;
  20. c.work();
  21. }
  22. }
  23. }
  24. abstract class Animals {
  25. abstract void eat();
  26. }
  27. class Cats extends Animals {
  28. public Cats() {
  29. System.out.print("喵");
  30. }
  31. @Override
  32. public void eat() {
  33. System.out.println("吃鱼");
  34. }
  35. public void work() {
  36. System.out.println("抓老鼠");
  37. }
  38. }
  39. class Dogs extends Animals {
  40. public Dogs() {
  41. System.out.print("汪");
  42. }
  43. @Override
  44. public void eat() {
  45. System.out.println("吃骨头");
  46. }
  47. public void work() {
  48. System.out.println("看家");
  49. }
  50. }
添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注