本文实例讲述了Java接口定义与实现方法。分享给大家供大家参考，具体如下：
 
在java中，我们可以通过继承得到另一个类中的方法，但是这个仅仅满足继承一个方法，那有办法可以多个继承不，就好比，我们人类的基因，总有一部分是继承爸爸，一部分是继承妈妈，而java中有是单继承，那我们怎么办解决？java中就用接口的方式来解决，实现接口，就可以实现所谓的多继承
 
什么是接口？
 
一个Java 接口(interface)是一些方法特征的集合，这些方法特征来自于具体方法，这些方法符合它们一般来自于一些在系统中不断出现的方法。一个接口只有方法的特征，而没有方法的实现，因此这些方法在不同的地方被实现时，可以具有完全不同的行为。在Java语言中，Java接口还可以定义public的变量。
 
接口把方法的特征和方法的实现分割开来。这种分割，体现在接口常常代表一个角色(role)，它包装与该角色相关的操作和属性，而实现这个接口的类便扮演这个角色的演员(类)。一个角色(接口)可以由不同的演员(类)来演，而不同的演员(类)之间除了扮演一个共同的角色(接口)之外，并不要求有任何其他的共同之处。
 
注意:
 
在人们讲到“接口”时，这个词往往有两种不同的含义：
 
第一种是指Java接口，这是一种Java语言中存在的结构，有特定的语法和结构。
 
第二种仅仅是指一个类所具有的方法的特征集合，是一种逻辑上的抽象。
 
Java的接口可以有public、静态的(static)和final的属性。
 
通过下面的例子我们来看看接口的相关特性：
 
package com.duotai;
 
/*
 
* 接口最大的好处就是多继承
 
* 他的特性Java接口可以有public，静态的和final属性，也可以默认不带
 
* 默认方法就是抽象的(abstract)
 
*/
 
interface home{
 
public void refrigerator();//方法不能写实现Java接口可以有public，静态的和final属性。它等同于 // public static final refrigerator();
 
void chest();// 接口没有构造方法，也不能被实例化的
 
}
 
interface eat{
 
public void fruit();
 
void rice();
 
}
 
/**
 
* 我们来实现这个接口
 
* @author jun
 
*1.我们创建一个人，并建一个name的方法
 
*2.我们创建一个boy
 
*3.boy分别去实现(多继承)eat和一个home这接口
 
*/
 
class person{
 
String name;
 
public void name(String name){
 
this.name=name;
 
}
 
}
 
//可以继承一个类，并且还可以实现这两个接口，接口只能用implements来实现
 
class boy extends person implements eat,home{
 
//实现的时候，子类必须实现父类的所有方法，所以就有了下3个方法
 
@Override
 
public void refrigerator() {
 
// TODO Auto-generated method stub
 
System.out.println("这个是个冰箱");
 
}
 
@Override
 
public void chest() {
 
// TODO Auto-generated method stub
 
System.out.println("这个是个衣柜");
 
}
 
@Override
 
public void fruit() {
 
// TODO Auto-generated method stub
 
System.out.println("这是水果");
 
}
 
@Override
 
public void rice() {
 
// TODO Auto-generated method stub
 
System.out.println("这是米饭");
 
}
 
}
 
public class Imptents {
 
/**
 
* @param args
 
* 现在到了我们调用的时刻了，我们的方法只能调用它自己里面的方法
 
* 就比如
 
*/
 
public static void main(String[] args) {
 
// TODO Auto-generated method stub
 
System.out.println("脚本之家测试结果：");
 
home h=new boy();
 
h.refrigerator();
 
h.chest();
 
eat e=new boy();
 
e.rice();
 
e.fruit();
 
}
 
}
 
运行结果：
 

 
希望本文所述对大家java程序设计有所帮助。

 
将一个方法的默认实现放在一个超类中是最好的，当子类想要偏离这个方法时要覆盖它，还是应该把超类方法抽象出来，并且跨越许多子类来重复正常的实现？
 
