java第八章总结

8.1 Java类包：
在Java中定义好一个类，通过Java编译器进行编译之后，都会生成一个扩展名为class的文件，当程序的规模逐渐扩大时，就很容易发生类名称冲突的现象。

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

8.1.2 完整的类途径:
一个完整的类名需要包名与类名的组合，每个类都隶属于一个类包，只要保证同一类包中的类不同名，就可以有效地避免同名类冲突的情况

java.utll.Date = new java.utll.Date();

java.sql.Date date2 = new java.sql.Date(1000);

在Java中采用类包机制非常重要，类包不仅可以解决类名冲突问题，还可以在开发庞大的应用程序时，帮助开发人员管理庞大的应用程序组件，方便软件复用

8.1.3 创建包： 
在Eclipse中创建包的步骤如下：

（1）在项目的src节点上点击，选择‘新建’/‘包’命令（英语为NEW / Package）

 （2）弹出‘新建Java包’（NEW Package）对话框，在‘名称’（Name)文本框输入新建的包名

3.右击新创建的包，选择New,这样新建的类会默认保存在该包中。另外也可以在New java class对话框中指定新建类所在包。

        4.语法（注意：Java包的命名规则是全部使用小写字母）

（3）在Eclipse中创建类时，可以在新建立的包中点击，选择’新建‘（New)命令，这样新建的类会默认保存在该包中，例外也可以在New Java Class对话框中指定新建类所在的包

在Java中包含设计应与文件系统结构相对应，如一个包名为com.mr，那么该包中的类位于com文件夹的mr子文件夹下

定义包名语法如下：

package   包名 

8.1.4 导入包： 

1.使用import关键字入包：

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

import com.mr.Math  //导入com.mr包含Math类

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

2.使用import导入静态成员：

import关键字导入包外，还可以导入静态成员，这是JDK 5.0 以上版本提供的功能，导入静态成员可以使编程更为方便，使用静态成员方法如下：

import static  静态成员

package package1;
 
import java.util.Scanner;
 
public class Test1 {
	public static void main(String[] args) {
	// 从键盘获一个整数
	// 将该整数输出
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个数:");
		int c1 = sc.nextInt();
		System.out.println(c1);
	}
}

8.2 内部类：
在一个文件中定义两个类，则其中任何一个类都不在另一个类的内部，如果在类中在定义一个类，则将在类中在定义的那个类称为内部类

8.2.1 成员内部类:
1.成员内部简介:

在一个类中使用内部类，可以在内部类中之恶存取所在类的私有成员变量，成员内部类的语法如下：

class OuteClass {          //外部类

 class InnerClass {   //内部类

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

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

【例8.3】使用成员内部类模拟发动机点火

  public class c {
 private String brand;  //汽车品牌
 public c(String brand) {//汽车类的构造方法，参数为汽车品牌
  this.brand=brand; //给汽车品牌赋值
 }
 class En{   //发动机类（内部类）
  String model;  //发动机型号
  public En (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
    c c = new c("大众朗行");  //创建汽车类对象，并为汽车品牌赋值
    c.start();   //汽车类对象调用启动（汽车）方法
    //创建发动机类（内部类）对象，并为发动机型号赋值
    c.En engine = c.new En("EA211");
    engine.ignite();  //发动机类对象调用（发动机）点火方法2
   }
    }

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

外部类 outer=new 外部类（）；

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

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

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

如果在外部类中定义的成员变量的成员变量名称相同，可以使用this关键字

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

8.2.2 匿名内部类：

匿名类是只在创建对象时才会编写类体的一种写法，匿名类的特点是‘现用现学’，其语法如下：

new 父类/父接口（）{

      子类实现的内容

}；

使用匿名内部类创建一个抽象类的对象

代码

package package2;
	abstract class Dog {
		   String Color;
		   public abstract void move();
		   public abstract void call();
		  }
 
		   public class Test2{
		   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();
		   }
 
		  }

使用匿名内部类应该遵循以下原则：

（1）匿名类不能写构造方法

（2）匿名类不能定义静态的成员

（3）如果匿名类创建的对象没有赋值给任何引用变量，会导致该对象用完一次就会被java虚拟机销毁。