java中类的表现形式分为三种:
interface
class
abstract class
为什么需要接口?
接口可以被继承之后去实现具体的功能,扩展性很好。
接口的实现与类的继承相比而言，更加的条理清晰。
接口解决多继承带来的种种问题。
一个class只能extends一个class （单根继承）
public class A{}
public class B extends A{}
一个interface可以extends多个interface
public interface C{}
public interface D{}
public interface E extends C,D{}
一个class可以implements多个interface
public class F implements C,D{}
一个class可以在extends一个class后，再implements多个interface
public class G extends A implements C,D{}
接口的特点:
1、接口中的属性，必须是公共的静态常量
2、接口具有很好的扩张性，里面的方法都是没有方法体的，是一个非常抽象的方法。
3、接口中的方法是抽象的，用来创建对象是无意义的，它不能产生任何行为，所以接口中没有构造方法。创建对象的时候，虽然接口是父类，但是不需要先调用接口的构造方法，（接口没有构造方法）即可创建对象。
特别注意：
继承(实现)一个接口需要用关键字implements
实现一个接口需要实现接口中的所有方法,故必须要给所有方法加上方法体.
子类在重写父类方法的时候不可以减少方法的可见性.
//接口中的方法都是没有方法体的,是一个非常抽象的方法.
public interface Person {
public static final String name="人";//必须赋予初值
String s="";//默认是public static final
public void study();//=public abstract void study();
}
public class Student implements Person{
public void study() {
System.out.println("学习");
}
public void eat(){、、此处必须声明是public的
System.out.println("吃饭");
}
}
public class Manager {
public static void main(String args[]){
Person p=new Student();
p.study();
p.eat();
}
}
关于多个接口的继承与强制转换：
public class Manager {
public static void main(String args[]){
Person p=new Student();
p.study();
p.eat();
//Person继承了a,b,所以a,b都是Student的父类
//所以以下写法都是正确的
a a1=new Student();
b b1=new Student();
b b2=(b)a1;//强制转型关心的是原本的类型,原本a1是Student类,所以可以被转成b
People pp=new People();
// a a2=(a)pp;
/*此时会编译出错,因为pp是People类型,People类是Student的父类,
*a类是Student的子类,但是People和a类并无直接关系.
*/
}
}
public interface b {
void ab();
}
public interface a {
void ab();
}
public class People {
int num;
}
public class Student extends People implements Person{
public void study() {
System.out.println("学习");
}
public void eat(){
System.out.println("吃饭");
}
public void ab() {
System.out.println("这是a与b的方法");
}
}
public interface Person extends a,b{
public static final String name="人";//必须赋予初值
String s="";//默认是public static final
public void study();//=public abstract void study();
void eat();
}
接口的实现与类的继承的区别和联系
通过接口可以实现不相关类的相同行为，而不需要了解对象所对应的类。
如果你的一组方法需要在很多类里实现，那么就可以把它们抽象出来，做成一个接口规范，更加方便使用。
如果你的接口有三个实现类，而三个实现类实现接口的某个方法的逻辑各不相同，利用java的多态机制会非常简化代码编写，逻辑也会很清晰。
给你举个例子，假设有A B C三个类，都有一个move()方法，如果要求你实现一个数组，数组里面只能是A B C的一种，需要遍历集合然后分别调用集合元素的move()方法 ，你想想怎么弄？
你只能具体instanceof A 这样挨个判定是那个具体类型，然后分别调用A.move() B.move() C.move()方法
而加入你定义了一个A B C 统一的接口 名称为MInterface ，接口的方法就是move() ，那么就可以用下面的代码很简单实现
public class InterfaceDemo {
public static void main(String[] args) {
MInterface[] ary=new MInterface[5];//直接定义一个接口的数组，调用不同的
//实现方法，可是类的继承无法做到这一点
ary[0]=new A();
ary[1]=new B();
ary[2]=new C();
ary[3]=new B();
ary[4]=new A();//接口的具体实现类
for(MInterface m:ary){
m.move();//java的自动向下绑定会自动实现具体实现类的move()方法
}
}
}
class A implements MInterface{
public void move() {
System.out.println("这一行代表A对接口方法的业务逻辑实现");
}
}
class B implements MInterface{
public void move() {
System.out.println("这一行代表B对接口方法的业务逻辑实现");
}
}
class C implements MInterface{
public void move() {
System.out.println("这一行代表C对接口方法的业务逻辑实现");
}
}
interface MInterface{
public void move();
}
事件监听机制的基本了解
在窗体程序中,会涉及到许多鼠标键盘的动作,程序需要知道他们在什么时候产生了动作,所以需要加一个监听器时刻监视他们的行为,比如是否点击了某一个按钮,鼠标现在指在哪个位置.
实现方法:定义一个监听器并实现相应接口,再增加到相应的对象上,实现对该对象产生的事件的监听.
示例程序:
public class MyListener implements ActionListener{
public void actionPerformed(ActionEvent e) {
}
}
public class MainUI extends JFrame{
MainUI(){
JButton denglu=new JButton("登 录");//按钮
this.setTitle("QQ ");
this.setSize(380, 295);
this.setDefaultCloseOperation(3);
denglu.setBounds(115, 250, 160, 30);//定位
denglu.setContentAreaFilled(false);//设置按钮透明
this.add(denglu);
MyListener lis=new MyListener();
denglu.addActionListener(lis);
}
}
public class Main {
public static void main(String[] args) {
MainUI mu=new MainUI();
mu.setVisible(true);
}
}
