public class tt1 { public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象 //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难 lover l1 = new lover(); l1.love(); } } //定义接口 interface ILove { void love(); } //外部实现类 class lover implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); } }
//输出为:I love you lover ---> 1
public class tt1 { //静态内部类 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象 //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难 ILove l1 = new lover1(); l1.love(); //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦 ILove l2 = new lover2(); l2.love(); } } //定义一个函数式接口 interface ILove { void love(); } //外部实现类 class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); } }
//输出为:I love you my lover ---> 1
// I love you my lover ---> 2
public class tt1 { //静态内部类 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象 //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难 ILove l1 = new lover1(); l1.love(); //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦 ILove l2 = new lover2(); l2.love(); //局部内部类 class lover3 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 3"); } } ILove l3 = new lover3(); l3.love(); } } //定义一个函数式接口 interface ILove { void love(); } //外部实现类 class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); } }
//输出为:I love you my lover ---> 1
// I love you my lover ---> 2
// I love you my lover ---> 3
public class tt1 { //静态内部类 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象 //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难 ILove l1 = new lover1(); l1.love(); //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦 ILove l2 = new lover2(); l2.love(); //局部内部类 class lover3 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 3"); } } ILove l3 = new lover3(); l3.love(); //使用内部匿名类 ILove l4 = new ILove() { @Override public void love() { System.out.println("I love you my lover ---> 4"); } }; } } //定义一个函数式接口 interface ILove { void love(); } //外部实现类 class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); } }
//输出为:I love you my lover ---> 1
// I love you my lover ---> 2
// I love you my lover ---> 3
// I love you my lover ---> 4
public class tt1 { //静态内部类 static class lover2 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 2"); } } public static void main(String[] args) { //用外部类来实现接口,首先需要在主类外定义另外一个类,之后再在内部类中创建对象 //这样对于那些只需要使用一次的接口来说比较的麻烦,而且也会使整个代码变得臃肿,给其他开发人员带来阅读困难 ILove l1 = new lover1(); l1.love(); //使用静态内部类来实现,由于实现类和main方法位于相同主类中,方便了开发人员阅读,但是实现过程还是比较麻烦 ILove l2 = new lover2(); l2.love(); //局部内部类 class lover3 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 3"); } } ILove l3 = new lover3(); l3.love(); //使用内部匿名类 ILove l4 = new ILove() { @Override public void love() { System.out.println("I love you my lover ---> 4"); } }; l4.love(); //使用Lambda表达式实现接口 ILove l5 = () ->{ System.out.println("I love you my lover ---> 5"); }; l5.love(); } } //定义一个函数式接口 interface ILove { void love(); } //外部实现类 class lover1 implements ILove{ @Override public void love() { System.out.println("I love you my lover ---> 1"); } }
//输出为:
I love you my lover ---> 1
I love you my lover ---> 2
I love you my lover ---> 3
I love you my lover ---> 4
I love you my lover ---> 5
关于Lambda表达式的更加极致的简化(针对有参数的Lambda表达书)
本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注的更多内容!