例如，我涉及的一个项目有一个类，用于指定它应该停止的条件。抽象类如下：
 
public abstract class HaltingCondition{
 
public abstract boolean isFinished(State s);
 
}
 
一个微不足道的实现可能是：
 
public class AlwaysHaltingCondition extends HaltingCondition{
 
public boolean isFinished(State s){
 
return true;
 
}
 
}
 
我们用对象做这件事的原因是我们可以随意地将这些对象组合在一起。例如：
 
public class ConjunctionHaltingCondition extends HaltingCondition{
 
private Set conditions;
 
public void isFinished(State s){
 
boolean finished = true;
 
Iterator it = conditions.iterator();
 
while(it.hasNext()){
 
finished = finished && it.next().isFinished(s);
 
}
 
return finished;
 
}
 
}
 
但是，我们有一些停止的条件需要通知事件发生。例如：
 
public class HaltAfterAnyEventHaltingCondition extends HaltingCondition{
 
private boolean eventHasOccurred = false;
 
public void eventHasOccurred(Event e){
 
eventHasOccurred = true;
 
}
 
public boolean isFinished(State s){
 
return eventHasOccurred;
 
}
 
}
 
我们应该如何最好地在抽象超类中表示eventHasOccurred(Event e)？大多数子类可以具有这种方法的无操作实现(例如AlwaysHaltingCondition)，而一些需要重要的实现才能正常运行(例如HaltAfterAnyEventHaltingCondition)，而其他子类不需要对该消息做任何事情，而必须将其传递给其下属以使它们正常运行(例如ConjunctionHaltingCondition)。
 
我们可以有一个默认的实现，这将减少代码重复，但会导致某些子类编译但如果不被重写，则无法正确运行，或者我们可以将该方法声明为抽象，这将要求每个子类的作者考虑他们提供的实施情况，虽然十分之一的时候是九分之一将是一个无操作的实施。这些策略的其他优点和缺点是什么？是比一个好吗？

 
/**
 
* Java事件监听处理――自身类实现ActionListener接口，作为事件监听器
 
*
 
* @author codebrother
 
*/
 
class EventListener1 extends JFrame implements ActionListener {
 
private JButton btBlue, btDialog;
 
public EventListener1() {
 
setTitle("Java GUI 事件监听处理");
 
setBounds(100, 100, 500, 350);
 
setLayout(new FlowLayout());
 
btBlue = new JButton("蓝色");
 
btDialog = new JButton("弹窗");
 
// 将按钮添加事件监听器
 
btBlue.addActionListener(this);
 
btDialog.addActionListener(this);
 
add(btBlue);
 
add(btDialog);
 
setVisible(true);
 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
}
 
// ***************************事件处理***************************
 
@Override
 
public void actionPerformed(ActionEvent e) {
 
if (e.getSource() == btBlue) {
 
Container c = getContentPane();
 
c.setBackground(Color.BLUE);
 
}
 
else if (e.getSource() == btDialog) {
 
JDialog dialog = new JDialog();
 
dialog.setBounds(300, 200, 400, 300);
 
dialog.setVisible(true);
 
}
 
}
 
}
 
/**
 
* Java事件监听处理――内部类处理
 
*
 
* @author codebrother
 
*/
 
class EventListener3 extends JFrame {
 
private JButton btBlue, btDialog;
 
// 构造方法
 
public EventListener3() {
 
setTitle("Java GUI 事件监听处理");
 
setBounds(100, 100, 500, 350);
 
setLayout(new FlowLayout());
 
btBlue = new JButton("蓝色");
 
btDialog = new JButton("弹窗");
 
// 添加事件监听器对象(面向对象思想)
 
btBlue.addActionListener(new ColorEventListener());
 
btDialog.addActionListener(new DialogEventListener());
 
add(btBlue);
 
add(btDialog);
 
setVisible(true);
 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
}
 
// 内部类ColorEventListener，实现ActionListener接口
 
class ColorEventListener implements ActionListener {
 
@Override
 
public void actionPerformed(ActionEvent e) {
 
Container c = getContentPane();
 
c.setBackground(Color.BLUE);
 
}
 
}
 
// 内部类DialogEventListener，实现ActionListener接口
 
class DialogEventListener implements ActionListener {
 
@Override
 
public void actionPerformed(ActionEvent e) {
 
JDialog dialog = new JDialog();
 
dialog.setBounds(300, 200, 400, 300);
 
dialog.setVisible(true);
 
}
 
}
 
}
 
