java介面開發實例

① java語言中實現介面的實例

abstract class Person {
public abstract void Eat();
public abstract void Sellp();
}

interface Father {
public void Smoking();
public void GoFishing();
}

interface Mon {
public void WatchTV();
public void Cook();
}

class Me extends Person implements Father,Mon{ //使用「implements」來實現介面
public void Eat() {
System.out.println("我喜歡吃魚香茄子");
}

public void Sellp() {
System.out.println("我喜歡睡覺時做夢");
}

public void Smoking() {
System.out.println("我不喜歡抽煙");
}

public void GoFishing() {
System.out.println("我喜歡釣魚");
}

public void WatchTV() {
System.out.println("我喜歡看電視");
}

public void Cook() {
System.out.println("我不太會做菜");
}
}

public class Test {
public static void main(String[] args) {
Person p1 = new Me();
p1.Eat();
p1.Sellp();

Mon m1 = (Mon)p1;
m1.WatchTV();
m1.Cook();
}
}

② 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）誰能給個「面向介面編程」的例子

很簡單啊,我給你一個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 動物 {
void 叫();
}

class 狗 implements 動物 {
void 叫() {
System.out.println("汪");
}
}

class 貓 implements 動物 {
void 叫() {
System.out.println("喵");
}
}

class test{
private 動物 我的寵物;

public static void main() {
我的寵物.叫();
}
}

現在你可以把我的寵物隨便換成狗類或貓類都行了，main方法不用改。
針對實現編程就是
new 狗();
狗.叫();
換了貓再改一次main方法

⑤ java中介面有什麼作用請創建一個介面（舉例）

介面的作用就是把使用介面的人和實現介面的人分開，實現介面的人不必要關心誰去使用，而使用介面的人也不用關心誰實現的介面，由介面將他們聯系在一起。以上像一段繞口令，那麼通過下面的幾段程序解釋：
1、以生產和使用一台計算機為例，首先，我們定義了一個顯卡的介面，他裡面有顯示功能和獲取顯卡名稱的功能：
interface VidioCard
{
void display();
String getName();
}
2、顯卡的生產者來了，他必須實現介面中定義的所有方法，也可以自己增添若干方法：
class HaolongVidio implements VidioCard
{

String name="Haolong's vidiocard";

void setName(String name){
this.name=name;
}

public void display(){
System.out.println("The Haolong's vidiocard is running!!");
}

public String getName(){
return name;
}
};
顯卡製造商生產出了顯卡，並且通過setName方法貼上了自己的商標，而通過getName方法可以讓使用者知道這塊顯卡的製造商。
3、現在顯卡已經生產出來了，但是我們還需要一塊主板，把生產出來的顯卡插到主板上才能夠使用，那麼我們去買主板：
class MainBorad
{
String cpuname;
VidioCard vc;
void setCPU(String cpuname){
this.cpuname=cpuname;
}

void setVidioCard(VidioCard vc){
this.vc=vc;
}

void run(){
System.out.println("wudi-mainbord!");
System.out.println(vc.getName());
vc.display();
System.out.println("mainbord is running successful!");
}
};
這是主板廠商生產的主板，這也就是我們所說的介面的使用者，在他生產主板的時候並不知道用戶使用的是哪塊顯卡（程序中這樣理解：Mainborad這個類只知道介面VidioCard中有哪些方法，但是並不知道介面的實現類HaolongVidio是怎麼去實現介面的，也就是生產主板的廠商並沒有必要考慮顯卡是哪個廠商的，他要做的只是根據介面把顯卡插槽做好，介面里沒有實現的方法相當於插槽），但是他留出來了顯卡的插槽（插槽就是介面），也就是他不關心誰實現的介面，但是他可以使用介面，預留出顯卡的插槽讓用戶去選購顯卡。
4、現在我們用戶開始組裝計算機了：
public class ChengDuActor
{
public static void main(String [] args){

HaolongVidio hv=new HaolongVidio();//買了一塊HaolongVidio顯卡
MainBorad mb=new MainBorad();//買了一塊主板

mb.setCPU("Intel");//買的是Inter主板
mb.setVidioCard(hv);//把HaolongVidio插到主板上（通過主板上setVidio方法）

//System.out.println(hv.getName());
mb.run();//開電腦運行
System.out.println("success");
}
};
以上看出介面的作用就是大力實現了java的開源性，使軟體開發過程優化，介面重要的特徵是實現了多樣性，能夠很好地解決C++中遺留的多繼承中出現的問題。

