JavaSE 包机制、访问控制权限、内部类

一、包机制

1. package

1.1 package概述

• package是java中包机制。包机制的作用是为了方便程序的管理，不同功能的类分别存放在不同的包下（按照功能划分，不同的软件包具有不同的功能）

1.2 package 使用

• package是一个关键字，后面加包名，包名称通常采用小写
• package语句只允许出现在Java源代码的第一行，注释除外

1.3 命名规范

• 一般都采用公司域名倒序的方式（因为公司域名具有全球唯一性）
• package com.gongsiyuming.xiangmuming.mokuaiming.(gongnengming)
• 公司域名倒序 + 项目名 + 模块名 + 功能名
• 不在同一个package下，包名不可以省略

1.4 带有package的Java程序的编译与运行

• 编译
  例：javac -d.HelloWorld.java
  javac：负责编译的命令
  -d：带包编译
  .：代表编译之后生成的东西放到当前目录下（点代表当前目录）
  HelloWorld.java：被编译的java文件名
• 运行
  java com.gongsiyuming.xiangmuming.mokuaiming.(gongnengming).HelloWorld

2. import

• 使用时机
  A类使用B类
  A类和B类都在同一个包下，不需要import
  A类和B类不在同一个包下，需要import
• import语句只能出现在package语句之下，class声明语句之上，还可以采用“ * ”的方式（“ * ”只代表某些类的名字）

3. JDK常用开发包

• java.lang，此包为Java语言标准包，使用时无需import 引入
• java.sql，提供了JDBC接口类
• java.util，提供了常用工具类
• java.io，提供了各种输入输出流

二、访问控制权限

1. Java中4种访问控制符

• Java使用4种“访问控制符”来控制封装，分别为private、default、protected、public
  private 表示私有，只有自己类能访问；
  default表示没有修饰符修饰，只有同一个包的类能访问
  protected表示可以被同一个包的类以及其他包中的子类访问
  public表示可以被该项目的所有包中的所有类访问
• 访问控制符可以修饰什么
  属性（4个都能用）
  方法（4个都能用）
  类（public和default能用）
  接口（public和default能用）
  

三、内部类

• 在一个类的内部定义的类，称为内部类
• 内部类主要分为：实例内部类、静态内部类、局部内部类

1. 实例内部类

类似于实例变量

• 创建实例内部类，外部类的实例必须已经创建
• 实例内部类会持有外部类的引用
• 实例内部不能定义 static 成员，只能定义实例成员

2. 静态内部类

类似于静态变量

• 静态内部类不会持有外部的类的引用，创建时可以不用创建外部类
• 静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

3. 局部内部类

类似于局部变量

• 局部内部类是在方法中定义的，它只能在当前方法中使用。和局部变量的作用一样
• 局部内部类和实例内部类一致，不能包含静态成员

4. 匿名内部类

• 匿名内部类是局部内部类的一种，该类没有名字，使用前提是只使用一次，且要重写抽象方法

public class Test {
	// 静态变量
	static String country;
	// 该类在类的内部，所以称为内部类
	// 由于前面有static，所以称为“静态内部类”
	static class Inner1 {
	}

	// 实例变量
	int age;
	// 该类在类的内部，所以称为内部类
	// 没有static叫做“实例内部类”
	class Inner2 {
	}

	// 方法
	public void doSome() {
		// 局部变量
		int i = 100;
		// 该类在类的内部，所以称为内部类
		// 局部内部类
		class Inner3 {
		}
	}

	public void doOther() {
		// doSome()方法中的局部内部类Inner3，在doOther()中不能用
	}

	// main方法，入口
	public static void main(String[] args) {
		// 调用MyMath中的mySum方法。
		MyMath mm = new MyMath();
		/*
		 * Compute c = new ComputeImpl(); 
		 * mm.mySum(c, 100, 200);
		 * 或：mm.mySum(new ComputeImpl(), 100, 200);
		 */

		// 使用匿名内部类，表示这个ComputeImpl这个类没名字了
		// 这里表面看上去好像是接口可以直接new了，实际上并不是接口可以new了
		// 后面的{} 代表了对接口的实现。
		// 不建议使用匿名内部类，因为一个类没有名字，没有办法重复使用，且可读性太差
		// 匿名内部类：
		mm.mySum(new Compute() {
			public int sum(int a, int b) {
				return a + b;
			}
		}, 200, 300);

	}

}

// 负责计算的接口
interface Compute {
	// 抽象方法
	int sum(int a, int b);
}

// 不使用匿名内部类则需要编写一个Compute接口的实现类ComputeImpl
/*
 * class ComputeImpl implements Compute{
 * // 对方法的实现 
 * public int sum(int a, int b){ 
 * 		return a + b;
 * 	}
 * }
 */

// 数学类
class MyMath {
	// 方法
	public void mySum(Compute c, int x, int y) {
		int retValue = c.sum(x, y);
		System.out.println(x + "+" + y + "=" + retValue);
	}
}