/**
 
* Java事件监听处理――匿名内部类处理
 
*
 
* @author codebrother
 
*/
 
class EventListener2 extends JFrame {
 
private JButton btBlue, btDialog;
 
public EventListener2() {
 
setTitle("Java GUI 事件监听处理");
 
setBounds(100, 100, 500, 350);
 
setLayout(new FlowLayout());
 
btBlue = new JButton("蓝色");
 
btDialog = new JButton("弹窗");
 
// 添加事件监听器(此处即为匿名类)
 
btBlue.addActionListener(new ActionListener() {
 
// 事件处理
 
@Override
 
public void actionPerformed(ActionEvent e) {
 
Container c = getContentPane();
 
c.setBackground(Color.BLUE);
 
}
 
});
 
// 并添加事件监听器
 
btDialog.addActionListener(new ActionListener() {
 
@Override
 
public void actionPerformed(ActionEvent e) {
 
JDialog dialog = new JDialog();
 
dialog.setBounds(300, 200, 400, 300);
 
dialog.setVisible(true);
 
}
 
});
 
add(btBlue);
 
add(btDialog);
 
setVisible(true);
 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
}
 
}
 
/**
 
* Java事件监听处理――外部类处理
 
*
 
* @author codebrother
 
*/
 
class EventListener4 extends JFrame {
 
private JButton btBlue, btDialog;
 
public EventListener4() {
 
setTitle("Java GUI 事件监听处理");
 
setBounds(100, 100, 500, 350);
 
setLayout(new FlowLayout());
 
btBlue = new JButton("蓝色");
 
btDialog = new JButton("弹窗");
 
// 将按钮添加事件监听器
 
btBlue.addActionListener(new ColorEventListener(this));
 
btDialog.addActionListener(new DialogEventListener());
 
add(btBlue);
 
add(btDialog);
 
setVisible(true);
 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
}
 
}
 
// 外部类ColorEventListener，实现ActionListener接口
 
class ColorEventListener implements ActionListener {
 
private EventListener4 el;
 
ColorEventListener(EventListener4 el) {
 
this.el = el;
 
}
 
@Override
 
public void actionPerformed(ActionEvent e) {
 
Container c = el.getContentPane();
 
c.setBackground(Color.BLUE);
 
}
 
}
 
// 外部类DialogEventListener，实现ActionListener接口
 
class DialogEventListener implements ActionListener {
 
@Override
 
public void actionPerformed(ActionEvent e) {
 
JDialog dialog = new JDialog();
 
dialog.setBounds(300, 200, 400, 300);
 
dialog.setVisible(true);
 
}
 
}
 
public class ActionListenerTest
 
{
 
public static void main(String args[])
 
{
 
new EventListener2();
 
}
 
}

 
本文实例讲述了Java Swing实现窗体添加背景图片的2种方法。分享给大家供大家参考，具体如下：
 
在美化程序时，常常需要在窗体上添加背景图片。通过搜索和测试，发现了2种有效方式。下面分别介绍。
 
1. 利用JLabel加载图片
 
利用JLabel自带的setIcon(Icon icon)加载icon，并设置JLabel对象的位置和大小使其完全覆盖窗体。这是一个很取巧的办法，代码非常简单，如下所示。
 
JLabel lbBg = new JLabel(imageIcon);
 
lbBg.setBounds(0, 0, frameSize.width, frameSize.height);
 
this.getContentPane().add(lbBg);
 
