接口
什么是接口?
接口是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
规则:
方法中的内部类依然可以访问外部类的属性和方法
方法中的内部类必须在使用前定义
方法中的内部类可以访问方法中的定义的变量
方法中的内部类通过最近声明原则确定具体属性或常量