接口和继承的联系与差别以及监听器

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);
    }
}