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

朴灿烈づ我的快乐病毒、 2022-09-22 00:32 13阅读 0赞

贴上测试代码：

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.接口对行为抽象，抽象的对类抽象.

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

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