[Java知识库]ObjectOrientedProgramming - 面向对象的编程（包、继承、多态的一部分：向下/向下转型，重写） -Java

包

包 (package) 是组织类的一种方式.

包里存的基本上都是类，而这些类都是别人写好的。我们只需要拿着用。前提是导入对应的包

代码案例（打印数组）：

import java.util.Arrays;// 导入包util包中的 Arrays 类， 图 1
public class ObjectOrientedProgramming {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5};
        System.out.println(Arrays.toString(array));
        在输入 Arrays 的途中，编译器会给出提示，只要我们选择就能自动导入对应包中的类。
        // Arrays 是一个类，而toString 由类 来调用的，说明toString 是一个静态方法 (图2) 
        // 也就是说所有通过类调用的方法都是 静态的
    }
}

附图（缺少的那句代码，作用就是导入一个包。从包中拿出你需要的类）

图1

图2

?

经由上面一个简单的程序附图2，引申出一格问题： 什么是 package 和 import？

   package （包）
   指：类所在的包
   
   import （引入包中的类）
   引入在类中需要的类（我们写的程序就是一个类，import 的作用就是 在我们写程序的时候， 引入我们所需要的类）

?

在java里，包肯定不止一个，那么就意味着 一个 类，可能有在不同包里都有它，只不过实现的功能不同。选择对应包中的类，编译器会自动帮你导入所需包中的类

例1

例2

?

既然知道包是怎么导入它当中的类，那么该如何使用？ new它！

实例1（导入(包中的类)情况）

?

实例2（不导入（包中的类）情况）

?

前者都是导入包中的类，在程序中就可以使用该类。那我们只导入包呢？在程序中我们还可以使用它里面的类吗？

由结果得知： 不能，在Java中 只能导入一个具体的类，不能带入一个具体的包。

?

我们再来看看 用特殊的方法 导入一个类

  import java.util.*; //  * 在该代码中 表达的意识是 通配符。
  这么写是什么意思？
  导入这个包里所有类。
   

示例

?

疑问：util包中 有很多类，难道 “ impor java.util.*; ” 是一下子全部 都导入吗？

    不是的，Java 处理的时候，需要哪个类，它才会给你那个类。
    就是说：Java不会提前给你任何类，当你需要某个类的时候，再给你。而且是要一个，给一个。
       不会说要一个，给你一大堆。

   这也是 Java 和 C 的区别之一。
   假设 include<stdio.h>
   C  通过 include 关键字，将 stdio.h 头文件里面的内容全部都拿过来，导入程序。
   这就好比  古时 朝廷 发赈灾款 给 某位大臣，这批钱，你怎么用都行。
   而不是 先排大臣过去，碰到一项需要开支的地方，再向朝廷申请 合适的 拨款数目
   
   如果你要问：Java 和 C 那个导入方式好，肯定是java。因为 Java 是用一个，给一个，用不到的，绝对不会给你。省空间。
   不像C一样，一股脑的全给你，管你用不用，这样就会造成空间的浪费，

?

那么 “ impor java.util.*; ” 和 “ impor java.util.具体的类名; ” ，那个更好？

       impor java.util.具体的类名;   更好！

拿 前面 例子中 Date 举例，

由图我们发现 Date这个类， 在很多包中 都有。如果我们 同时使用两个包中的Date，且使用 通配符的导入模式。会怎么样？
?

import static - 静态导入

  使用 import static 可以导入包中的 静态的 方法 和 字段
  方法：
  import static java.lang.具体的类.*;

实例

但是这种方法用的不多，虽然代码简单，但是阅读性不高。不建议这么写。（了解）

?

使用包的主要目的是保证类的唯一性

但是 如果一个项目很大，有50多人参与这个项目，有可能会出现 类名相同的情况。
此时包的作用就体现出来了。

?

在此之前，我们先来看包是如何创建的（包名 必须小写）

把类放进包里

  方法：
    和我们平常在src目录下，新建clas文件（类）一样，直接反键new就行了。

?

使用我们自己创建的包中的类

?

包的访问权限控制

 我们已经了解了类中的 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编程开发包。

?

面向对象的基本特征：

封装：不必要公开的数据成员和方法，使用private关键字进行修饰。意义：安全性。

继承：对共性的抽取。使用extends关键字进行处理的。 意义：可以对代码进行重复使用。

先来通过代码了解一些知识点，为了我们了解继承做铺垫

?

讲这些共有的特性抽离出来

?

继承的语法规则

基本语法

class 子类 extends 父类 { 
 
} 

总结

使用 extends 指定父类.
子类会继承父类的所有 public 的字段和方法.
Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).

对于父类的 private 的字段和方法, 子类中是无法访问的.

子类构造的同时，要 先 帮助父类来进行构造

super关键字的用法，this的用法可以看这篇文章 类与对象