然而这种方法有几个要注意的点：
 
(1)不能使用布局管理器
 
此时你需要将布局管理器设置为null，然后精确控制所有控件的大小和位置。否则，JLabel无法完整覆盖窗体。
 
(2)应当先添加背景JLabel，再添加其它控件。否则其它控件将被JLabel所遮挡(为什么不是后添加的遮挡先添加的？)。
 
(3)由于控件及窗体的尺寸需要手动控制，因此无法对背景图片进行缩放。
 
2. 重载JPanel的paintComponent(Graphics g)方法
 
通过重载该方法，在JPanel的绘制阶段将指定图片绘制上去即可。由于背景是绘制出来的，因此不会对布局有任何影响。
 
示例代码如下：
 
@Override
 
public void paintComponent(Graphics g) {
 
super.paintComponent(g);
 
g.drawImage(image, 0, 0, d.width, d.height, this);
 
MainFrame.instance().repaint();
 
}
 
下面是一个完整的demo。
 
package frame;
 
import java.awt.Dimension;
 
import java.awt.Graphics;
 
import java.awt.Image;
 
import javax.swing.ImageIcon;
 
import javax.swing.JButton;
 
import javax.swing.JFrame;
 
import javax.swing.JLabel;
 
import javax.swing.JPanel;
 
import javax.swing.JTextField;
 
public class ImageFrame extends JFrame {
 
class ImagePanel extends JPanel {
 
Dimension d;
 
Image image;
 
public ImagePanel(Dimension d, Image image) {
 
super();
 
this.d = d;
 
this.image = image;
 
}
 
@Override
 
public void paintComponent(Graphics g) {
 
super.paintComponent(g);
 
g.drawImage(image, 0, 0, d.width, d.height, this);
 
MainFrame.instance().repaint();
 
}
 
}
 
Dimension frameSize = new Dimension(500, 300);
 
ImageIcon imageIcon = new ImageIcon(this.getClass().getResource(
 
"/images/bg.jpg"));
 
public ImageFrame() {
 
// 设置窗体属性
 
setSize(frameSize);
 
setLocationRelativeTo(null);
 
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
setIconImage(imageIcon.getImage());
 
setUndecorated(true);
 
}
 
public void addImageByJLable() {
 
setLayout(null);
 
// 设置背景
 
JLabel lbBg = new JLabel(imageIcon);
 
lbBg.setBounds(0, 0, frameSize.width, frameSize.height);
 
this.getContentPane().add(lbBg);
 
addComponents();
 
setVisible(true);
 
}
 
public void addImageByRepaint() {
 
ImagePanel imagePanel = new ImagePanel(frameSize, imageIcon.getImage());
 
setContentPane(imagePanel);
 
addComponents();
 
setVisible(true);
 
}
 
private void addComponents() {
 
JButton btn1 = new JButton("haha");
 
btn1.setBounds(10, 20, 60, 30);
 
this.getContentPane().add(btn1);
 
JTextField jtf = new JTextField("22222222222");
 
jtf.setBounds(200, 100, 80, 30);
 
this.getContentPane().add(jtf);
 
}
 
public static void main(String[] args) {
 
// TODO Auto-generated method stub
 
ImageFrame imageFrame = new ImageFrame();
 
// imageFrame.addImageByJLable();
 
imageFrame.addImageByRepaint();
 
}
 
}
 
运行效果如下：
 

 
图1 使用JLabel加载图片效果
 
图1可见，使用JLabel时，由于未图片尺寸与窗体尺寸不一致，导致图片只显示出一部分；且有一个控件被遮挡了。注意：通过精细设置尺寸和添加控件顺序，可以达到较为满意的效果的。
 

 
图2 使用重绘方式加载图片
 
图2可见，不需要可以设置匹配尺寸和控件的添加顺序，即可得到比较满意的效果。
 
补充说明：Swing 重绘 repaint,updateUI区别
 
repaint
 
public void repaint()重绘此组件。
 
