面向对象编程

包

• 包 (package)

是组织类的一种方式.
使用包的主要目的是保证类的唯一性.

• 静态导入

使用 import static 可以导入包中的静态的方法和字段.

import static java.lang.System.*;
public class Test {
    public static void main(String[] args) {
        out.println("hello");
   }

使用这种方式可以更方便的写一些代码, 例如

import static java.lang.Math.*;
public class Test {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;
        // 静态导入的方式写起来更方便一些. 
        // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
        double result = sqrt(pow(x, 2) + pow(y, 2));
        System.out.println(result);
   }
}

• 将类放到包中
  基本规则
  1.在文件的最上方加上一个 package 语句指定该代码在哪个包中.
  2.包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
  3.包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
  4.如果一个类没有 package 语句, 则该类被放到一个默认包中.
  操作步骤：
  

• 包的访问权限控制
  我们已经了解了类中的 public 和 private. private 中的成员只能被类的内部使用.
  如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用.

• 常见的系统包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包。

继承

背景：代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).
有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.

例如：Animal，Bird，Cat
这三个类都具备一个相同的 eat 方法, 而且行为是完全一样的.
这三个类都具备一个相同的 name 属性, 而且意义是完全一样的.
从逻辑上讲, Cat 和 Bird 都是一种 Animal (is - a 语义).

此时我们就可以让 Cat 和 Bird 分别继承 Animal 类, 来达到代码重用的效果.
Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类
对于像 Cat 和 Bird 这样的类, 我们称为 子类, 派生类
和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果

• 语法规则

基本语法

class 子类 extends 父类 { 
 
} 

使用 extends 指定父类.
Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).
子类会继承父类的所有 public 的字段和方法.
对于父类的 private 的字段和方法, 子类中是无法访问的.
子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用

extends 英文原意指 “扩展”. 而我们所写的类的继承, 也可以理解成基于父类进行代码上的 “扩展”. 例如我们写的 Bird 类,就是在 Animal 的基础上扩展出了 fly 方法

• protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 “封装” 的初衷.
两全其美的办法就是 protected 关键字.
对于类的调用者来说, protected 修饰的字段和方法是不能访问的
对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的
小结: Java 中对于字段和方法共有四种访问权限
private: 类内部能访问, 类外部不能访问
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
public : 类内部和类的调用者都能访问

• 什么时候下用哪一种呢?

我们希望类要尽量做到 “封装”, 即隐藏内部实现细节, 只暴露出 必要 的信息给类的调用者.因此我们在使用的时候应该尽可能的使用 比较严格 的访问权限. 例如如果一个方法能用 private, 就尽量不要用public.
另外, 还有一种 简单粗暴 的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用, 还是更希望同学们能写代码的时候认真思考, 该类提供的字段方法到底给 “谁” 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用)
多层继承
即子类还可以进一步的再派生出新的子类
我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.
如果想从语法上进行限制继承, 就可以使用

• final 关键字
• 曾经我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示 常量 (不能修改).

final int a = 10; 
a = 20; // 编译出错
final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.

final 关键字的功能是 限制 类被继承
“限制” 这件事情意味着 “不灵活”. 在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.
是用 final 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的.

我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承

组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果
组合表示 has - a 语义
在刚才的例子中, 我们可以理解成一个学校中 “包含” 若干学生和教师.
继承表示 is - a 语义
在上面的 “动物和猫” 的例子中, 我们可以理解成一只猫也 “是” 一种动物

多态

• 向上转型
  父类引用子类对象，把子类的方法赋父类

animal=cat；
animal.cat（）；

若发生，则父类只能调用自己的方法

向上转型发生的时机：
1.直接赋值
2.方法传参
3.方法返回

• 动态绑定
  在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为动态绑定
• 方法重写
  子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为 覆写/重写/覆盖(Override).
  
  
• 多态
  多态可以理解成是封装的更进一步, 让类调用者对类的使用成本进一步降低.

封装是让类的调用者不需要知道类的实现细节.

使用多态的好处：

1. 类调用者对类的使用成本进一步降低
2. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
3. 可扩展能力更强

• 向下转型
  向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象
  向下转型之前必须发生向上转型
• super 表示获取到父类实例的引用

抽象类

最大存在意义：被继承

• 语法规则
  1.包含抽象方法的类叫做抽象类
  2.抽象类不能被实例化new##
  3.抽象类当中可以有抽象方法也可以有非抽象方法或者成员变量
  4.抽象类就是为了继承的
  5.抽象类被继承之后，一定要重写抽象方法
  6.抽象类A如果继承了抽象类B,那么A可以选择重写或者不重写B中的方法
  抽象方法不能是私有的private
  抽象类只要被继承就要一定被继承

接口

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量.

• 使用 interface 定义一个接口
• 接口中的方法一定是抽象方法, 因此可以省略 abstract
• 接口中的方法一定是 public, 因此可以省略 public
• Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
• 在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
• 接口不能单独被实例化

扩展(extends) vs 实现(implements)
扩展指的是当前已经有一定的功能了, 进一步扩充功能.
实现指的是当前啥都没有, 需要从头构造出来.

接口中只能包含抽象方法. 对于字段来说接口中只能包含静态常量(final static).

1. 我们创建接口的时候, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性
   抽象类和接口都是 Java 中多态的常见使用方式.
   核心 区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.