009.java_接口、嵌套类、JAR文件

接口

只规定功能，而不限制如何进行实现的结构，在程序设计中称为设计与实现相分离。

Java语言中的接口就属于设计部分，他只是声明一套功能，而没有具体的实现。

通过关键字interface定义接口，默认public；使用关键字implements实现接口；

如果一个类实现实现了某一个接口，就要实现接口中所有的方法体，否则就变成了抽象类；

接口中的方法没有方法体，默认public；

接口中可以声明变量，定义变量，全部都是public static final 静态不可修改的；

接口不是类，不能创建对象。

public class interfaceTest{
	
	public static void main(String[] args){
		Flyer f=new Airplance();//接口变量引用实现类Airplance的对象
		f.fly();//输出  飞行...
		
		interfaceTest test=new interfaceTest();
		test.oip(f);           // 传入参数由实现接口的类的对象来代替
		test.oip(new bird());
		
		System.out.println(Flyer.pi);  //接口中的常量可直接用接口名引用
	}
	public void oip(Flyer f){   //形参为接口类型
		System.out.println("飞得更高");
		f.fly();
	}
}

interface Flyer {  //如果写上接口类型为public   就要单独建一个文件 放入接口
	public void takeoff(); //起飞
	public void fly();  //飞行
	public void land();  //降落
	
	public static final double pi=3.141592653589793d;//接口中的变量声明时就要赋值  不可改
}

  class Airplance implements Flyer{  //实现接口Flyer  就是实现它的所有方法

	public void takeoff() {
		System.out.println("准备起飞！");
	}

	public void fly() {
		System.out.println("飞行...");
	}

	public void land() {
		System.out.println("降落！");
	}
 }
	
abstract class Animals {
	public abstract void eat();
}

 class bird extends Animals implements Flyer{  ///bird类继承抽象类Animals 实现 Flyer接口  必须重写它们的方法
	@Override
	public void takeoff() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void fly() {
		// TODO Auto-generated method stub
		System.out.println("飞鸟。。。");
	}

	@Override
	public void land() {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void eat() {
		// TODO Auto-generated method stub
		
	}
	 
}

运行结果：

飞行...
飞得更高
飞行...
飞得更高
飞鸟。。。
3.141592653589793

如果一个类实现了多个接口，就要实现所有接口声明的方法。

嵌套类

java允许在类中声明类，这种在类内部的类被称为嵌套类。嵌套类可使用外部类所有的属性和方法。

public class MemberInnerClassTest {
	static class Outer{
		private int outer_i=100;
		private int j=123;
		public void test(){
			System.out.println("outer::test()");
		}
		public void accessInner(){
			Inner i=new Inner();     //调用内部类方法前  先声明一个内部类
			i.display();
		}
		
		class Inner{  //在outer类内定义嵌套类inner
			private int inner_i=100;
			private int j=789;
			public void display(){
				System.out.println(outer_i);
				test();                       //内部类可以在方法体内直接使用外部类的属性和方法
				System.out.println(Outer.this.j);//内部类访问自己的参数 j 或 this.j 或 外部类名.this.j
			}
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outer out=new Outer();
		out.test();
		out.accessInner();
		
		Outer.Inner in=out.new Inner();  //创建内部类对象
		in.display();
	}

}

运行结果：

outer::test()
100
outer::test()
123
100
outer::test()
123

局部内部类：

class Inout{
	private String str="between";
	private int j=123;
	public void amethod(final int iArgs){
		int b=10;
		
		class Bicycle{  //在方法体中新建一个类
			private int j=678;
			public void sayHello(){
				System.out.println(j);   //默认访问本类的j
				System.out.println(Inout.this.j);//访问外部类的j
				System.out.println(b);  //可以访问方法体内的变量
				System.out.println(str);
				System.out.println(iArgs);
			
			}
		}
		Bicycle b1=new Bicycle();
		b1.sayHello();               //在方法体中创建，实例化一个类，并调用本身的方法
	}
}
public class LocalInnerClassTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Inout i=new Inout();
		i.amethod(100);
	}

}

