JAVA面向对象（三）

第三章  封装与继承

目录

第三章  封装与继承

1.1.封装

1.2.包

1.3.访问权限控制

1.4.static修饰符

1.4.1.成员变量

1.4.2.成员方法

1.4.3.代码块

2.1.继承

总结

---

内容仅供学习交流，如有问题请留言或私信！！！！！

有空您就点点赞

---

1.1.封装

封装是什么？

        将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，是面向对象三大特征之一。

        封装的原则：把所有的属性藏起来；把尽可能多的东西藏起来，对外提供便捷的接口（简单记忆：隐藏细节，开放接口）。

如何实现封装：

 封装的好处：

• 便于使用者正确使用系统，防止错误修改属性
• 有助于系统之间的松耦合（软件设计原理：高内聚，低耦合），提高系统独立性
• 提高软件的可重用性
• 降低了构建大型系统的风险

---

1.2.包

        包：允许类组成较小的单元（类似文件夹），易于找到和使用相应的文件。

        作用：防止命名冲突，区分名字相同的类；有助于实施访问控制权限

命名规范：

• 包名由小写字母组成，不能以原点开头或结尾
  • package mypackage
• 包名之前最好加上唯一的前缀，通常使用组织倒置的网络域名
  • package net.javagroup.mypackage;
• 包名后续部分依不同机构内部的规范不同而不同
  • package net.javagroup.research.powerproject;

包导入语句：为了使用不在同一包中的类，需要在java程序中使用import关键字导入这个类。

语法：        

import 包名.类名;

eg:

import java.util.Scanner;//导入java.util包中的Scanner类

import java.util.*;//导入java.util包中的所有类

注意事项：

1.  一个类同时引用了两个来自不同包的同名类

   1. 必须通过完整类名来区分

   eg：已创建两个dog类

           import cn.com.Dog

           import cn.com.oop.Dog

   在main函数中调用时，只能通过类的完整限定名来区分

           cn.com.Dog dog1 = new cn.com.Dog();

           cn.com.oop.Dog dog2 = new cn.com.oop.Dog();

2. 每个包都是独立的，顶层包不会包含子包的类
3. package和import的顺序是固定的
   1. package必须位于（代码的）第一行
   2. 只允许有一个package语句
   3. 其次是import
   4. 接着是类的声明

---

1.3.访问权限控制

• 类的访问控制
  • public修饰符：公有访问级别
  • 默认修饰符：包级私有访问级别（本包内可以访问，不同包内无法访问）
• 类成员的访问控制

作用域 修饰符	同一个类中	同一个包中	子类中	任何地方
private	可以	不可以	不可以	不可以
默认修饰符	可以	可以	不可以	不可以
protected	可以	可以	可以	不可以
public	可以	可以	可以	可以

        protected：被proctected关键字修饰的成员也自然是“被保护”的，其只对本包及其子类可见。

• 父类的proctected成员包内可见，并且对子类可见。
• 子类父类不在同一个包里的话子类只能访问从父类继承的proctected方法。
• 子类不能访问被其他子类继承的proctected方法。

          protected：

• 可以修饰属性和方法
• 本类、同包、子类可以访问

super和this

区别	this	super
访问属性	访问本类属性 如果没有则从父类找	访问父类中的属性
访问方法	访问本类访问 如果没有则从父类找	访问父类中的方法
访问构造	访问本类构造 放在构造方法首行	调用父类构造，放在

---

1.4.static修饰符

static可以用来修饰：

• 1.4.1.成员变量

  • 静态变量，可以直接通过类名访问

---

类的成员变量包括：

• 类变量（静态变量）：
  • 被static修饰的变量
  • 在内存中只有一个拷贝
  • 类内部，可以在任何方法内直接访问静态变量
  • 其它类中，可以直接通过类名访问
• 实例变量
  • 没有被static修饰的变量
  • 每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响
  • 通过访问

 static变量的作用：

（1）能被类的所有实例共享，可作为实例之间进行交流的共享数据

（2）如果类的所有实例都包含一个相同的常量属性，可把这个属性定义为静态常量类型，从而节省内存空间

---

• 1.4.2.成员方法

  • 静态方法，可以直接通过类名访问

---

static方法：

• 静态方法：可以直接通过类名访问
  • 静态方法中不能使用this和super
  • 不能直接访问所属类的实例变量和实例方法
  • 可直接访问类的静态变量和静态方法
• 实例方法：通过实例访问
  • 可以直接访问所属类的静态变量、静态方法、实例变量和实例方法；不可以定义static变量
• 静态方法必须被实现
  • main（）就是最常用的的静态方法

---

• 1.4.3.代码块

  • 静态代码块，当Java虚拟机加载类时，就会执行该代码块

---

        static代码块：

• JVM加载类时，加载静态代码块
  • 如果有多个静态块，按顺序加载
  • 每个静态代码块只会被执行一次

---

2.1.继承

        使用继承修改后的好处：方便修改代码、减少代码量。

如何使用继承：

• 使用继承
  • 编写父类

    [访问修饰符] class Pet {

        //公共的属性和方法

    }

  • 编写子类，继承父类

    [访问修饰符] class Dog extends Pet {

        //子类特有的属性和方法

    }

        Java中只支持单根继承，即一个类中只能有一个直接父类。

• 子类访问父类成员：
  • 访问父类构造方法

    super();

    super(name);

  • 访问父类属性

    super.name;

  • 访问父类方法

    super.print();

使用super关键字来访问（调用）父类的成员时：

1. 使用super关键字，super代表父类对象。
2. 在子类构造方法中调用并且必须是第一句。
3. 不能访问父类中定义为private的属性，即私有属性。

   使用super.属性  ||  super.方法()

---

继承条件下的构造方法

        继承条件下构造方法的调用规则：

• 子类构造方法没有通过super显式调用父类的有参构造方法，也没通过this显式调用自身其他构造方法。
  • 系统默认调用父类的无参构造方法
• 子类构造方法通过super显式调用父类的有参构造方法。
  • 执行父类相应构造方法，而不执行父类无参构造方法
• 子类构造方法通过this显式调用自身的其他构造方法，在相应构造方法中应用以上两条规则。

---

子类继承父类：

• 继承public和protected 修饰的属性和方法，不管子类和父类是否在同一个包里。
• 继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里。

子类不能继承父类的成员：

• private成员
• 子类与父类不在同包，使用默认访问权限的成员
• 构造方法

---

继承例题：

输出结果是什么？

class Car {

    private int site = 4;  //座位数

    Car(){

        System.out.println ("载客量是"+site+"人");

    }

    public void setSite(int site){

        this.site = site;

    }

    void print(){

        System.out.print("载客量是"+site+"人");

    }

}

class Bus extends Car {

    Bus(int site){

        setSite(site);

    }

}

public static void main(String[] args) {

    Bus bus = new Bus(20);

    bus.print();

}

运行结果：载客量是4人，载客量是20人。

解析：系统调用时，先调用无参构造函数即红色部分，后执行相应的内容后，进行调用蓝色部分。

---

总结

        练习：------------------练习点这里------------------