Java-包与面向对象特性（封装，继承）

目录

一、Java中的包

包的作用：

创建包：

 总结：

静态导入：

二、面向对象三点特性：封装，继承，多态

【1】封装：

【2】继承

继承总结：

继承的内存分析：

---

一、Java中的包

包的作用：

1. 解决重名问题（实际上包对应的就是盘符的目录）
2. 解决权限问题

创建包：

     包名的定义规范：

1. 名字全部小写
2. 中间用"."隔开    
3. 一般都是公司域名倒着写:com.jd        
4. 加上模块名字:com.jd.login     
5. 不能使用系统中的关键字      

6. 包声明的位置一般都在非注释性代码的第一行：

package com.hhf.test07;
import com.hhf.test01.*;//导包：就是为了进行定位
import java.util.Date;


/**
 * @Author: Rick
 * @Description:
 * @Date: Crated in 0:33 2022/11/3
 * @Modified By:
 */
public class Student  {
    public static void main(String[] args) {
        new person();
        new Date();
        new java.sql.Date(1000l);//在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包
    }
}

 总结：

1. 使用不同包下的类需要导包：import **.*.*; 例如import java.util.Date;
2. 在导包以后，还想用其他包下同名的类，就必须要手动自己写所在的包。
3. 同一个包下的类想使用不需要导包，可以直接使用。
4. 在Java.lang包下的类，可以直接使用无需导包：

静态导入：

//静态导入：
import static java.lang.Math.*;
//导入java.lang下Math类中的所有静态的内容


/**
 * @Author: Rick
 * @Description:
 * @Date: Crated in 0:33 2022/11/3
 * @Modified By:
 */
public class Student {
    public static void main(String[] args) {
        System.out.println(Math.random());//输出一个随机数
        System.out.println(PI);//输出π
        System.out.println(round(5.6));
    }

}

二、面向对象三点特性：封装，继承，多态

【1】封装：

1.生活中的案例：ATM机（把钱封装起来），电线（把金属导线封装起来）

2.Java中封装的理解：将某些东西进行隐藏，然后提供相应的方式进行获取。

3.概念（网上概念，读起来嘛，比较官方，百度搜索Java中的封装即可得到）：

        封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。 适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。

4.我们程序设计追求“高内聚，低耦合”。

高内聚：类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅对外暴露少量的方法用于使用。

隐藏对象内部的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装的设计思想。

5.封装的好处：提高代码的安全性

6.代码演示：

Girl类代码：

package test.hhf.test01;

/**
 * @Author: Rick
 * @Description:
 * @Date: Crated in 15:04 2022/7/3
 * @Modified By:
 */
public class Girl {
    //属性
    private int age;

    //读取年龄
    public int readAge() {
        return age;
    }

    //设置年龄
    public void setAge(int age) {
        if (age>=30){
            this.age=18;
        }
        else {
            this.age = age;
        }
    }
}

测试类代码：

package test.msb.test01;

/**
 * @Author: Rick
 * @Description:
 * @Date: Crated in 15:08 2022/7/3
 * @Modified By:
 */
public class Test {
    public static void main(String[] args) {
        Girl g =new Girl();
//        g.age=18;
//        System.out.println(g.age);
        //设置年龄
        g.setAge(31);
        //读取年龄
        System.out.println(g.readAge());

    }
}

上面的代码，对于属性age来说，我加了修饰符private，这样外界对他的访问就受到了限制，现在我还想加上其他限制条件，但是在属性本身没有办法再加了，所以我们通过定义方法来限制条件的添加。

以属性为案例，进行封装：

1. 将属性私有化，被private修饰——》加入权限修饰符，一旦加入了权限修饰符，其他人就不可以随意地获取这个属性
2. 提供public修饰的方法让别人来访问/使用
3. 即使外界可以通过方法来访问属性了，但是也不能随意访问，因为我们在方法中可以加入限制条件。

生成封装快捷键：Alt+Insert，点击Getter and Setter 根据属性生成get和set方法

【2】继承

类是对对象的抽象

        eg：荣耀20，小米6，红米3，华为P40 Pro ---》类：手机类

继承是对类的抽象：

        eg：学生类：Student

                属性：姓名，年龄，身高，学生编号

                方法：吃饭，睡觉，喊叫，学习

                 教室类：Teacher

                属性：姓名，年龄，身高，教室编号

                方法：吃饭，睡觉，喊叫，教学

                员工类：Emploee

                属性：姓名，年龄，身高，员工编号

                方法：吃饭，睡觉，喊叫，工作

共通的东西：

人类：

属性：姓名，年龄，身高

方法：吃饭，睡觉，喊叫

 学生类/教师类/员工类 继承自 人类，以后定义代码

先定义人类：

人类：Human——》父类，基类，超类

属性：姓名，年龄，身高

方法吃饭，睡觉，喊叫

再定义子类，派生类

学生类：Studnet

属性：学生编号

方法：学习

教师类：Teacher

属性：教师编号

方法：教学

员工类：Emploee

属性：员工编号

方法：工作

子类继承父类

我们定义的继承关系，是在合理的范围中进行抽取，抽取出子类父类的关系，如，猫类，狗类，继承人类，就是不合理的，虽然猫猫和狗狗都有名字，年龄，身高，都会吃饭，睡觉。

代码层面的解释：先写父类，再写子类，代码演示

父类Person：

package test.hhf.test03;

/**
 * @Author: Rick
 * @Description:
 * @Date: Crated in 23:28 2022/7/3
 * @Modified By:
 */
public class Person {
    //属性
    private int age;
    private String name;
    private double height;

    //提供setter和getter方法

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }


    //方法
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("睡觉");
    }

}

学生类Student继承父类Person：

package test.hhf.test03;

/**
 * @Author: Rick
 * @Description:
 * @Date: Crated in 23:32 2022/7/3
 * @Modified By:
 */
public class Student extends Person {//子类Student 继承 父类Person
    //属性
    private int sno;

    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    //方法
    public void study(){
        System.out.println("李云龙：学习？学个屁呀");
    }
}

测试类：

package test.hhf.test03;

/**
 * @Author: Rick
 * @Description:
 * @Date: Crated in 23:38 2022/7/3
 * @Modified By:
 */
public class Test {
    public static void main(String[] args) {
        //创建子类Student的对象
        Student stu=new Student();
        stu.setSno(10086);
        stu.setAge(18);
        stu.setName("猪猪侠");
        stu.setHeight(163.5);

        System.out.println("英雄名字是"+stu.getName()+"年纪为"+stu.getAge());

        //访问方法
        stu.study();
        stu.eat();
        stu.sleep();
    }
}

继承的好处：提高代码的复用性

父类定义的内容，子类可以直接拿过来用就可以了，不用代码上重复定义了

需要注意的是，父类private修饰的内容，子类实际上也继承，只是因为封装的特性阻碍了直接调用，但是提供了间接调用的方式，可以间接调用。

---

继承总结：

1. 继承关系：父类/基类/超类，子类/派生类，子类继承父类一定是在合理的范围进行继承的
2. 继承的好处：父类定义的内容，子类可以直接拿过来用就可以了，不用代码上重复定义了；便于代码的扩展；为了以后多态的使用。是多态的前提。
3. 父类private修饰的内容，子类实际上也继承过来了
4. 一个父类可以有多个子类
5. 一个子类只能有一个直接父类，也就是说可以间接地继承其他类。
6. 继承具有传递性，如：Student类继承自Person类，Person类继承自Object类；Object类是所有类的根基父类（曾曾曾·······曾曾祖父）

继承的内存分析：