java中接口、抽象类的区别，以及内部类若干思考

贴上测试代码：

package interface_test;

interface dog{
	void move();
	void wang();
	
	class littledog implements dog{     //接口内部内
		public void move(){
			System.out.println("dog move");
		}
		public void wang(){
			System.out.println("dog wang");
		}
		
		public void little(){
			System.out.println("dog little");
		}
		
		
	}
	
	
}

abstract class cat{
	abstract void move();
	abstract void miao();
	
    
	
	void jump(){
		System.out.println("cat jump"); //抽象类中可以实现方法，接口中不行
	}
	
	class littlecat{           //同理，抽象类里面也可以有内部类
		
	}
}

class A{
	private int i = 1;
	
	public void f(){
		System.out.println("A:f()");
	}
	
	class B{
		public void f(){
			System.out.println("B:f()");
			System.out.println("B:i is:" + i); // 访问外围类数据。当然还可以是函数。
		}
	}
}

class idog implements dog{     //接口的实现

	public void move(){
		System.out.println("implements move");
	}
	public void wang(){
		System.out.println("implements wang");
	}
	
	 public void say(){   // 实现接口可添加新的方法，抽象类也一样。但是接口需实现所有的接口，抽象类需要实现所有抽象方法。
	 dog.littledog dl = new dog.littledog();
	 dl.little();
	 }
}

class icat extends cat{
	
	public void move(){
		System.out.println("extends move");
	}
	
	public void miao(){
		System.out.println("extends miao");
	}
	
//	public void jump(){  //普通方法，可以覆盖，也可以不覆盖
//		System.out.println("extends jump");
//	}
}

class IA{
	void f(){
		System.out.println("IA");
	}
	class IAA{
		IA outer(){
			return IA.this;
		}
	}
	
	IAA iaa(){
		return new IAA();
	}
}

class IB{
	void f(){
		System.out.println("IB");
		
	}
	
	class IBB{
		void f(){
			System.out.println("IBB");
			
		}
	}
}


public class t01{
	
	
	public static void main(String[] args){
		 A a = new A();  //内部内的用法
		 A.B ab = a.new B();
		 
		 a.f();
		 ab.f();
		 
		 idog id = new idog();//idog类调用
		 id.move();
		 id.say();
		 
		 icat ic = new icat();
		 ic.move();
		 ic.jump();
		 
		 
		 IA ia = new IA(); //这种方法不创建内部内对象，减少开销.
		 IA.IAA iaa = ia.iaa();
		 iaa.outer().f();
		 
		 IB ib = new IB();//创建了内部类对象
		 IB.IBB ibb = ib.new IBB();
		 ibb.f();
		
		
	}

}

先说说接口与抽象类的相似处

1.都不能被直接实例化，都可以通过继承实现其抽象方法，且在子类都可以添加新的方法。

2.都是面向抽象编程的技术基础，实现了诸多的设计模式。

3.两者里面都可以含内部类。

不同之处：

1.接口支持多继承；抽象类不能实现多继承。

2.接口只能定义抽象规则；抽象类既可以定义规则，还可能提供已实现的成员，还可以定义成员变量。

3.接口可以用于支持回调；抽象类不能实现回调，因为继承不支持

4.接口子类需要实现接口里面所有方法，抽象类子类需要实现所有抽象方法，也可以重写一般方法。

5.接口对行为抽象，抽象的对类抽象.

(可能还有一些不完善的地方，这是我目前的认识-_-)

下面说说内部类。在接口里面使用内部类，使得这些公共代码，可以被该接口的所有不同实现所使用。这里主要介绍一下它的使用方法

分.this和.new方法，具体见代码，值得一提的是.new方法创建了内部类对象，个人觉得比较好用.