Java基础知识(四) -- 面向对象(中)

1.包

1.3.1 包的作用

• （1）可以避免类重名：有了包之后，类的全名称就变为：包.类名【便于使用】
• （2）分类组织管理众多的类【便于管理类】
• （3）可以控制某些类型或成员的可见范围【控制访问范围】

Java中常见的包:

包名	作用
java.lang	Java语言的核心类，如String、Math、Integer、 System和Thread等，提供常用功能
java.net	执行与网络相关的操作的类和接口
java.io	提供多种输入/输出功能的类
java.util	实用工具类，如集合框架类、日期时间、数组工具类Arrays，文本扫描仪Scanner，随机值产生工具Random
java.text	Java格式化相关的类

包的本质就是创建不同的文件夹/目录来保存类文件

1.3.2 如何声明包?

package 包名;

注意：

(1)必须在源文件的代码首行

(2)一个源文件只能有一个声明包的语句

包名命名规范与习惯:

• 1. 所有单词都小写，每一个单词之间使用.分割
• 2. 习惯用公司的域名倒置

1.3.3 如何跨包使用类?

前提：被使用的类或成员的权限修饰符是>缺省的，即可见的。

• 1. 使用类型的全名称

  java.util.Scanner input = new java.util.Scanner(System.in);
  

• 2. 使用import 语句之后，代码中使用简名称

  import 包.类名;
  import 包.*;
  import static 包.类名.静态成员;
  

2.访问修饰符

2.1 概述

  Java 提供四种访问控制修饰符号，用于控制方法和属性(成员变量)的访问权限（范围）:

1. 公开级别:用 public 修饰,对外公开

2. 受保护级别:用 protected 修饰,对子类和同一个包中的类公开

3. 默认级别:没有修饰符号,向同一个包的类公开.

4. 私有级别:用 private 修饰,只有类本身可以访问,不对外公开.

2.2 访问修饰符的访问范围

访问级别	访问修饰控制符	同类	同包	子类	不同包
公开	public	√	√	√	√
受保护	protected	√	√	√	×
默认	没有修饰符	√	√	×	×
私有	private	√	×	×	×

## 3.面向对象编程-封装

3.1 概述

  面向对象编程语言是对客观世界的模拟，客观世界里每一个事物的内部信息都是隐藏在对象内部的，外界无法直接操作和修改，只能通过指定的方式进行访问和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。正如现实生活中，每一个个体与个体之间是有边界的，每一个团体与团体之间是有边界的，而同一个个体、团体内部的信息是互通的，只是对外有所隐瞒。

  随着业务系统越来越复杂，类会越来越多，那么类之间的访问边界必须把握好，面向对象的开发原则要遵循“高内聚、低耦合”，而“高内聚，低耦合”的体现之一：

• 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
• 低耦合：仅对外暴露少量的方法用于使用

  隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的讲，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

Q:封装就是把该隐藏的隐藏起来，该暴露的暴露出来。那么暴露的程度如何控制呢？

A: 依赖访问控制修饰符，也称为权限修饰符来控制。访问控制修饰符来控制相应的可见边界，边界有如下：类、包、子类、模块(Java9之后引入)。权限修饰符：public,protected,缺省,private。

3.2 封装的实现

• 1. 将属性私有化private
• 2. 提供一个公共的(public)set方法, 用于对属性判断并赋值

  public void setXxx(类型 参数名){
       
      //加入业务逻辑判断
      属性 = 参数名;
  }
  

• 3. 提供一个公共的(public)get方法, 用于获取属性值

  public void getXxx(){
       
      return xx;
  }
  

3.3 成员变量/属性私有化问题

  成员变量（field）私有化之后，提供标准的get/set方法，我们把这种成员变量也称为属性（property）。 或者可以说只要能通过get/set操作的就是事物的属性，哪怕它没有对应的成员变量。

3.3.1 成员变量封装目的

• 隐藏类的实现细节
• 保证对象信息的完整性,提高代码的安全性。让使用者只能通过事先预定的方法来访问数据，从而可在该方法里面加入控制逻辑，限制对成员变量的不合理访问。还可以进行数据检查，从而有利于保证对象信息的完整性。
• 便于修改，提高代码的可维护性。主要体现在隐藏的部分，在内部修改了，如果其对外可以的访问方式不变，外部根本感觉不到它的修改。例如：Java8->Java9，String从char[]转为byte[]内部实现，而对外的方法不变，使用者根本感觉不到它内部的修改。

3.3.2 成员变量封装实现

1. 使用 private 修饰成员变量

   public class Chinese{
        
       private static String Country;
       private String name;
       private int age;
       private boolean marry;
   }
   

2. 提供 getXxx方法 / setXxx 方法，可以访问成员变量

   package JavaBase;
   
   public class Chinese {
        
       private static String country;
       private String name;
       private int age;
       private boolean marry;
   
       public static void setCountry(String c) {
        
           country = c;
       }
   
       public static String getCountry() {
        
           return country;
       }
   
       public void setName(String n) {
        
           name = n;
       }
   
       public String getName() {
        
           return name;
       }
   
       public void setAge(int a) {
        
           age = a;
       }
   
       public int getAge() {
        
           return age;
       }
   
       public void setMarry(boolean m) {
        
           marry = m;
       }
       
        public boolean isMarry(){
        
           return marry;
       }
   }
   

3.3.3 如何解决局部变量与成员变量同名问题

当局部变量与类变量（静态成员变量）同名时，在类变量前面加“类名."；

当局部变量与实例变量（非静态成员变量）同名时，在实例变量前面加“this.”。

public class Chinese {
   
    private static String country;
    private String name;
    private int age;

    public static void setCountry(String country) {
   
        Chinese.country = country;
    }

    public static String getCountry() {
   
        return country;
    }

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

    public String getName() {
   
        return name;
    }

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

    public int getAge() {
   
        return age;
    }
}

4.面向对象编程-继承

4.1 概述

  多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成某种关系。如图所示：

其中，多个类可以称为子类，也叫派生类；多个类抽取出来的这个类称为父类、超类（superclass）或者基类。继承描述的是事物之间的所属关系，这种关系是：is-a 的关系。例如，图中猫属于动物，狗也属于动物。可见，父类更通用，子类更具体。通过继承，可以使多种事物之间形成一种关系体系。

  继承可以解决代码复用,让编程更加靠近人类思维.当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过 extends 来声明继承父类即可。

4.2 继承的好处

• 提高代码的复用性。
• 提高代码的扩展性。
• 类与类之间产生了关系，是学习多态的前提。

4.3 继承的格式

【修饰符】 class 父类 {
   
	...
}

【修饰符】 class 子类 extends 父类 {
   
	...
}

示例1:

父类:

package JavaBase.extend.extend01;

// 父类:Pupil 和 Graduate 的父类
public class Student {
   
    // 公共属性
    public String name;
    public int age;
    private double score;

    // 公共方法
    public void setScore(double score) {
   
        this.score = score;