如果此组件是轻量组件，则此方法会尽快调用此组件的 paint 方法。否则此方法会尽快调用此组件的 update 方法。
 
注：有关 AWT 和 Swing 所用绘制机制的更多信息，包括如何编写最高效的绘制代码的信息 。
 
updateUI
 
public void updateUI()UIManager 发出的关于 L&F 已经更改的通知。用 UIManager 的最新版本替换当前的 UI 对象。覆盖： 类 JComponent 中的 updateUI另请参见： JComponent.updateUI()
 
可能大家都试过在swing的事件监听中动态添加组件，但是JFrame却不会动态显示，只有变大变小(实际是重画了)才会显示。repaint,updateUI可以，用validate发现也可以。
 
API中对repaint()方法是这样描述的，调度完当前所有未完成的事件后重新绘制该组件，所以repaint方法不总是马上执行。
 
package awtDemo;
 
import java.awt.Container;
 
import java.awt.FlowLayout;
 
import java.awt.event.MouseAdapter;
 
import java.awt.event.MouseEvent;
 
import javax.swing.JButton;
 
import javax.swing.JFrame;
 
import javax.swing.JLabel;
 
import javax.swing.JPanel;
 
@SuppressWarnings("serial")
 
public class Ss extends JFrame {
 
Container con = this.getContentPane();
 
JButton jb1 = new JButton("jb1");
 
JButton jb2 = new JButton("jb2");
 
JLabel jl1 = new JLabel("jl1");
 
FlowLayout gly = new FlowLayout();
 
JPanel jp = new JPanel(gly);
 
public Ss() {
 
con.add(jp);
 
jp.add(jb1);
 
jp.add(jb2);
 
MyListener ml = new MyListener();
 
jb1.addMouseListener(ml);
 
this.setSize(300, 200);
 
this.setVisible(true);
 
}
 
private class MyListener extends MouseAdapter {
 
@Override
 
public void mouseClicked(MouseEvent e) {
 
// TODO Auto-generated method stub
 
try {
 
JButton jb3 = new JButton("jb3");
 
jp.add(jb3);
 
// jp.updateUI();//可以正常显示
 
jp.repaint();//API中对repaint()方法是这样描述的，调度完当前所有未完成的事件后重新绘制该组件，repaint方法不总是马上执行，所以只有调整大小才可以显示。
 
//主要就是下面的invalidate和validate
 
//当然，用jp来invalidate和validatae也是可以的
 
// jp.invalidate();
 
} catch (Exception ex) {
 
ex.printStackTrace();
 
}
 
}
 
}
 
public static void main(String s[]) {
 
Ss sss = new Ss();
 
sss.setVisible(true);
 
}
 
}
 
swing重绘主要有四个关键方法:paint(),repaint(),revalidate(),paintImmediately();
 
而进行绘制时后它会依次调用update(),paint(),paintComponent(),paintBorder(),paintChildren()进行绘制；
 
那么repaint()方法为什么会延时呢？
 
调用repaint()会导致一个区域被增加到重绘列表队列中，且被预定重绘。产生一个防止到系统事件队列中的请求，
 
一旦该请求被处理，内部工具自动毁掉组件的paintImmediately()方法。然后该方法立即执行绘制；
 
也就是说通常情况下repaint()它是不会立即执行的，调用它后会有一个等待处理的过程。但repaint比较高效，会推迟实际的绘制并将多余的请求压缩到单个 paint 调用中。
 
所以如何解决它的repaint()延时问题呢？
 
1.让它立即执行：使用paintImmediately()。
 
2.使用SwingUtilities工具类中的invokeLater(Runnable doRun)方法；把你要在repaint()后执行的操作写在要执行的线程中；(它会把这个方法也加入到java内部事件队列中，它排在repaint()之后，所以一般情况下，它是等repaint()执行完之后才会执行，虽然这样达到效果，但并不理想)；
 
希望本文所述对大家java程序设计有所帮助。