第八章总结

一.Java类包

1.类名冲突
     Java 中每个接口或类都来自不同的类包，无论是Java API中的类与接口还是自定义的类与接口，都需要隶属于某一个类包，这个类包包含了一些类和接口。如果没有包的存在，管理程序中的类名称将是一件非常麻烦的事情。如果程序只由一个类组成，自然不会出现类名重叠的问题，但是随着租序的类的数量增多，难免会出现这一问题。

2.完整的类路径

   在程序中使用两个不同 Date 类的完整类路径，代码如下：

java.util.Date date = new java.util.Date();
java,sql.Date date2 = new java.sql.Date(1000);

  同一包中的类相互访问时，可以不指定包名。

3.创建包

在 Java 中包名设计应与文件系统结构相对应，如一个包名为com.mr，那么该包中的类位于 com文件夹下的 mr 子文件夹下。没有定义包的类会被归纳在默认包 (default package)中。在实际开发中，应该为所有类设置包名，这是良好的编程习惯。在类中定义包名的语法如下：

package  包名

Java包的命名规则是全部使用小写字母。

package com.mr;//指定包名
 
public class Math {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
System.out.println("不是java.lang.Math类,而是com.mr.Math类");
	}
 
}

4.导入包

如果某个类中需要使用 Math 类，那么如何告知编译器当前应该使用哪一个包中的Ma类是java.lang.Math 类还是 commrMath 类?这是一个令人困扰的问题。此时，可以用Java中的impo关键字指定。例如，如果在程序中使用import 关键字导入commrMath类在程中用Ma类就.会自动选择commrMath类。import 关键字的语法如下:

import com.mr.*;               //导入com.mr包中的所有类
import com.mr.Math;            //导入com.mr包中的Mah类

​

在使用import 关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在用import关键字指定时在包指定后加上*，这表示可以在程序中使用该包中的所有类。

使用import 导入静态成员
   import关键子除导入包外，还可以导入静专成员，使用 imp 导入静态成员的语法如下:

import static静态成员

package com.mr;
import static java.lang.Math.max;
//导入静态成员方法
import static java.lang.System.out;
//导入静态成员变量
public class ImportText {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		out.println("1和4的较大值为："+ max(1,4));
		//主方法中可以直接使用这些静态成员
	}
 
}

二.成员内部类

 1.成员内部类简介
在一个类中使用内都类，可以在内部类中直接存取其所在类的租有或员变量。步美有智李场场难如下：

class OuterClass {            //外部类
    class InnerClass         //内部类

在成员内部类中可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private。图8.3充分说明了内部类的使用，尽管成员变量i以及成员方法g（）都在外部类中被修饰为private，但在成员内部类中可以直接使用。

内部类的实例一定要绑定在外部类的实例上，如果从外部类中初始化一个内部类对象，那么内部类对象就会绑定在外部类对象上。内部类初始化方式与其他类的初始化方式相同，都是使用new为关键字。

 
public class Car {//创建汽车类
	private String brand;//汽车品牌
	public Car(String brand) {//汽车类的构造方法，参数为汽车品牌
		this.brand = brand;//给汽车品牌赋值
	}
	class Engine{//发动机类
		String model;//发动机型号
		public Engine(String model) {//发动机类的构造方法，参数为发动机型号
			this.model = model;//给发动机型号赋值
		}
	
		public void ignite() {//点火方法
			System.out.println("发动机"+this.model+"点火");
		}
	}
		public void start() {//启动汽车方法
			System.out.println("启动"+this.brand);
		}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Car car = new Car("大众郎行");//创建汽车类对象，并为汽车品牌赋值
		car.start();//汽车类对象调用启动汽车方法
		Car.Engine engine = car.new Engine("EA211");
		//创建发动机类对象，并为发动机型号赋值
		engine.ignite();//发动机类对象调用点火方法
	}
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
 
}
 

   成员内部类不止可以在外部类中使用，在其他类中也可以使用。在其他类中创建内部类对象的
法非常特殊，语法如下:

外部类 outer =new 外部类（）;
外部类内部类 inner=outer.new 内部类（）;

(1) 如果在外部类和非静态方法之外实例化内部类对象，需要使用"外部类.内部类"的形式指定该对象的类型。
(2)内部类对象会依赖于外部类对象，除非已经存在一个外部类对象，否则类中不会出现巾部类对象。

使用 this 关键字获取内部类与外部类的引用
  如果在外部类中定义的成员变量与内部类的成员变量名称相，可以使用 this 关键字。

 
public class TheSameName {
	private int x=7;//外部类的x
	private class Inner{
		private int x=9;//内部类的x
		public void doit() {
			int x=11;//局部变量的x
			x++;
			this.x++;//调用内部类的x
			TheSameName.this.x++;//调用外部类的x
		}
	}
}

在类中，如果遇到内部类与外部类的成员变量重名的情况，可以使用 his 关键字进行处理。例如，在内部类中使用 this.x 语句可以调用内部类的成员变量x，而使用TheSameName.thisx语句可以调用外部类的成员变量x，即使用外部类名称后跟一个点操作符和 his 关键字便可获取外部类的一个引用。

匿名内部类
   匿名类是只在创建对象时才会编写类体的一种写法。匿名类的特点是“现用现写”，其语法如下;

new 父类/父接口(）{
    子类实现的内容
};

abstract class Dog {//抽象类
	String Color;
	public abstract void move();
	public abstract void call();
}

 
public class Demo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Dog maomao = new Dog() {
			public void move() {//使用匿名内部类补充方法体
				System.out.println("四腿飞奔");//输出
			}
			public void call() {//使用匿名内部类补充方法体
				System.out.println("嗷呜~");//输出
			}
		};
		maomao.Color = "灰色";
		maomao.move();
		maomao.call();
	}
 
}
 
 

从这个结果可以看出，本来无法创建对象的抽象类竟然也可以出现在 new 关键字的右侧。为何叫匿名内部类?就是因为实例中 Dog 抽象类的实现类没有名称。创建出的对象 maomao 既不是金毛犬也不是哈士奇犬，在程序中 maomao 只能解读为“一只具体的无名之狗”。使用匿名类时应该遵循以原则:
匿名类不能写构造方法。
匿名类不能定义静态的成员。
如果匿名类创建的对象没有赋值给任何引用变量，会导致该对象用完一次就会被 Java 虚拟机销毁。 

说明：
   匿名内部类编译以后，会产生以“外部类名S序号”为名称的.class 文件，序号以 1~n 排列分别代表 1~n个匿名内部类。