javaSE -面向对象编程（包，继承，组合，多态，抽象类，接口）

一、包（package）

1.1、包（package）是组织类的一种方式

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

比如说：打印数组

import java.util.Arrays;
public class TestDome {
   

    public static void main(String[] args) {
   
        int[] array = {
   1,2,3,4,5};
        System.out.println(Arrays.toString(array));
    }

}

一个包里面有很多个类
用类名 调用的方法就是static修饰的方法

1.2、什么是 package 和 import

package （包）
指：类所在的包

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

1.3、在java中不同的包可能会有同名的类

比如说：

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

1.4、import static - 静态导入

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

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

1.6、如何创建一个包

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

1.7、在包里面创建一个类

1.8、在另一个包里，导入同名的类

1.8、包的访问权限控制 - 只能在同一个包里面使用

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

1.9、常见的系统包

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编程开发包

二、继承 - extends

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

封装：不必要公开的数据成员和方法，使用private关键字进行修饰。意义：安全性。
继承：对共性的抽取。使用extends关键字进行处理的。 意义：可以对代码进行重复使用。

定义两个类，Dog和Bird

class Dog{
   
    public String name;
    public int age;
    
    public void eat(){
   
        System.out.println(name + "正在吃饭！");
    }
}

class Bird{
   
    public String name;
    public int age;

    public void eat(){
   
        System.out.println(name + "正在吃饭！");
    }
    public void Fly(){
   
        System.out.println(name + "正在飞翔！");
    }
}

这两个类分别表示狗和鸟，他们都有共同的属性，名字吗，年龄，吃饭
我们可以将这些共性抽取出来

class Animal{
   
    public String name;
    public int age;

    public void eat(){
   
        System.out.println(name + "正在吃饭！");
    }
}

class Dog extends Animal{
   
    
}

class Bird extends Animal{
   
    public void Fly(){
   
        System.out.println(name + "正在飞翔！");
    }
}

Dog和Bird都继承于Animal，Animal是动物，Dog和Bird都继承于Animal，说明Dog和Bird都具有名字吗，年龄，吃饭这些属性
这就是继承
如何访问Dog和Bird的属性和方法
和以前一样，通过对象的引用来调用

class Animal{
   
    public String name;
    public int age;

    public void eat(){
   
        System.out.println(name + "正在吃饭！");
    }
}

class Dog extends Animal{
   

}

class Bird extends Animal{
   
    public void Fly(){
   
        System.out.println(name + "正在飞翔！");
    }
}

public class TestDome {
   
    public static void main(String[] args) {
   
        Dog dog = new Dog();
        dog.name = "小狗";
        dog.age = 10;
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.eat();
        System.out.println("-----------------");
        Bird bird = new Bird();
        bird.name = "小鸟";
        bird.age = 10;
        System.out.println(bird.name);
        System.out.println(bird.age);
        bird.eat();
        bird.Fly();
    }
}

仔细分析, 我们发现 Animal 和 Dog以及 Bird 这几个类中存在一定的关联关系:

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

从逻辑上讲, Dog和 Bird 都是一种 Animal (is - a 语义).
狗是一种动物，鸟也是一种动物
此时我们就可以让 Dog和 Bird 分别继承 Animal 类, 来达到代码重用的效果.
此时, Animal 这样被继承的类, 我们称为 父类 , 基类 或 超类, 对于像 Dog和 Bird 这样的类, 我们称为 子类, 派生类
和现实中的儿子继承父亲的财产类似, 子类也会继承父类的字段和方法, 以达到代码重用的效果

2.1、语法规则

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

2.2、子类在进行构造的时候要先给父类进行构造（super的三种用法）

• super(); — 调用父类的构造方法，只能出现在构造方法里面，并且只能在第一行
• super.eat(); — 调用父类的普通方法
• super.属性；— 调用父类的属性
• super(); 不能出现在静态方法中，
  

2.3、在java中只能是单继承

2.4、protected 关键字

刚才我们发现, 如果把字段设为 private, 子类不能访问. 但是设成 public, 又违背了我们 “封装” 的初衷.
两全其美的办法就是 protected 关键字.

• 对于类的 子类 和 同一个包的其他类 来说, protected 修饰的字段和方法是可以访问的

2.5、小结: Java 中对于字段和方法共有四种访问权限

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

2.6、更复杂的继承关系

举个例子, 只涉及到 Animal, Cat 和 Bird 三种类. 但是如果情况更复杂一些呢?
针对 Cat 这种情况, 我们可能还需要表示更多种类的猫~

如刚才这样的继承方式称为多层继承, 即子类还可以进一步的再派生出新的子类.
时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂.
但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.
如果想从语法上进行限制继承, 就可以使用 final 关键字

2.7、 final 关键字

• 修饰一个变量或者字段的时候, 表示 常量 (不能修改)

• 

• final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.

• 

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

三、组合

组合和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果.

例如表示一个学校：

组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段.

这是我们设计类的一种常用方式之一.
组合表示 has - a 语义
在刚才的例子中, 我们可以理解成一个学校中 “包含” 若干学生和教师.
继承表示 is - a 语义
在上面的 “动物和猫” 的例子中, 我们可以理解成一只猫也 “是” 一种动物

四、多态

4.1、向上转型 - 父类引用引用子类对象

class Animal{
   
    String name;
    int age;
    protected int val;
    private int hight;
    public int getHight() {
   
        return hight;
    }
    public void setHight(int hight) {
   
        this.hight = hight;
    }