·子类继承父类，子类在内存中的情况

特殊情况 ( 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用 )

相当于 上图 wing，是鸟类自带的属性。不会被父类的构造方法的初始化所影响。

?

protected 关键字

  刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 "封装" 的初衷.  
 两全其美的办法就是 protected 关键字.
     对于类的调用者来说, protected 修饰的字段和方法是不能访问的
    对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的

?

访问权限图（ private | default | protected | public）

private: 类内部能访问, 类外部不能访问
默认(也叫包访问权限): 类内部能访问, 同一个包中的类可以访问, 其他类不能访问.
protected: 类内部能访问, 子类和同一个包中的类可以访问, 其他类不能访问.
public : 类内部和类的调用者都能访问

?

同一个包中的同一个类

同一个包中的不同类

不同包的子类（类的继承需要两个类都是public的类）

?

不同包的非子类

上面这些情况中，调用的成员变量都是有public修饰的，也就是说 只要我们 字段/属性/成员变量是被public 所修饰的，就意味着在哪里都能使用。

?

我们主要还是讲 protected，因为其他的，在前面都讲了。

同一个包中的同一个类

同一个包中的不同类

不同包的子类（前面protected 和 public几乎一样，但下面两点就是public 和 protected 的区别）

不同包的非子类

?

总结

   protected 的出现为了防止继承的时候，非子类也能调用父类当中成员变量和方法，
   让父类数据，不会被随意调用，造成不可预料的效果。（就好比我举的例子，狗和鸟，狗不会飞，但是你让狗去继承鸟的翅膀，可能吗？）       
   
   protected 还有一个，一个好处： 即使不同类不同包，只要是子类，就可以去调用父类的数据

 时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一
 系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂.
  但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了       .
   如果一个类不想被继承, 就可以使用 final 关键字.对其进行修饰

?

final 关键字

   曾经我们学习过 final 关键字, 修饰一个变量或者字段的时候, 表示 常量 (不能修改)
   现在拓展一下：
   final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.

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

?

组合

  和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果
  你可以理解为 a part of 一部分
  例如：
  学生 和 老师 是 学校的一部分

  组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段.    
  这是我们设计类的一种常用方式之一.

  组合表示 has - a 语义 ： the school  hava  students and teachers。
 在刚才的例子中, 我们可以理解成一个学校中 "包含" 若干学生和教师.   
 继承表示 is - a 语义 ： dog is animal
  在上面的 "动物和猫" 的例子中, 我们可以理解成一只猫也 "是" 一种动物

?

多态 - 这里 只是铺垫，开个头，讲一个部分。

 字面上理解： 语文层次： 一种食物多种形态。 但是这句话不要跟面试官，直接gg，这里只是 让你对多态先有个初步了解。

?

向上转型：

   子类对象 给 父类 的 引用

什么情况下会发生向上转型？

1. 直接赋值

?

2. 函数的参数

?

3.作为函数的返回值

?

动态绑定（多态的基础）

当子类和父类中出现同名方法的时候, 再去调用会出现什么情况呢?

?

动态绑定的条件：

1.父类 引用 子类的对象
2.通过父类这个引用 调用 父类 和 子类 同名的覆盖（重写） 方法

?

重写 /覆盖 / 覆写

1.方法名相同
2. 参数的 个数 和 类型 相同
3. 最好返回值相同（协变类型：返回值可以不同。返回值的关系为父子类关系）
4. 父子类的关系

代码1

?

代码2 (动态绑定)

?

再来通过以下图片 来进一步了解 多态绑定

?

重写的注意事项

方法不可以是 static 方法

子类的访问修饰限定的访问范围一定要大于等于 父类 的 访问修饰限定

         重写中子类的方法的访问权限 不能低于 父类的方法访问权限

private 方法 不能被重写

方法 被 final修饰 ，也不能被重写

方法的返回值不一样，也能被重写（ 协变类型 ）

特殊情况

?

重写 与 重载的区别

重载可 通过这篇文章进行参考方法的使用

1.方法名相同
2. 参数的 个数 和 类型 必须有一个不同（重写：参数的类型和个数都相同）
3. 返回值可以不同 （重写：协变类型可以返回值不同，一般情况返回值是一样）
4. 重载涉及静态绑定（重写：动态绑定）

?

编译时多态：利用重载来实现多态，在同一个类中定语多个同名的不同方法来实现多态

?

向下转型

    向上转型： 父类引用 引用 子类对象
    那么向下转型：子类引用  引用 父类对象
    你可以这么去理解：父类 引用子类对象，子类b格提升。称为向上转型
     子类 引用 父类 ，父类b格降级，称为向下转型

但是不建议大家去写 向下转型！

处理方法

再介绍一个坑（在构造方法中调用重写的方法）

本文结束