精华内容
下载资源
问答
  • Java进阶:default方法说明
    千次阅读
    2020-10-20 16:09:04

    1. 概述

    JDK1.8的接口引入了 static 和 default 方法。static相当于public static修饰,和常规的用法一样,直接通过{类名.方法名}调用。而default方法只有public修饰,必须由接口的实现类来调用。

    2. default 的作用

    之所以引入 default ,主要是为了接口的升级。在以往开发中,接口只要增加了方法,所有实现类必须实现该方法,否则编译不通过。而default修饰的接口方法,实现类可以不做任何实现,默认调用接口的default方法。

    3. 示例:实现类不实现接口方法

    定义接口:

    public interface MyService {
       
        static void StaticMethod(){
       
            
    更多相关内容
  • Java default 方法

    千次阅读 2018-05-21 13:52:23
    Default 方法 The section Interfaces describes an example that involves manufacturers of computer-controlled cars who publish industry-standard interfaces that describe which methods can be invoked to...

    Default 方法

    前言:当我在用Spring boot框架开发项目中配置Webconfig类时,该类实现了WebMvcConfigurerAdapter抽象类。但是IDE提示WebMvcConfigurerAdapter类已被弃用,查看该类的定义发现已被@Deprecated注解标记,Spring-webmvc的版本为5.0.6。接着查看它实现的WebMvcConfigurer接口,发现该接口下的所有方法都变成了以default开头的方法,由于之前不了解default关键字,因此查阅官方文档,便有了下面的翻译。

    原文链接:https://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

    部分Interface描述了一个示例,该示例涉及计算机控制的汽车制造商,他们发布行业标准接口,描述可以调用哪些方法来操作他们的汽车。如果那些电脑控制的汽车制造商向他们的汽车添加新的功能,比如飞行,会怎么样呢?这些制造商需要指定新的方法,以使其他公司(如电子导航仪器制造商)能够使他们的软件适应飞行汽车。这些汽车制造商将在哪里声明这些新的飞行相关的方法?如果将它们添加到原始接口中,那么已经实现了这些接口的程序员将不得不重写他们的实现。如果将它们以静态方法的方式添加,那么程序员将视它们为实用方法,而不是本质的核心的方法。

    default方法能够使你向库中添加新的功能,并确保它们和这些接口旧版本现有的代码二进制兼容。

    考虑下面的interface,TimeClient,如在Answers to Questions and Exercises: Interfaces中的描述:

    import java.time.*; 
    
    public interface TimeClient {
        void setTime(int hour, int minute, int second);
        void setDate(int day, int month, int year);
        void setDateAndTime(int day, int month, int year,
                                   int hour, int minute, int second);
        LocalDateTime getLocalDateTime();
    }

    下面SimpleTimeClient类实现了TimeClient接口:

    package defaultmethods;
    
    import java.time.*;
    import java.lang.*;
    import java.util.*;
    
    public class SimpleTimeClient implements TimeClient {
    
        private LocalDateTime dateAndTime;
    
        public SimpleTimeClient() {
            dateAndTime = LocalDateTime.now();
        }
    
        public void setTime(int hour, int minute, int second) {
            LocalDate currentDate = LocalDate.from(dateAndTime);
            LocalTime timeToSet = LocalTime.of(hour, minute, second);
            dateAndTime = LocalDateTime.of(currentDate, timeToSet);
        }
    
        public void setDate(int day, int month, int year) {
            LocalDate dateToSet = LocalDate.of(day, month, year);
            LocalTime currentTime = LocalTime.from(dateAndTime);
            dateAndTime = LocalDateTime.of(dateToSet, currentTime);
        }
    
        public void setDateAndTime(int day, int month, int year,
                                   int hour, int minute, int second) {
            LocalDate dateToSet = LocalDate.of(day, month, year);
            LocalTime timeToSet = LocalTime.of(hour, minute, second); 
            dateAndTime = LocalDateTime.of(dateToSet, timeToSet);
        }
    
        public LocalDateTime getLocalDateTime() {
            return dateAndTime;
        }
    
        public String toString() {
            return dateAndTime.toString();
        }
    
        public static void main(String... args) {
            TimeClient myTimeClient = new SimpleTimeClient();
            System.out.println(myTimeClient.toString());
        }
    }

    假如你想向TimeClient 接口添加新的功能,例如通过ZonedDateTime对象指定时区的能力(这就像一个LocalDateTime对象,只是它存储了时区信息)。

    public interface TimeClient {
        void setTime(int hour, int minute, int second);
        void setDate(int day, int month, int year);
        void setDateAndTime(int day, int month, int year,
            int hour, int minute, int second);
        LocalDateTime getLocalDateTime();                           
        ZonedDateTime getZonedDateTime(String zoneString);
    }

    在此基础上修改了TimeClient接口,你将不得不修改SimpleTimeClient 类,并且实现getZonedDateTime方法。然而你不必保持getZonedDateTime方法为抽象方法(像之前的例子一样),取而代之可以定义一个默认的实现。(记住,抽象方法是在没有实现的情况下声明的方法)。

    package defaultmethods;
    
    import java.time.*;
    
    public interface TimeClient {
        void setTime(int hour, int minute, int second);
        void setDate(int day, int month, int year);
        void setDateAndTime(int day, int month, int year,
                                   int hour, int minute, int second);
        LocalDateTime getLocalDateTime();
    
        static ZoneId getZoneId (String zoneString) {
            try {
                return ZoneId.of(zoneString);
            } catch (DateTimeException e) {
                System.err.println("Invalid time zone: " + zoneString +
                    "; using default time zone instead.");
                return ZoneId.systemDefault();
            }
        }
    
        default ZonedDateTime getZonedDateTime(String zoneString) {
            return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString));
        }
    }

    你通过在方法签名前以default关键字开始的方式,在一个接口中指定了一个方法的定义。在interface中,所有的方法声明,包括default方法的可见范围都隐式的声明为public,因此你可以省略这个public修饰符。

    对于这个interface,你不需要改变SimpleTimeClient类,这个类(任何实现了接口TimeClient的类)将有已经定义了的getZonedDateTime方法。下面这个例子,TestSimpleTimeClient类从SimpleTimeClient类的一个实例中调用了getZonedDateTime 方法。

    package defaultmethods;
    
    import java.time.*;
    import java.lang.*;
    import java.util.*;
    
    public class TestSimpleTimeClient {
        public static void main(String... args) {
            TimeClient myTimeClient = new SimpleTimeClient();
            System.out.println("Current time: " + myTimeClient.toString());
            System.out.println("Time in California: " +
                myTimeClient.getZonedDateTime("Blah blah").toString());
        }
    }

    继承包含default方法的接口

    当你继承一个包含default方法的接口时,你可以执行以下操作:

    • 根本不用提及default方法,这让你继承的接口继承default方法。
    • 重新声明default方法,使它成为抽象方法。
    • 重新定义default方法,重写default方法。

    假如你像下面这样继承TimeClient接口:

    public interface AnotherTimeClient extends TimeClient { }

    实现了AnotherTimeClient 接口的任何类,都将拥有default方法TimeClient.getZonedDateTime的实现。

    假如你像下面这样继承TimeClient接口:

    public interface AbstractZoneTimeClient extends TimeClient {
        public ZonedDateTime getZonedDateTime(String zoneString);
    }

    任何实现了AbstractZoneTimeClient 接口的类,都将不得不实现getZonedDateTime方法;这个方法是一个抽象方法,像一个接口中所有其他非default(和非静态)方法一样。

    假如你像下面这样继承TimeClient接口:

    public interface HandleInvalidTimeZoneClient extends TimeClient {
        default public ZonedDateTime getZonedDateTime(String zoneString) {
            try {
                return ZonedDateTime.of(getLocalDateTime(),ZoneId.of(zoneString)); 
            } catch (DateTimeException e) {
                System.err.println("Invalid zone ID: " + zoneString +
                    "; using the default time zone instead.");
                return ZonedDateTime.of(getLocalDateTime(),ZoneId.systemDefault());
            }
        }
    }

    所有实现了HandleInvalidTimeZoneClient 接口的类,都将使用HandleInvalidTimeZoneClient 接口中实现的getZonedDateTime 方法,而不是第一个接口TimeClient中的getZonedDateTime 方法。

    静态方法

    除了default方法,你可以在接口中定义静态方法。(静态方法是与定义它的类相关联的方法,而不是与任何对象相关联的方法。类的每个实例都共享其静态方法。)这个使你更容易在函数库中组织辅助方法;你可以保持静态方法与同一个接口中,而不是分开的类中。下面的例子定义了一个静态方法,该方法依据地区标识符检索返回一个ZoneId对象;如果依据得到的标识符没有检索出ZoneId对象,那么将返回系统默认的地区时间。(因此,你可以简化getZonedDateTime方法):

    public interface TimeClient {
        // ...
        static public ZoneId getZoneId (String zoneString) {
            try {
                return ZoneId.of(zoneString);
            } catch (DateTimeException e) {
                System.err.println("Invalid time zone: " + zoneString +
                    "; using default time zone instead.");
                return ZoneId.systemDefault();
            }
        }
    
        default public ZonedDateTime getZonedDateTime(String zoneString) {
            return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString));
        }    
    }

    像类中的静态方法,在一个接口中,你需要使用static关键字在方法签名前来制定它为静态方法。在一个接口中所有的方法声明,包括静态方法,隐式地声明为public,因此你能省略public标识符。

    集成default方法到现有的库中

    default方法能够使你向已经存在的接口中添加新的功能,并确保它们和这些接口旧版本现有的代码二进制兼容。特别的,default方法使您能够添加将lambda表达式作为参数的方法添加到现有接口中。本节演示如何使用默认和静态方法增强Comparator接口。

    考虑在Classes的问题和练习中描述的Card和Deck类。这个例子重写CardDeck类为接口。Card接口包含了两个枚举类型(Suit和Rank)和两个抽象方法(getSuit和getRank):

    package defaultmethods;
    
    public interface Card extends Comparable<Card> {
    
        public enum Suit { 
            DIAMONDS (1, "Diamonds"), 
            CLUBS    (2, "Clubs"   ), 
            HEARTS   (3, "Hearts"  ), 
            SPADES   (4, "Spades"  );
    
            private final int value;
            private final String text;
            Suit(int value, String text) {
                this.value = value;
                this.text = text;
            }
            public int value() {return value;}
            public String text() {return text;}
        }
    
        public enum Rank { 
            DEUCE  (2 , "Two"  ),
            THREE  (3 , "Three"), 
            FOUR   (4 , "Four" ), 
            FIVE   (5 , "Five" ), 
            SIX    (6 , "Six"  ), 
            SEVEN  (7 , "Seven"),
            EIGHT  (8 , "Eight"), 
            NINE   (9 , "Nine" ), 
            TEN    (10, "Ten"  ), 
            JACK   (11, "Jack" ),
            QUEEN  (12, "Queen"), 
            KING   (13, "King" ),
            ACE    (14, "Ace"  );
            private final int value;
            private final String text;
            Rank(int value, String text) {
                this.value = value;
                this.text = text;
            }
            public int value() {return value;}
            public String text() {return text;}
        }
    
        public Card.Suit getSuit();
        public Card.Rank getRank();
    }

    Deck接口包含了各种各样操作Card的方法:

    package defaultmethods; 
    
    import java.util.*;
    import java.util.stream.*;
    import java.lang.*;
    
    public interface Deck {
    
        List<Card> getCards();
        Deck deckFactory();
        int size();
        void addCard(Card card);
        void addCards(List<Card> cards);
        void addDeck(Deck deck);
        void shuffle();
        void sort();
        void sort(Comparator<Card> c);
        String deckToString();
    
        Map<Integer, Deck> deal(int players, int numberOfCards)
            throws IllegalArgumentException;
    
    }

    PlayingCard 类实现了Card接口,StandardDeck 类实现了Deck接口。

    StandardDeck 类实现了抽象方法Deck.sort,如下:

    public class StandardDeck implements Deck {
    
        private List<Card> entireDeck;
    
        // ...
    
        public void sort() {
            Collections.sort(entireDeck);
        }
    
        // ...
    }

    Collections.sort方法是一个List实例的排序,它的元素类型实现了Comparable接口。entireDeck成员是一个List实例,它的元素类型是Card,其继承了Comparable接口。PlayingCard类实现了Comparable.compartTo方法,如下:

    public int hashCode() {
        return ((suit.value()-1)*13)+rank.value();
    }
    
    public int compareTo(Card o) {
        return this.hashCode() - o.hashCode();
    }

    compareTo方法使得StandardDeck.sort()中cards元素先按照suit排序,再按照rank排序。

    如果你想要deck的排序先按照rank排序,再按照suit排序怎么办?你需要实现Comparator接口来指定新的排序规则,并且使用sort(List list, Comparator

    public void sort(Comparator<Card> c) {
        Collections.sort(entireDeck, c);
    } 

    使用这种方法,你可以指定Collections.sort方法中Card类实例的排序。一种方式是实现Comparator接口来指定你想要的cards排序。下面的例子SortByRankThenSuit 就是这样做的。

    package defaultmethods;
    
    import java.util.*;
    import java.util.stream.*;
    import java.lang.*;
    
    public class SortByRankThenSuit implements Comparator<Card> {
        public int compare(Card firstCard, Card secondCard) {
            int compVal =
                firstCard.getRank().value() - secondCard.getRank().value();
            if (compVal != 0)
                return compVal;
            else
                return firstCard.getSuit().value() - secondCard.getSuit().value(); 
        }
    }

    下面先按照rank排序,再按照suit排序的方式调用deck的sort方法:

    StandardDeck myDeck = new StandardDeck();
    myDeck.shuffle();
    myDeck.sort(new SortByRankThenSuit());

    然而,这种方式太繁琐了。如果你能指定想要的排序,而不是排序的方式,那就更好了。假设你是编写Comparator接口的开发人员,向Comparator接口添加怎样的default方法或静态方法,才能使其他开发人员更容易地指定排序规则呢?

    首先,假设你对于deck的排序想以rank比较来排序,与suit无关。你可以像下面的这种方式来调用StandardDeck.sort方法:

    StandardDeck myDeck = new StandardDeck();
    myDeck.shuffle();
    myDeck.sort(
        (firstCard, secondCard) ->
            firstCard.getRank().value() - secondCard.getRank().value()
    ); 

    因为Comparator 接口是一个函数式接口,因此你可以使用lambda表达式来作为sort函数的参数。在这个例子中,lambda表达式比较了两个整数值。

    如果开发着能够仅仅通过Card.getRank方法来创建一个Comparator实例,那对于他们来说将会是简单的。特别的,如果开发者能够通过一个方法得到一个数值,例如getValue 或者hashCode方法,从而能够创建一个Comparator实例来比较任何对象,那将是有用的。Comparator接口已经通过使用静态方法比较增强了这个能力:

    myDeck.sort(Comparator.comparing((card) -> card.getRank()));  

    在这个例子中,你可以使用方法引用来代替:

    myDeck.sort(Comparator.comparing(Card::getRank)); 

    这个方法更好的演示了要什么排序,而不是怎样排序。

    Comparator接口也增加了其他版本的比较方法,例如: comparingDoublecomparingLong,这样能够通过比较其他数据类型来创建Comparator实例。

    假设开发者想要超过一种规则比较对象来创建Comparator实例。例如deck的排序先比较rank,然后再比较suit,怎么办?像前面那样,你可以通过Lambda表达式来指定排序规则:

    StandardDeck myDeck = new StandardDeck();
    myDeck.shuffle();
    myDeck.sort(
        (firstCard, secondCard) -> {
            int compare =
                firstCard.getRank().value() - secondCard.getRank().value();
            if (compare != 0)
                return compare;
            else
                return firstCard.getSuit().value() - secondCard.getSuit().value();
        }      
    ); 

    如果能够通过一系列的Comparator实例构建一个Comparator实例,那将会对开发者来说更简单。Comparator接口已经通过default方法thenComparing增强了这个能力:

    myDeck.sort(
        Comparator
            .comparing(Card::getRank)
            .thenComparing(Comparator.comparing(Card::getSuit)));

    Comparator接口已经增加了其他版本的thenComparing(例如 thenComparingDoublethenComparingLong) default方法,使你能够通过比较其他数据类型来创建Comparator实例。

    假设开发者希望创建一个Comparator实例,使它们能够以相反的顺序对对象集合进行排序。例如,你想要对deck中的cards按rank的降序排序,从Ace 到 Two(而不是从Two to Ace)?像之前一样,你可以指定另一个Lambda表达式。然而,如果开发者能够通过调用一个方法从而反转已经存在的Comparator,那将会更简单。Comparator接口已经通过default方法reversed实现了该功能:

    myDeck.sort(
        Comparator.comparing(Card::getRank)
            .reversed()
            .thenComparing(Comparator.comparing(Card::getSuit)));

    这个例子展示了Comparator接口如何通过default方法、静态方法、Lambda表达式和方法引用来创建一个更具表现力的库函数,开发者们能够很快的通过调用方式来推断出它们的功能。使用这些设计来增强库中的接口。

    展开全文
  • java接口中的default方法和static方法

    千次阅读 2020-06-01 09:32:17
    default方法 default修饰方法只能在接口中使用,在接口种被default标记的方法为普通方法,可以直接写方法体。 1.实现类会继承接口中的default方法 如果接口中有default方法: public interface demo { public ...

    在JAVA8之前java中的接口类型旨在定义类型的接口规约,并不能拥有自己的方法实现,具体实现完全交由实现类自己完成。
    在java8以后,接口中可以添加使用default或者static修饰的方法

    default方法

    default修饰方法只能在接口中使用,在接口种被default标记的方法为普通方法,可以直接写方法体。

    1.实现类会继承接口中的default方法

    如果接口中有default方法:

    public interface demo {
    	public default void demoFun(){
    		System.out.println("我是接口");
    	}
    }
    

    Test类实现接口:

    public class Test implements demo {
    	
    }
    

    那么Test类将会继承接口demo 中的demoFun方法:

    public class Test2 {
    	public static void main(String[] args) {
    		Test t = new Test();
    		t.default();
    	}
    }
    
    2.如果一个类同时实现接口A和B,接口A和B中有相同的default方法,这时,该类必须重写接口中的default方法

    (因为,类在继承接口中的default方法时,不知道应该继承哪一个接口中的default方法。)接口A:

    public interface A {
    	public default void c(){
    		System.out.println("方法A");
    	}
    }
    

    接口B:

    public interface B {
    	public default void c(){
    		System.out.println("方法B");
    	}
    }
    

    Test类:

    public class Test implements A,B {
    	@overried
    	public default void c(){
    		System.out.println("方法A,B");
    	}
    }
    
    3.如果子类继承父类,父类中有b方法,该子类同时实现的接口中也有b方法(被default修饰),那么继承(extends)时覆盖了实现接口(implements)时的b()方法

    接口A:

    public interface A {
    	public default void b(){
    		System.out.println("A方法");
    	}
    }
    

    类C:

    public class C {
    	public void b(){
    		System.out.println("C方法");
    	}
    }
    

    子类:

    public class Test extends C implements A{
    
    }
    

    实例化:

    Test test=new Test();
    test.b()
    
    输出值为:C方法
    

    static方法

    用法和普通的static方法一样。

    代码示例
    public interface InterfaceA {

        /**
         * 静态方法
         */
        static void showStatic() {
            System.out.println("static方法");
        }
    
    }
    

    测试

    public class Test {
        public static void main(String[] args) {
            InterfaceA.show();
        }
    }
    

    结果

    static方法
    
    展开全文
  • 浅谈接口与default方法

    千次阅读 2019-06-12 23:01:27
    接口的default方法:  正如我们所熟知的, 接口里正常的方法是不能有函数体只能有一个类似于c++里的方法的声明而没有实现: 即使是空的方法体eclipse也会报错。  每个“继承”接口的类如果没有声明为 ...

    接口与插件:

          初见接口,你可能会奇怪为什么叫接口不叫插件,因为java接口的功能太像一个插件了,插上每个插件,就具有某种功能。

    那么我举个例子你就明白了,比如说一个U盘就相当于一个插件,而要读取U盘的内容就得需要一个USB接口了,倘若缺少二者中的任何一个,都无法实现你想要达到的功能。

    往抽象了说,电脑的外设都可以称为插件,而USB接口在电脑上可以有很多个,把电脑的PC主机抽象为一个类,那么你可以选择实现3个USB接口那么你就可以供3个插件使用并起作用(打印机,光驱),当然你也可以选择不实现,这都取决于你,至于这个插件本身的不同,USB接口并不关心,只取决于实现接口的类。这个就是现实意义中的“多态”。


    接口的优缺点:

    1.      达到了了C++的多继承的目的。一个类可以实现多个接口,在Java中类与类是单一继承,一个类只能由一个父类,打破了继承的局限性。
    2.     降低了程序的耦合性,使程序能更好的被维护。
    3.     缺点:由于每个继承接口的类都必须实现接口内部的功能,造成代码量的迅速膨胀。

    接口的default方法:

       正如我们所熟知的, 接口里正常的方法是不能有函数体只能有一个类似于c++里的方法的声明而没有实现:

    即使是空的方法体eclipse也会报错。

       每个“继承”接口的类如果没有声明为abstract 就必须将接口里的方法全部实现,一个都不能少。

        那么问题来了,倘若你想在这个类中添加一个新的方法,比如这个:

    在这个接口里新加了一个test() 方法,但是为了能让程序编译能够通过我们不得不在每个继承Device接口的类中实现这个方法。这就给代码后期的维护与更新带来了很大的不便,缘于此,Javajdk1.8版本为接口添加了一个default声明。

    这个怎么使用呢?

    我们看到了test方法的声明与在普通类中没有什么不同,当然除了那个public前的default。通过这个default声明我们可以在接口里实现一个类似于普通的class中的Static功能。

    并且实现与否是由你自己决定的,你可以选择在继承接口的类中覆写这个方法,也可以选择不去管它。反正我们都是可以通过多态,将子类对象的引用赋给一个接口对象的引用。

    我们在驱动类中创建一个接口类型的容器:

     然后我们在这个容器中添加“东西”:

     (注:Tv、Stopwacth、LightBulb是三个继承接口的类,其中Tv覆写了test方法)

     然后我们遍历这个容器:

    看下结果:

    是不是感觉有种覆写基类方法的感觉......


    总结:

       a.有了default 我们可以在接口中实现普通类中的方法,有访问权限、函数体、返回类型。

       b.我们可以通过default 可以很容易的在接口中添加新的方法,而不是必须在每个继承该接口的类中覆写该方法。减少了java的代码量。

     


    代码附录:

    public interface Device {
    	 
    	void turnOn();
    	
    	void turnOff();
    	
    	default public void test() {
    	System.out.println("I am a default method from interface from Device");
      }
    	
    }
    public class Stopwacth implements Device{
    	private int state;
    	private long startTime;
    	private String name;
    
    	/**
    	 * @param state
    	 * @param startTime
    	 * @param name
    	 */
    	public Stopwacth(int state, long startTime, String name) {
    		super();
    		this.state = state;
    		this.startTime = startTime;
    		this.name = name;
    	}
    
    	@Override
    	public void turnOn() {
    		System.out.println(" The stopwatch has been turned on.");
    		
    	}
    
    	@Override
    	public void turnOff() {
    		System.out.println(" The stopwatch has been turned on.");
    		
    	}
    	public String toString() {
    		return "stopwatch: "+" state: "+this.state+" startTime: "+this.startTime+
    				" name: "+this.name;
    	}
    	
    
    }
    public class Tv implements Device {
    	
    	private String name;
    	
    	public Tv(String initialname)
    	{
    		this.name = initialname;
    	}
    
    	@Override
    	public void turnOn() {
    		
    		System.out.println(" The Tv has been turned on.");
    		
    	}
    
    	@Override
    	public void turnOff() {
    		
    		System.out.println(" The Tv has been turned off.");
    		
    	}
    	
    	public String toString() {
    		return "name: "+this.name;
    	}
    	public void test() {
    		System.out.println("����TV class��");
    	}
    
    }
    
    public class LightBulb implements Device{
    	private String name;
    	
    
    	/**
    	 * @param name
    	 */
    	public LightBulb(String name) {
    		super();
    		this.name = name;
    	}
    
    	@Override
    	public void turnOn() {
    		System.out.println(" The LightBulb has been turned on.");
    		
    	}
    
    	@Override
    	public void turnOff() {
    		System.out.println(" The LightBulb has been turned on.");
    		
    	}
    	public String toString() {
    		return "LightBulb:\n"+"name: "+this.name;
    	}
    
    }
    import java.util.ArrayList;
    
    public class Main {
    	
        private ArrayList<Device> device = new ArrayList<Device>();
    
    	public static void main(String[] args) {
    		  
                 Main m = new Main();
                 m.addDevice();
                 m.display();
                 
    	}
    	private void display() {
    		for(Device de:device) {
    			de.turnOn();
    			de.turnOff();
    			de.test();
    		}
    		
    	}
        private void addDevice() {
    		device.add(new Tv("ximenzi"));
    		device.add(new Tv("songxia"));
    		device.add(new Tv("changhong"));
    		device.add(new Stopwacth(1,13333,"kaxiou"));
    		device.add(new Stopwacth(2,2444,"kaxiou"));
    		device.add(new Stopwacth(3,4555,"kaxiou"));
    		device.add(new LightBulb("xiaoming"));
    		device.add(new LightBulb("xiaofang"));
    		device.add(new LightBulb("xiaohong"));
        }
        
    	
    
    }

     

    展开全文
  • java接口中的default方法

    千次阅读 2020-12-17 17:15:03
    在接口中,可以定义default方法。例如,把Person接口的run()方法改为default方法: public class Main { public static void main(String[] args) { Person p = new Student("Xiao Ming"); p.run(); } } ...
  • Java 接口中的default方法

    千次阅读 2019-11-22 23:17:37
    在java8以后,接口中可以添加使用default或者static修饰的方法,在这里我们只讨论default方法,default修饰方法只能在接口中使用,在接口种被default标记的方法为普通方法,可以直接写方法体。 1、实现类会继承接口...
  • Java学习笔记之default方法

    千次阅读 2018-12-28 15:18:52
    Default Methods是java8中的特性,主要是在之前接口中智能定义方法名称和参数类型,并不能写实际的逻辑,java8之后使用Default Methods就可以写了,下面看一个例子: 首先定义接口: public interface TestDefault...
  • 接口中的default方法和static方法

    千次阅读 2019-02-24 20:02:29
    Java接口中的default方法和static方法。default方法由接口实现类来调用 static将由接口(或其实现类)直接调用(实际上实现类调用不到) 接口中的静态方法实现类无法继承,default方法实现类可以继承。 一般情况下...
  • Python进阶之路 setdefault方法

    千次阅读 多人点赞 2019-06-03 18:49:56
    setdefault方法 setdefault方法用于设置key的默认值。该方法接收两个参数,第1个参数表示key,第2个参数表示默认值。如果key在字典中不存在,那么setdefault方法会向字典中添加这个key,并用第2个参数作为key的值。...
  • Java 8的default方法详解

    万次阅读 2015-01-11 16:26:43
    Java 8的default方法详解作者:chszs,转载需注明。博客主页:http://blog.csdn.net/chszsJava 8新增了default方法,它可以在接口添加新功能特性,而且还不影响接口的实现类。下面我们通过例子来说明这一点。public ...
  • Jdk1.8新特性(一) 接口的default方法

    千次阅读 2019-02-21 19:24:13
    Jdk1.8打破了这样的用法:接口中可以实现具体的方法体,只需要加上关键字static或者default修饰即可。 1)使用static来修饰的称之为静态方法,静态方法通过接口名来调用; 2)使用default来修饰的称之为默认方法,...
  • 接口里的default方法

    万次阅读 2017-04-23 17:58:52
    我们都知道接口里的变量默认隐含类型是...我的PC上安装的是jdk1.8,一次编写接口代码的时候,看到接口里的方法竟然可以定义为default类型,很好奇,就查看了一下这个default关键字究竟有什么含义,原来是jdk1.8的接口新
  • jdk8新加入的default方法

    千次阅读 2017-03-26 14:35:19
    default方法的加入是为了兼容jdk8以前的版本的需要。 (1)当前有两个接口MyInterface和MyInterface1,它们都有相同名字的default方法,之后实现类Myclass同时implements了MyInterface和MyInterface1,同时Myclass...
  • Java 8 interface default方法

    千次阅读 2016-07-12 18:33:11
    我们都知道在Java8以前,接口中只能定义方法名,而不能包含方法的具体实现代码。接口中定义的方法必须在接口的非抽象子类中实现。下面就是关于接口的一个例子: interface InterfaceA{ void doFirstWork(); } ...
  • Java8 接口中default方法带来的问题

    千次阅读 2018-05-21 16:22:48
    接口中默认方法中的问题: 默认方法的出现,是为了方便 当所有实现类都需要添加某个方法时,在接口中能直接写实现过程。 但是,如果某个类,实现了两个接口,并且这两个接口有同名默认方法,那么这个类就无法判断...
  • Java8揭秘(三)Default 方法

    万次阅读 2014-04-21 01:46:25
    为什么要有Default方法 一旦Java8发布,有件事情就显得非常重要,即能在不破坏现有实现架构的情况下往接口里增加方法。之所以引入Default方法到Java8,正是为了优化接口,同时不会跟现有实现架构产生兼容问题。看...
  • Java - 一个类实现的多个接口,有相同签名的default方法会怎么办 public interface A { default void hello() { System.out.println("Hello from A"); } } public interface B extends A { default ...
  • Java8新特性–Interface中的default方法(接口默认方法)在Java8的新特性中有一个新特性为接口默认方法,该新特性允许我们在接口中添加一个非抽象的方法实现,而这样做的方法只需要使用关键字default修饰该默认实现...
  • Java接口中的default方法

    千次阅读 2021-08-15 22:37:24
    Java接口中的default方法 default 接口中可以添加使用default或者static修饰的方法,在这里我们只讨论default方法,default修饰方法只能在接口中使用,在接口中被default标记的方法为普通方法,可以直接写方法体。...
  • JDK 8 中Interface新增的default方法和static方法的区别和使用
  • python的get与set_default方法

    千次阅读 2018-10-15 15:18:15
    setdefault()方法语法: dict.setdefault(key, default=None) dict必须是一个字典类型 参数 key – 查找的键值。 default – 键不存在时,设置的默认键值。 返回值 如果 key 在 字典中,返回对应的value值。...
  • 【JAVA】接口中的default和static方法

    千次阅读 2020-04-11 00:13:25
    所以java设计者妥协了,在java8中,支持default和static方法,这样,实现接口时,可以选择不对default修饰的方法重写。 概念: 接口提供一个默认实现的方法,并且不强制实现类重写此方法 ...
  • JAVA8中接口interface引入方法实现的猜想在JAVA8之前java中的接口类型旨在定义类型的接口规约,并不能拥有自己的方法实现,具体实现完全交由实现类自己完成。以普通人和中上阶层为例,为各自的子女读大学的目标: ...
  • Java中的Default方法

    千次阅读 2015-12-03 18:04:26
    Java中的Default方法Java8在接口中新引入了一种default方法。目的是保留原先的结构,只将改动加入到接口中。public interface A { default void c(){ System.out.println("A.c"); } }public interface B { default...
  • lambda表达式:默认方法default

    千次阅读 2015-12-09 14:40:15
    写给大忙人看的JavaSE8中的lambda表达式:默认方法default
  • Java关键字Default的两种使用方法 其实之前一直都没有关注过还有default这关键字的存在,最近重新回温《Java语言程序设计》这本书时,想总结总结常用的一些修饰符。偶然发现…嗯..是这样的. 两种使用方法: 据...
  • 在JDK1.8中打破了这样的认识,接口中的方法可以有方法体,但需要关键字static或者default来修饰,使用static来修饰的称之为静态方法,静态方法通过接口名来调用,使用default来修饰的称之为默认方法,默认方法通过...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,098,827
精华内容 839,530
关键字:

default方法

友情链接: ZVZJB.zip