java接口类

A. java接口类有什么作用

接口是一个标准，是一个约定，而不是一种实现，接口的目的是为了规范实现类，这样就可以不用具体管实现类，因为你不管怎是实现，我只要知道你是实现了这个接口，那么你肯定有那些方法，那么我调用这个接口的方法就肯定没问题。

举个例子，有一个接口，规定一个方法 int calc(int b);
这个函数用于计算从1到b的和

比如有两个类实现了这个接口
第一类是这么实现的
int calc(int b)
{
int sum = 0;
for(int i=1;i<=b;i++)
sum+=b;
return sum
}

第二个类是这么实现的
int calc(int b)
{
int sum = 0;
sum = (1+b) * b / 2
return sum;
}
可见不管哪个类实现了这个接口，我们只要调用calc方法就能计算出sum，而不用管他是怎么实现的

B. java接口类有什么用

接口 其实 可以理解成我们生活中用的插排 插排上不是有三孔的 两孔的 等等 接口就好比一种规则 一种标准 你只有实现了这个接口（你的电源是三角的 或者是两角的 ）你才可以用这个接口里的方法（就好比你把电源插头插到插排上 才可以用电一样）

C. java中有哪些主要的接口和类

实际上完全可以把接口理解成为一种特殊的类，由常量和抽象方法组成的特殊类。

一般都是比较接口和抽象类 因为抽象类和接口有一定的相似性

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而类是可以有私有方法或私有变量的，

另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用.

D. java 类实现接口方法

public class Aircraft implements Vehicle{
private int speed;
public Aircraft(){}
public void setSpeed(int speed){
this.speed=speed;
}
public int getSpeed(){
return this.speed;
}
public void start(int speed){
setSpeed(speed);
}
public void stop(){
this.speed=0;
}
}
Bus同上。
希望对你有所帮助。。。

E. java接口的分类

以下是引用片段：
public interface Actionlistener{
public abstract void actionPerformed(ActionEvent event);
}
仅且只有一个方法，只有实现了这个接口(重写这个接口中的唯一一个方法)，你才有资格去事件监听器列表里注册(参数为Actionlistener类型)，当事件源变动时，自动调用这个唯一的actionPerformed方法。 是没有任何方法和属性的接口。标识接口不对实现它的类有任何语意上的要求，它仅仅表明了实现它的类属于一个特定的类型(传递)。
不推荐过多的使用标识接口。 用Java接口来声明一些常量，然后由实现这个接口的类使用这些常量(以前在做画板的时候这么干过)。建议不要模仿这种常量接口的做法。
【范例】
定义接口格式：
[public]interface 接口名称 [extends父接口名列表]
{
//静态常量
[public] [static] [final] 数据类型变量名=常量值;
//抽象方法
[public] [abstract] [native] 返回值类型方法名（参数列表）;
}
实现接口格式：
[修饰符] class 类名[extends 父类名] [implements 接口A,接口B,···]
{
类成员变量和成员方法；
为接口A中的所有方法编写方法体，实现接口A；
为接口B中的所有方法编写方法体，实现接口B；
}
实例：
本例定义接口AreaInterface，其中有静态常量pai和求面积的抽象方法area（）。类Circle和类Rectangle实现了AreaInterface接口，即为接口中的抽象方法area（）编写了满足各自要求的方法体，分别求圆形和长方形的面积。
程序：AreaInterface.java 1
2
3
4
5 package jiekou;
public interface AreaInterface{
double pai=Math.PI;
double area();
} 程序：Circle.java 1
2
3
4
5
6
7
8
9
10
11
12
13 package jiekou;
public class Circle implements AreaInterface{
double r;
public Circle(double x){
r=x;
}
//实现接口中的抽象方法，求圆面积
public double area(){
return pai * r * r;
}
public String toString(){
return 圆：r=+r+ area=+area();
}
} 程序：Rectangle.java 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package jiekou;
public class Rectangle implements AreaInterface{
double x,y;
public Rectangle(double a,double b){
x=a;
y=b;
}
public double area()//实现接口中的抽象方法，求长方形面积
{
return x * y;
}
public String toString()
{
return 长方形：x=+x+;y=+y+
area=+area();
}
} 区别Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以，这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。如果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。
一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。
不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。
在语法上，抽象类和接口有着以下不同：
1.abstract class在Java语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。 继承抽象类使用的是extends关键字，实现接口使用的是implements关键字，继承写在前面，实现接口写在后面。如果实现多个接口，中间用逗号分隔。例：
public class Main extends JApplet
public class Main implements Runnable
public class Main extends JApplet implements ActionListener
public class Main extends JApplet implements ActionListener, Runnable
2.在abstract class中可以有自己的数据成员，也可以有非abstract的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是static final的，不过在 interface中一般不定义数据成员），所有的成员方法都是abstract的。
3.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是is-a关系，interface表示的是like-a关系。
4.实现接口的类必须实现其中的所有方法，继承自抽象类的子类实现所有的抽象方法。抽象类中可以有非抽象方法。接口中则不能有实现方法。
5.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值。
6.抽象类中的变量默认具有 friendly权限，其值可以在子类中重新定义，也可以重新赋值。
7.接口中的方法默认都是 public abstract 类型的。

