JAVA中的接口与内部类

接口

什么是接口？

接口是JAVA中一种自定义的特殊的类

接口中只能声明方法的原型，而不允许定义方法体

接口中定义的属性只能是常量

为什么需要接口

JAVA语言中只支持单继承模式，即一个类有且只有一个父类，那我想多层继承呢，那只能继承接口了，接口只有方法原型，接口定义的属性必须是常量

JAVA中的类都继承了Objiect，Objiect是所有JAVA类的父类

接口的定义和使用

JAVA通过关键字interface定义一个接口

接口中的属性和方法声明只能是public类型

接口其实是一种类类型，可以定义接口类型的引用变量

子类通过关键字implements实现接口中方法

一个子类可以实现多个接口，但是必须实现接口中的所以的方法，否则子类将成为抽象类

 

示例

interface Calculate{

         publicfloat PI=3.14f;

         publicfloat area();

         publicfloat perimeter();

}

 

class Shape{

         privatefloat x=0;

         privatefloat y=0;

        

         publicShape(float x,float y){

                   this.x=x;

                   this.y=y;

         }

 

         publicfinal float getX(){

                   returnx;

         }

 

         publicfinal float getY(){

                   returny;

         }

 

}

 

final class Rectangle extends Shapeimplements Calculate{

         privatefloat width = 0;

         privatefloat height =0;

        

         publicRectangle(float x,float y,float width,float height){

         super(x,y);

         this.width= width;

         this.height= height;

 

         }

 

         publicfloat area(){

                   returnwidth*height;

         }

 

         publicfloat perimeter(){

                   return2*(width+height);

         }

 

}

 

final class Circle extends Shape implementsCalculate{

         protectedfloat radius=0;

 

         publicCircle(float x,float y,float radius){

                   super(x,y);

                   this.radius= radius;

         }

 

         publicfloat area(){

                   returnPI*radius*radius;

         }

 

         publicfloat perimeter(){

                   return2*PI*radius;

         }

}

 

public class Main{

         publicstatic void main(String[] args){

                   Calculater=new Rectangle(2,4,5,10);

                   Calculatec=new Circle(9,10,5);

                   Rectanglez=new Rectangle(1,2,3,4);

        

                   System.out.println(z.getX());

                   System.out.println(r.perimeter());

                   System.out.println(r.area());

                   System.out.println();

                   System.out.println(c.perimeter());

                   System.out.println(c.area());

         //      System.out.println(c.getX());

         }

 

}       

 

接口只是一种特殊的抽象类

接口中的每个方法都是抽象方法

接口中定义的属性都是常量属性

 

内部类只是一个相对的概念，通常指内嵌于其他类中定义的类和内嵌于方法中定义的类

内部类在使用上和顶层类没有什么区别

只是由于内部类在其他类中定义，因此会有一些附加的规则

为什么需要内部类？

对类的使用者而言，只关心方法所提供的功能

对类的实现者而言，需要设计一个特殊的算法实现方法的功能

在设计算法的同时不可避免的会遇见一些逻辑概念，而这些概念可以抽象成一些只有内部使用的类

 

内部类和接口

类里面定义内部类

规则：

JAVA中的内部类可以访问外部类的属性和方法

内部类的使用必须以生成对象的方式进行

在出现二义性的情况下，还是可以通过外部类名+this的方式访问外部类的属性和方法

如果不加限定符，将通过最近声明原则确定具体属性

使用范例1：

这里有个Outer类

class Outer{

         privateint x=0;

         这里明显是定义一个类，这个类是在哪里定义的呢

         privateInner inner= null;

         这下面马上就定义了，在内部修饰的

         Private修饰这个类，明显不想让外部知道这个类

         privateclass Inner{

                   这个类干了什么是呢？首先这个内部有个X为0

                   privateint x=0;        

                   这里有个很奇怪的语法，Outer.this.x++

                   前面的Outer.this看起来是限定符，

                   publicvoid addOuter(){

                            这里调用了外面类的对象来++

Outer.this.x++;

                   }

                   根据我们作用域访问原则：不加限定符，将通过最近声明原则确定具体属性，

                   所以这里的X就是前面Inner类里面的X

public void addSelf(){

                            x++;

                   }

 

                   publicint getX(){

                            returnx;

                   }

         }

         构造函数，构造函数里面创建了这个内部类

         publicOuter(){

                   inner= new Inner();

         }

         这个addOuter是外部类的

         publicvoid addOuter(){

                   调用内部类的addOuter

                   inner.addOuter();

         }

         addInner调用内部类的addSelf()

         publicvoid addInner(){

                   inner.addSelf();

         }

         这里是访问X，这个X明显是外部类的

         publicint getOuterX(){

                   returnx;

         }

         这里访问内部类的X

         publicint getInnerX(){

                   returninner.getX();

         }

}

 

如果不加限定符，将通过最近声明原则确定具体属性

如上面的addSelf方法中的x指的是Inner类的属性X

public class Main{

       public static void main(String[] args){

                Outer o=new Outer();

 

                o.addOuter();

                o.addOuter();

                o.addOuter();

                o.addInner();

 

               System.out.println(o.getOuterX());

               System.out.println(o.getInnerX());

       }

}

 

输出结构是3 1

 

内部类的第二种使用方法

 

方法里面定义内部类

class Outer{

         privateint x=0;

         publicint getX(){

                   finalint x=5;

                   intret=0;

                   classInner{

                            publicvoid addOuter(){

                                     Outer.this.x++;

                            }

                            publicint getX(){

                                     returnx;

                            }

                   }

                   Innerinner=new Inner();

                  这里的X是前面的 privateint x=0那里的x

                   if(this.x==0){

                            inner.addOuter();

                            ret= this.x;

                   }elseif(this.x==1){

                            inner.addOuter();

                            ret= inner.getX();

                   }else{

                            ret= x+inner.getX();

                   }

        

                   returnret;

                   }

}

 

 

 

public class Main{

       public static void main(String[] args){

                Outer o=new Outer();

 

                System.out.println(o.getX());

                System.out.println(o.getX());

                System.out.println(o.getX());

 

 

       }

}

 

输出结果 1 5 10

规则：

方法中的内部类依然可以访问外部类的属性和方法

方法中的内部类必须在使用前定义

方法中的内部类可以访问方法中的定义的变量

方法中的内部类通过最近声明原则确定具体属性或常量