【化神系列】JavaSE 封装

一. 包的概念

• 在开发过程中，会定义很多类，随着类越写越多，难免会出现类重名而发生覆盖的情况，为了在使用它们的时候不让编译器混淆，我们给类加上一个限定 (前缀)，把所有java程序保存在各自的目录里面，而该目录就是包，包的本质实际上就是一个文件夹

  • 即：把它们放在不同的包里面，调用时再加上前缀即可；这样好处是对同名的类进行了区分；能精确指出我们需要的哪一个；让同名的类在一个程序中可以共存
    包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式

在同一个工程中允许存在相同名称的类，只要处在不同的包中即可

二. 导入包中的类

• 使用类的全路径

  • Java 中已经提供了很多现成的类供我们使用, 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类.

  public class TestDemo {
      public static void main(String[] args) {
          java.util.Date date = new java.util.Date();
          System.out.println(date.getTime());
          
          java.util.Date date2 = new java.util.Date();
          System.out.println(date2.getTime());
          
      }
  }

  

  • 优点：一定不会发生冲突 缺点：使用麻烦，每 new 一个对象都需要.

• 使用 import语句导入包

  import java.util.Date;
  
  public class TestDemo {
      public static void main(String[] args) {
          Date date = new Date();
          System.out.println(date.getTime());
      }
  }

  

  • 若使用import.java.util.*导包时，应注意避免引用不明确的问题

    Error:(5, 9) java: 对Date的引用不明确

    java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

    

• import static导入包中静态的方法和字段

  import static java.lang.Math.*;
  //可以直接使用Math类中的所有静态成员
  public class Test {
      public static void main(String[] args) {
          double x = 30;
          double y = 40;
  // 静态导入的方式写起来更方便一些.
  // double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
          double result = sqrt(pow(x, 2) + pow(y, 2));
          System.out.println(result);
      }
  }

  一个完整类名是包名+类名，在没有 import 导入的情况下，使用一个类需要给出完整的类名

三. 自定义包

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

• 建包

• 建类

• 创建的 Test.java 文件的最上方, 就出现了一个 package 语句

四. 访问限定符

Java中提供了四种访问限定符 public>protected>default>private

• private

  封装

public class TestDemo{
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("bit");
        System.out.println(p.getName());
    }
}
//对类内部的细节进行了隐藏/封装，对类外部提供一些公开的接口，供其他的用户进行访问
class Person{
    private String name;//此时的name只能在类内部进行访问
    public int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void show(){
        System.out.println("姓名: "+name+"年龄: "+age);
    }
}
// private属性：只能在Person类中访问，不能被其他类访问

• default(默认)

  class Person{
      private String name;
      int age;          //默认
  }
  // default属性：只能被本包中类访问

• public(公开的)

被public所修饰的成员可以在任何类中都能被访问到。可以修饰类，构造方法，数据成员，方法成员