『壹』 誰能提供java中介面的實例講解
介面(interface)：
介面的定義：介面從本質上說是一種特殊的抽象類。
關鍵字interface。
在介面中，所有的方法為公開、抽象的方法：public abstract
在介面中，所有的屬性都是公開、靜態的常量：public static final
介面與介面之間可以多繼承，用extends，多個之間用逗號隔開。
介面中沒有構造方法，不能用「new 介面名」來實例化一個介面，但可以聲明一個介面。
介面的實現：
關鍵字implements
一個類實現一個介面必須實現介面中所有的方法，否則其為抽象類，並且在實現類中的方法要加上public(不能省略)。
類中的默認修飾符：default。
介面中的默認修飾符：public。
一個類除了繼承另一個類外（只能繼承一個類），還可以實現多個介面(介面之間用逗號分隔)。
介面的作用：
間接實現多繼承：用介面來實現多繼承並不會增加類關系的復雜度。因為介面不是類，與類不在一個層次上，是在類的基礎上進行再次抽象。
介面可以抽象出次要類型，分出主、次關系類型，符合看世界的一般方法。
介面隔離，與封裝性有關。一個對象都有多個方面，可以只展示其中幾個方面，其他的都隱藏。因此可以看為「更高層次的封裝」，把 一個大介面做成若干個小介面。
通過介面制定標准（最重要的作用）
介面：制定標准。
介面的調用者：使用標准。
介面的實現類：實現標准。
解耦合作用：把使用標准和實現標准分開，使得標準的制定者和實現者解除偶合關系，具有極強的可移植性
例：sun公司提供一套訪問資料庫的介面（標准），java程序員訪問資料庫時針對資料庫介面編程。介面由各個資料庫廠商負責實現。
介面編程的原則
盡量針對介面編程（能用介面就盡量用介面）
介面隔離原則（用若干個小介面取代一個大介面）
注意：
介面中沒有構造器，也沒有main方法
『貳』 JAVA里的介面誰能給我編寫個例子解釋下啊
昂， 在java里 基本都是面向介面編程開發， 為什麼呢·，應為一個類只能繼承一個類 ，卻能實現多個介面，
首先 用起來方便，結構清晰
在j2ee中的介面也就是類，類與類之間的通信因為介面而變的簡單易懂
舉個簡單的JDBC的例子吧，比如有個BaseDao介面，現在有MySQLDao實現了一個（我們可以把具體的實現類配在配置
文件中，再通過反射進行實例化），也就類似這樣的：
BaseDao = (BaseDao)(Class.forName(Config.getDaoName()).newInstance());
其中Config.getDaoName()可以獲得配置文件中的配置，比如是：com.bao..impl.MySQLDao。
之後，那些人開始要燒錢了，要改用Oracle了，這樣我們只要按BaseDao的定義，再實現一個OracleDao就可以了，
再將配置文件中的配置改為：com.bao..impl.OralceDao就可以了，而在已經寫好的代碼中，我們可以一行不
改的進行了資料庫移植，這個就是面向對象設計原則中的「開-閉原則」（對增加是開放的，對修改是封閉的）。但
這只是理論上的，現實中很難做到的。
『叄』 什麼是面向介面編程及一個簡單實例
面向介面編程是一個很高級的概念了以前的面向對象編程，以java為例子，主要的操作針對對象來進行，把要處理的問題簡化分解成對象的方式來解決，對對象的使用主要是引用對象提供的方法後來的使用過程中，逐漸有人發現，當程序的內容不斷擴大，程序的編寫和完善需要更多的人員來合作完成的時候，面向對象的方式有些不便就很突出了，主要的就是類的繼承和方法的重寫，查詢起來和引用起來很多不便。所以現在有面向介面編程的理念提出來，介面就是標准，介面就是規范，但是介面沒有實現的方法，這樣避免了很多類的繼承的問題，特別在大型的程序的編寫方面有廣泛的應用。什麼是面向介面編程及一個簡單實例
『肆』 java編寫一個有關介面的程序
給你的也不是什麼系統之類的.
也就是一個思想而已,想了一下用<設計模式之Factory>來回答你的問題.
///////////////////////////////////////////////////////////////
工廠模式定義:提供創建對象的介面.
為何使用?
工廠模式是我們最常用的模式了,著名的Jive論壇 ,就大量使用了工廠模式，工廠模式在Java程序系統可以說是隨處可見。
為什麼工廠模式是如此常用？因為工廠模式就相當於創建實例對象的new，我們經常要根據類Class生成實例對象，如A a=new A() 工廠模式也是用來創建實例對象的，所以以後new時就要多個心眼，是否可以考慮實用工廠模式，雖然這樣做，可能多做一些工作，但會給你系統帶來更大的可擴展性和盡量少的修改量。
我們以類Sample為例， 如果我們要創建Sample的實例對象:
Sample sample=new Sample();
可是，實際情況是，通常我們都要在創建sample實例時做點初始化的工作,比如賦值 查詢資料庫等。
首先，我們想到的是，可以使用Sample的構造函數，這樣生成實例就寫成:
Sample sample=new Sample(參數);
但是，如果創建sample實例時所做的初始化工作不是象賦值這樣簡單的事，可能是很長一段代碼，如果也寫入構造函數中，那你的代碼很難看了（就需要Refactor重整）。
為什麼說代碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段代碼，說明要做的工作很多，將很多工作裝入一個方法中，相當於將很多雞蛋放在一個籃子里，是很危險的，這也是有背於Java面向對象的原則，面向對象的封裝(Encapsulation)和分派(Delegation)告訴我們，盡量將長的代碼分派「切割」成每段，將每段再「封裝」起來(減少段和段之間偶合聯系性)，這樣，就會將風險分散，以後如果需要修改，只要更改每段，不會再發生牽一動百的事情。
在本例中，首先，我們需要將創建實例的工作與使用實例的工作分開, 也就是說，讓創建實例所需要的大量初始化工作從Sample的構造函數中分離出去。
這時我們就需要Factory工廠模式來生成對象了，不能再用上面簡單new Sample(參數)。還有,如果Sample有個繼承如MySample, 按照面向介面編程,我們需要將Sample抽象成一個介面.現在Sample是介面,有兩個子類MySample 和HisSample .我們要實例化他們時,如下:
Sample mysample=new MySample();
Sample hissample=new HisSample();
隨著項目的深入,Sample可能還會\"生出很多兒子出來\", 那麼我們要對這些兒子一個個實例化,更糟糕的是,可能還要對以前的代碼進行修改:加入後來生出兒子的實例.這在傳統程序中是無法避免的.
但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.
工廠方法
你會建立一個專門生產Sample實例的工廠:
public class Factory{
public static Sample creator(int which){
//getClass 產生Sample 一般可使用動態類裝載裝入類。
if (which==1)
return new SampleA();
else if (which==2)
return new SampleB();
}
}
那麼在你的程序中,如果要實例化Sample時.就使用
Sample sampleA=Factory.creator(1);
這樣,在整個就不涉及到Sample的具體子類,達到封裝效果,也就減少錯誤修改的機會,這個原理可以用很通俗的話來比喻:就是具體事情做得越多,越容易范錯誤.這每個做過具體工作的人都深有體會,相反,官做得越高,說出的話越抽象越籠統,范錯誤可能性就越少.好象我們從編程序中也能悟出人生道理?呵呵.
使用工廠方法 要注意幾個角色，首先你要定義產品介面，如上面的Sample,產品介面下有Sample介面的實現類,如SampleA,其次要有一個factory類，用來生成產品Sample，如下圖，最右邊是生產的對象Sample：
進一步稍微復雜一點，就是在工廠類上進行拓展，工廠類也有繼承它的實現類concreteFactory了。
抽象工廠
工廠模式中有: 工廠方法(Factory Method) 抽象工廠(Abstract Factory).
這兩個模式區別在於需要創建對象的復雜程度上。如果我們創建對象的方法變得復雜了,如上面工廠方法中是創建一個對象Sample,如果我們還有新的產品介面Sample2.
這里假設：Sample有兩個concrete類SampleA和SamleB，而Sample2也有兩個concrete類Sample2A和SampleB2
那麼，我們就將上例中Factory變成抽象類,將共同部分封裝在抽象類中,不同部分使用子類實現，下面就是將上例中的Factory拓展成抽象工廠:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){
.........
return new SampleA
}
public Sample2 creator(String name){
.........
return new Sample2A
}
}
public class BombFactory extends Factory{
public Sample creator(){
......
return new SampleB
}
public Sample2 creator(String name){
......
return new Sample2B
}
}
從上面看到兩個工廠各自生產出一套Sample和Sample2,也許你會疑問，為什麼我不可以使用兩個工廠方法來分別生產Sample和Sample2?
抽象工廠還有另外一個關鍵要點，是因為 SimpleFactory內，生產Sample和生產Sample2的方法之間有一定聯系，所以才要將這兩個方法捆綁在一個類中，這個工廠類有其本身特徵，也許製造過程是統一的，比如：製造工藝比較簡單，所以名稱叫SimpleFactory。
在實際應用中，工廠方法用得比較多一些，而且是和動態類裝入器組合在一起應用.
....後面還有一些,但是我想這些應該可以解決你想知道的了.
『伍』 java編程關於介面的程序
packagecom.shape;
publicinterfaceVolume{
doublePI=3.1415926;
//計算體積
publicdoublecalVolume();
//計算表面積
publicdoublecalArea();
}
packagecom.shape;
//圓柱體
{
privatedoubleRadius;
privatedoubleHeight;
publicCylinder(doubleRadius,doubleHeight){
this.Radius=Radius;
this.Height=Height;
}
publicdoublegetRadius(){
returnRadius;
}
publicvoidsetRadius(doubleradius){
Radius=radius;
}
publicdoublegetHeight(){
returnHeight;
}
publicvoidsetHeight(doubleheight){
Height=height;
}
@Override
publicdoublecalVolume(){
//TODOAuto-generatedmethodstub
returnPI*Radius*Radius*Height;
}
@Override
publicdoublecalArea(){
//TODOAuto-generatedmethodstub
returnPI*Radius*Radius*2+PI*Radius*Height*2;
}
}
packagecom.shape;
//圓錐
{
privatedoubleRadius;
privatedoubleHeight;
publicdoublegetRadius(){
returnRadius;
}
publicvoidsetRadius(doubleradius){
Radius=radius;
}
publicdoublegetHeight(){
returnHeight;
}
publicvoidsetHeight(doubleheight){
Height=height;
}
publicCone(doubleRadius,doubleHeight){
this.Radius=Radius;
this.Height=Height;
}
//圓錐體的母線的長
publicdoublegetConeLine(){
doubleLine=Radius*Radius+Height*Height;
returnMath.sqrt(Line);
}
@Override
publicdoublecalVolume(){
//TODOAuto-generatedmethodstub
returnPI*Radius*Radius*Height/3;
}
@Override
publicdoublecalArea(){
//TODOAuto-generatedmethodstub
returnPI*Radius*Radius+PI*Radius*getConeLine();
}
}
publicclassShapeTestDemo{
publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
Cylindercy=newCylinder(3,4);
System.out.println(cy.calVolume());
System.out.println(cy.calArea());
Conecone=newCone(3,4);
System.out.println(cone.calVolume());
System.out.println(cone.getConeLine());
System.out.println(cone.calArea());
}
}
『陸』 （Java）誰能給個「面向介面編程」的例子
很簡單啊,我給你一個java類庫里的介面怎樣啊?是一個經常用到的MouseListener:
/*
* @(#)MouseListener.java 1.17 03/12/19
*
* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/
package java.awt.event;
import java.util.EventListener;
/**
* The listener interface for receiving "interesting" mouse events
* (press, release, click, enter, and exit) on a component.
* (To track mouse moves and mouse drags, use the
* <code>MouseMotionListener</code>.)
* <P>
* The class that is interested in processing a mouse event
* either implements this interface (and all the methods it
* contains) or extends the abstract <code>MouseAdapter</code> class
* (overriding only the methods of interest).
* <P>
* The listener object created from that class is then registered with a
* component using the component's <code>addMouseListener</code>
* method. A mouse event is generated when the mouse is pressed, released
* clicked (pressed and released). A mouse event is also generated when
* the mouse cursor enters or leaves a component. When a mouse event
* occurs, the relevant method in the listener object is invoked, and
* the <code>MouseEvent</code> is passed to it.
*
* @author Carl Quinn
* @version 1.17, 12/19/03
*
* @see MouseAdapter
* @see MouseEvent
* @see <a href="http://java.sun.com/docs/books/tutorial/post1.0/ui/mouselistener.html">Tutorial: Writing a Mouse Listener</a>
* @see <a href="http://www.awl.com/cp/javaseries/jcl1_2.html">Reference: The Java Class Libraries (update file)</a>
*
* @since 1.1
*/
public interface MouseListener extends EventListener {
/**
* Invoked when the mouse button has been clicked (pressed
* and released) on a component.
*/
public void mouseClicked(MouseEvent e);
/**
* Invoked when a mouse button has been pressed on a component.
*/
public void mousePressed(MouseEvent e);
/**
* Invoked when a mouse button has been released on a component.
*/
public void mouseReleased(MouseEvent e);
/**
* Invoked when the mouse enters a component.
*/
public void mouseEntered(MouseEvent e);
/**
* Invoked when the mouse exits a component.
*/
public void mouseExited(MouseEvent e);
}
介面與類的寫法差不多,這個介面放在MouseListener.java(稱為一個編輯單元)里.
『柒』 java創建介面編程怎麼寫代碼
interface Bike{
public void radio();
}
interface Car{
public void tv();
}
interface Dt{
public void music();
}
public class InterfaceDemo implements Bike,Car,Dt{
public void radio() {
System.out.println("可以聽廣播");
}
public void tv() {
System.out.println("可以看電視");
}
public void music() {
System.out.println("可以聽音樂");
}
public static void main(String args[])
{
InterfaceDemo m=new InterfaceDemo();
m.radio();
m.tv();
m.music();
}
}
『捌』 Java程序設計中舉例說明面向介面編程的框架和編程要點。
面向對象裡面的介面只是用來描述」我們的實現類應該具體什麼樣的功能而不必知道對方用什麼方法做到這點」，具體實現這個功能那叫「實現類」。
例子也恰恰是
Spring
裡面的每個
bean
都可以當成一個組件，假設我們需要使用加密組件把一個消息寫入到磁碟或發送給網路的另一方。這裡面的功能性要求僅僅是「我們需要加密，雙方使用相同的加密方法或標准「。那麼今天我們使用一個自認為強度較高的組件，但過了5年人們發現這個加密方法在電腦性能提高後有安全隱患，我們可以通過
Spring
配置把它替換另一個加密方法的組件，這些組件也是什麼完全相同的介面聲明。這樣你的代碼不需要修改。組件的提供者已經幫我們負責測試它的組件是完全符合功能說明的。
『玖』 java中什麼是針對介面編程請舉個例子（求助大神啊）
通過介面來調用一個類及其方法，而不是直接建立類實體來調用類。
比如將來你要把這個被調用的類換成一個別的實現類時，你就不用去把調用過它的類一個個改掉了，因為它們調的是介面，介面沒變，在配置里把介面的實現類換成新的類，就全部都替換掉了
這就是解耦，提高可維護性
interface 動物 {
void 叫();
}
class 狗 implements 動物 {
void 叫() {
System.out.println("汪");
}
}
class 貓 implements 動物 {
void 叫() {
System.out.println("喵");
}
}
class test{
private 動物 我的寵物;
public static void main() {
我的寵物.叫();
}
}
現在你可以把我的寵物隨便換成狗類或貓類都行了，main方法不用改。
針對實現編程就是
new 狗();
狗.叫();
換了貓再改一次main方法