F. java 中的接口 是不是一个类

由下图可以看出，接口和类同属于java数据类型的引用数据类型，他们是同等级的，接口并不是类。类是用class定义，而接口是inteface定义。

G. java接口分几类

单方法接口
以下是引用片段：
[2]public interface Actionlistener{
public abstract void actionPerformed(ActionEvent event);
}
仅且只有一个方法，只有实现了这个接口(重写这个接口中的唯一一个方法)，你才有资格去事件监听器列表里注册(参数为Actionlistener类型)，当事件源变动时，自动调用这个唯一的actionPerformed方法。
标识接口

是没有任何方法和属性的接口。标识接口不对实现它的类有任何语意上的要求，它仅仅表明了实现它的类属于一个特定的类型(传递)。
不推荐过多的使用标识接口。
常量接口

用Java接口来声明一些常量，然后由实现这个接口的类使用这些常量(以前在做画板的时候这么干过)。建议不要模仿这种常量接口的做法。

H. java类和接口的区别

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

I. JAVA接口类型的方法

package;

classZoo{
	{
		publicvoideat(){
			System.out.println("tigereat");
		}

		publicvoidsleep(){
			System.out.println("tigersleep");
		}
	}

	AnimalgetAnimal()//这里不明白，Animal不是接口么，怎么可以定义方法？
	{
		returnnewAnimal()//还有这里，接口不是不能实例化么？？你说的没有错，确实不能实例化，但是这里是匿名类，效果相当于代码2
		{
			publicvoideat(){
				System.out.println("animaleat");
			}

			publicvoidsleep(){
				System.out.println("animalsleep");
			}
		};
	}
	//代码2
	AnimalgetAnimal2(){
		{

			@Override
			publicvoideat(){
				//TODOAuto-generatedmethodstub
				
			}

			@Override
			publicvoidsleep(){
				//TODOAuto-generatedmethodstub
				
			}
		}
		returnnewAnimalTest();
	}
}

classTest{
	publicstaticvoidmain(String[]args){
		Zooz=newZoo();
		Animalan=z.getAnimal();
		an.eat();
		an.sleep();
	}
}

interfaceAnimal{
	voideat();

	voidsleep();
}

J. java接口中可以定义类吗

可以定义，也不仅限于抽象类。只是接口本身不能被实例化，接口内部的类是可以实例化的。
调用接口的内部类有两种方法：
1.接口名.类名
2.创建实现类implements接口，再直接实例化内部类
示例代码：
public interface Test{

class A{
public int a=1;
}

}

--

public class Program {
public static void main(String[] args) {
Test.A a = new Test.A();
System.out.println(a.a);
new B().method();
}
}
class B implements Test{

void method(){
System.out.println(new A().a);
}
}
亲测。正常运行打印'1' [换行]'1'