运行结果：

678
123
10
between
100

匿名内部类

没有声明名称的内部类。在声明时就直接创建出对象了。

匿名内部类都是某个已存在类或接口的子类或具体实现类。

匿名内部类在java图形界面(GUI)编程的事件处理程序中使用起来很方便。

class Aclass{
	private String name;
	public Aclass(String name) {
		this.name=name;
	}
	public void print(){
		System.out.println("SuperClass:the name="+name);
	}
}
public class AnnonymoseInnerClassTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		(new Aclass("redhacker") {
			@Override
			public void print() {  //对父类print()方法的覆盖
				// TODO Auto-generated method stub
				System.out.println("the annony class print");
				super.print();
			}
		}).print();
	}

}

运行结果：

the annony class print
SuperClass:the name=redhacker

静态嵌套类

http://blog.csdn.net/iispring/article/details/46490319

用static修饰的嵌套类称为静态嵌套类，可声明static成员或非静态成员，但只能访问外部类的静态成员。

class MyOuter{
	private static int outer_i=100;
	private int i=10;
	public void display(){
		System.out.println(this.i+this.outer_i);
	}
	public void test(){
		Inner i=new Inner();
		i.diaplay();
	}
	public static class Inner{
		private static int inner_i=200;
		private String name="zz";
		public static void display(){
			System.out.println(inner_i);
//			System.out.println(name);
//			System.out.println(i);//无法访问    静态内部类只能访问内部类中的静态变量
		}
		public  void diaplay(){
			System.out.println(outer_i);
			System.out.println(name);   //非静态函数 可访问内部类的非静态成员，不能访问外部类中的非静态函数
			
		}
	}
}
public class StaticNestedClassTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
//		MyOuter out=new MyOuter();
//		MyOuter.Inner in=out.new Inner();
//		in.diaplay();  //内部类的实例化对象需要绑定一个外围类的实例化对象，而静态嵌套类的实例化对象不能也无法绑定外围类的实例化对象。
		
		MyOuter.Inner.display();        //静态嵌套类的静态方法可以直接调用
		
		MyOuter i=new MyOuter();
		i.test();   //默认调用非静态函数
	}

}

运行结果：

200
100
zz

JAR文件

JAR（Java Archive）文件,也叫做java归档文件。

JAR 文件格式以流行的 ZIP 文件格式为基础。与 ZIP 文件不同的是，JAR 文件不仅用于压缩和发布，而且还用于部署和封装库、组件和插件程序，并可被像编译器和 JVM 这样的工具直接使用。在 JAR 中包含特殊的文件，如 manifests 和部署描述符，用来指示工具如何处理特定的 JAR。

JAR 文件格式提供了许多优势和功能，其中很多是传统的压缩格式如 ZIP 或者 RAR 所没有提供的。它们包括：

安全性　

可以对 JAR 文件内容加上数字化签名。这样，能够识别签名的工具就可以有选择地为您授予软件安全特权，这是其他文件做不到的，它还可以检测代码是否被篡改过。

减少下载时间　

如果一个 applet 捆绑到一个 JAR 文件中，那么浏览器就可以在一个 HTTP 事务中下载这个 applet 的类文件和相关的资源，而不是对每一个文件打开一个新连接。

压缩　

JAR 格式允许您压缩文件以提高存储效率。

传输平台扩展　

Java 扩展框架（Java Extensions Framework）提供了向 Java 核心平台添加功能的方法，这些扩展是用 JAR 文件打包的（Java 3D 和 JavaMail 就是由 Sun 开发的扩展例子）。

包密封

存储在 JAR 文件中的包可以选择进行密封，以增强版本一致性和安全性。密封一个包意味着包中的所有类都必须在同一 JAR 文件中找到。

包版本控制

一个 JAR 文件可以包含有关它所包含的文件的数据，如厂商和版本信息。

可移植性
处理 JAR 文件的机制是 Java 平台核心 API 的标准部分。