【面向对象编程——封装、继承】

一、包

包是组织类的一种方式
目的：为了保证类的唯一性，解决类同名的问题

1.导入包中的类

用import关键字导入包中的某一具体的类

java.util.Date data = new java.util.Data();
//得到一个毫秒级别的时间戳

意为导入java.util这个包中的Data类，但是比较麻烦
我们可以使用import关键字导入包中的类

import java.util.Data;
public class Test{
  public static void main (String[] args) {
     Data data = new Data();  
  }
}

如果需要用到java.util中其他的类，可以使用import java.util.*
但是建议制定要导入的类名，否则还是容易出现冲突的情况

import java.util.*
import java.sql.*
//util和sql中都存在Data这个类，会出现歧义，编译出错
//这时候我们就需要使用完整的类名
public class Test{
  public static void main (String[] args) {
     java.util.Date data = new java.util.Data();  
  }
}

2.静态导入

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

import static java.lang.System.*;
//导入了lang包中的System方法
public class Test{
  public static void main (String[] args) {
     out.println("hello!")  
  }
}

这样可以更方便写一些代码，但不推荐，原本的代码已经很方便了，使用静态导入不方便其他人看代码

3.包的访问权限控制

private中的成员只能被类的内部使用。
如果某个成员不包含public和private关键字，此时这个成员可以在包内部的其他类使用，但是不能在包外的类使用

4.常见的系统包

1. java.lang：系统常用基础类（String、Object），此包从JDK1.1之后自动导入
2. java.lang.reflect：java反射编程包
3. java.nat：进行网络编程开发包
4. java.sql：进行数据库开发的支持包
5. java.util：是java提供的工具开发包
6. java.io：I/O编程开发包

二、封装

封装是面向对象方法的重要原则，就是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。

什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让代码更容易理解和维护，也加强了代码的安全性。

1.private：类的内部能访问，类外部不能访问
2.default（也叫包访问权限）：类内部能访问，同一个包中的类可以访问，其他类不能访问。
3.protected：类的内部能访问，子类和同一个包中的类可以访问，其他类不能访问。
4.public：类的内部和类的调用者都能访问

权限范围
private < default < protected < public

什么时候用那种关键字进行封装呢？
封装，即隐藏内部实现细节，只暴露出必要信息给类的调用者。

因此我们在使用的时候应该尽可能的使用较为严格的访问权限，例如一个方法能用private，就尽量不要用public。

另外还有一种简单粗暴的方法：将所有字段设为private，将所有方法设为public。不过这种方式属于对访问权限的滥用。
还是希望大家在写代码的时候认真思考，该类提供的字段是给“谁”使用（是类的内部自己用，还是类的调用者使用，还是子类使用）。

三、继承

继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

例：设计一个Animal类

package com.rocket_class.Inherit;

public class Animal {
    public String name;
    public Animal(String name){
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name + "正在吃"+ food);
    }

package com.rocket_class.Inherit;

public class Bird {
    public String name;
    public Bird(String name){
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name + "正在吃"+ food);
    }

package com.rocket_class.Inherit;

public class Cat {
    public String name;
    public Cat(String name){
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name + "正在吃"+ food);
    }

我们发现代码中存在的大量代码冗余
这三个类都有一个相同的eat方法和一个name属性，而且行为和意义是完全一样的，从逻辑上cat和bird都是一种animal（is—a语义）。
此时我们可以让cat和bird继承animal类，来达到代码的重用效果。

继承的语法规则
class 子类 extends 父类{
}

package com.rocket_class.Inherit;

public class Animal {
    public String name;
    public Animal(String name){
        this.name = name;
    }
    public void eat(String food){
        System.out.println(this.name + "正在吃"+ food);
    }
}

package com.rocket_class.Inherit;

public class Bird extends Animal{

    public Bird(String name) {
        super(name);
    }
    public void fly(){
        System.out.println(this.name+"正在飞");
    }
}

package com.rocket_class.Inherit;

public class Cat extends Animal {

    public Cat(String name) {
        //使用super 调用父类的构造方法
        super(name);
    }

}

package com.rocket_class.Inherit;

public class text {
    public static void main(String[] args) {
        Cat cat = new Cat("咪咪");
        cat.eat("猫粮");
        Bird bird = new Bird("叽叽");
        bird.fly();
    }
}

运行结果：
咪咪正在吃猫粮
叽叽正在飞

继承的规则
1.要能使用继承必须满足（子类）is a （父类）的语义关系
2.一个子类只能使用extends继承一个父类。
3.子类会继承父类的所有属性和方法，显示继承（public属性和方法可以直接使用）。隐式继承（private属性和方法）子类其实也继承了这个属性和方法，但是无法直接使用，必须通过父类提供的方法来操作
例：private int age；
必须使用public int getAge(){} 和public void setAge（int age）{}方法来使用age 属性

我们可以发现继承不支持多继承