第八章包和内部类

包

包在整个管理过程中起到了非常重要的作用，

可以有效的管理繁杂的类文件，

在java中每定义好一个类，通过Java编译器进行编译之后，都会生成一个class文件，但当程序规模逐渐扩大，就很容易发生类名冲突的现象。Java中提供了一种管理类文件的机制，就是类包。

Java中每个接口或类都来自不同的类包，无论是JavaAPI中的类与接口还是自定义的类与接口，都需要一个类包，如果没有包的存在，管理程序中的类名称将是一个非常麻烦的事情。

知道包的位置

首先我们要知道我们的代码地址所在地，打开eclipse我们会看到控制台，复制控制台的地址到文件管理器粘贴，

 在这个下面我们可以看到我们建立的文件夹，在这些文件夹中存放我们的代码。

.metadata文件是配置文件

 随便打开一个文件夹

 其中bin文件夹是存放class文件的，src是存放java的，我们知道java文件要通过编译才能形成class，而eclipse会自动帮我们编译形成。

创建包

新建Java project文件

我们要首先建立一个Java project文件，

这样文件管理器，我们的工作台的文件夹所存在的地方就会出现新建的一个文件夹，现在这个文件夹里面什么都没有。

然后将新建的，JAVA project文件下的src文件下的.Java删除，

 新建package

然后右击src，新建一个package的文件，也就是包，

这样文件管理器的src文件夹就会有新建的package文件，但是这个文件夹里面什么都没有

因为我们还要建立class文件

建立class

 建立好class文件后，我们回到文件管理器可以在src文件夹看到我们新建的class，同时bin文件夹中也会存在.Java

 因为这个操作是非常常见的操作，我们会使用很多次这样的操作，我们可以在建立包的同时建立class文件

同时建立

就是在建立class文件的同时设置好包。

哪怕我们没有这个包，编译器也会自动生成包，然后在生成class文件。

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

例题8

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文件");//输出
	}

}

 导入包

我们创建好了包需要使用就是导入包，要使用import关键字

import         包名.类名

import        包名.*

在使用import关键字的时候可以指定类的完整描述，

使用包中的多个类

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

在前面的学习中我们使用到了从键盘输入，

要完成这个要求，我们要导入扫描器，就要用import 关键字导入Scanner;

例题8.2

package com.mr;
import static java.lang.Math.max;//导入静态成员方法
import static java.lang.System.out;//导入静态成员变量
public class Math {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		out.println("1和4的较大值为："+max(1,4));//直接使用静态成员
	}

}

 从例题中可以看出，分别使用import         static导入了java.lang.Math类中的静态成员方法 max()和Java.lang.System类中的out成员变量，这时就可以直接引用这些静态成员，如主方法中直接使用out.println()表达式以及max()方法。

 内部类

在一个类中使用内部类，可以在内部类中直接存放其所在类的私有成员变量，语法：

class OuterClass{

        class InnerClass{

        }

}

在成员内部类中可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为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) {
		Car car=new Car("大众朗行");//创建对象，并赋值
		car.Start();//调用方法
		//创建内部类的对象，并赋值
		Car.Engine engine= car.new Engine("EA211");
		engine.ignite();//调用对象
	}
		
}

 使用this关键字获取内部类与外部类的引用

例题：在内部类中调用外部类对象

构造方法中的x会遵行就近原则，自增为构造方法中的x;

而内部类，也就是构造方法所在的类，要自增就要用this关键字，意思为这个类，也就是内部类；

而外部类就自增就，外部类名.this.x++；用外部类名和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++;//构造方法x自增
			this.x++;//内部类x自增
			TheSameName.this.x++;//外部类x自增
			
		}
	}
}

匿名内部类

匿名内部类，顾名思义，就是看不到内部类的名字。

一般调用抽象方法的时候会使用到，

在调用的语句后面加{ }，

在{ }中补全抽象方法，原理是重写。

//抽象方法
abstract class dog{
	String color;//变量
	//抽象方法
	public abstract void move();
	public abstract void call();
}

public class Demo {

	public static void main(String[] args) {
		dog wangcai =new dog() //匿名内部类
				{
			public void move() {
				System.out.println("四腿狂奔");
		}
			public void call() {
				System.out.println("嗷呜~");
			}
		};
		wangcai.color="灰色";
		wangcai.move();
		wangcai.call();
	}

}