⑥ 為什麼java可以實例化介面

Java中介面是不能被new出來的,平時開發中介面都有自己的實現類,這樣可以把子類實例化然後賦值給父類,比如 PersonService personService = new PersonServiceImpl();現在我們項目都使用Spring管理,通過註解來注入,private PersonService personService;然後在上面加入一個@Autowrite註解,這個註解也是把子類實例化賦值給父類了,這也就是我們常常說的多態.

⑦ java中什麼是介面介面的作用是什麼

java介面：

1、Java語言中存在的結構，有特定的語法和結構。

2、Java語言中一個類所具有的方法的特徵集合，是一種邏輯上的抽象。

java介面作用：

1、利於代碼的規范

這樣做的目的一方面是為了給開發人員一個清晰的指示，告訴他們哪些業務需要實現；同時也能防止由於開發人員隨意命名而導致的命名不清晰和代碼混亂，影響開發效率。

2、有利於對代碼進行維護

可以一開始定義一個介面，把功能菜單放在介面里，然後定義類時實現這個介面，以後要換的話只不過是引用另一個類而已，這樣就達到維護、拓展的方便性。

3、保證代碼的安全和嚴密

一個好的程序一定符合高內聚低耦合的特徵，能夠讓系統的功能較好地實現，而不涉及任何具體的實現細節。這樣就比較安全、嚴密一些，這一思想一般在軟體開發中較為常見。

(7)java介面開發實例擴展閱讀：

關於java介面的使用規范：

1、介面中可以定義常量，不能定義變數，介面中的屬性都是全局靜態常量，介面中的常量必須在定義時指定初始值。

2、 介面中所有的方法都是抽象方法，介面中方法都會自動用public abstract 修飾，即介面中只有全局抽象方法。

3、 介面不能實例化，介面中不能有構造。

4、 介面之間可以通過extends實現繼承關系，一個介面可以繼承多個介面，但介面不能繼承類。

5、 介面的實現類必須實現介面的全部方法，否則必須定義為抽象類。

參考資料來源：網路：java介面

⑧ java中介面有哪幾種實現方式，分別舉例說明。

1. 可以通過implements來實現某個介面

2. 可以通過匿名內部類的方式，比如
   

3. Threadthread=newThread(newRunnable(){
   			publicvoidrun(){
   			}
   		});

⑨ Java 介面的實現和創建實例

此處printer並不是介面，他和betterPrinter均是類吧，典型的工廠模式返回對象的，只有Output是介面才對。

⑩ 關於JAVA介面的例子分析~~

附上一圖，希望能夠幫上你的忙。

通過附圖，我們可以了解到DY是介面，它被兩個子類實現，分別是softstudent，softschool。其中softschool還自定義了一個方法名叫print，參數便是DY介面，所以能夠對softstudent進行輸出。

Stringcontent表示的是參數名叫content，它的類型是字元串，名字可以隨便換，但不能是JAVA關鍵字，比如java,while,for等等。

new是構造的意思的，一般類都有默認的構造器，用於實例化類。

最後想說的話：

1,在JAVA世界，一般類名標准都要求單詞首字大寫，比如softschool應該寫成SoftSchool，這是業界內默認的約定。

2,左大括弧不像.net那樣。

舉個例子給你參考：

publicclassSoftSchool{

publicvoidtest(){

//...yourcodes

}

}

publicclassPrinter{

publicstaticvoidmain(String[]args){

SoftSchoolsoftSchool=newSoftSchool();

softSchool.test();

}

}