php中extendsFather技巧_每日一学超越极限Java接口和内部类的编程立异

本次学习目标

5 接口5.1 概述

Java程序是否能够连接利用某种数据库产品，那么要看该数据库产品有没有实现Java设计的JDBC规范

接口的定义，它与定义类办法相似，但是利用 interface 关键字。
它也会被编译成.class文件，但一定要明确它并不是类，而是其余一种引用数据类型。

引用数据类型：数组，类，列举，接口，表明。

【润色符】 interface 接口名{ //接口的成员列表： // 公共的静态常量 // 公共的抽象方法 // 公共的默认方法（JDK1.8以上） // 公共的静态方法（JDK1.8以上） // 私有方法（JDK1.9以上） }

示例代码：

package com.atguigu.interfacetype; public interface Usb3{ //静态常量 long MAX_SPEED = 50010241024;//500MB/s //抽象方法 void in(); void out(); //默认方法 default void start(){ System.out.println("开始"); } default void stop(){ System.out.println("结束"); } //静态方法 static void show(){ System.out.println("USB 3.0可以同步全速地进行读写操作"); } }

接口定义的是多个类共同的公共行为规范，这些行为规范是与外部互换的通道，这就意味着接口里常日是定义一组公共方法。

在JDK8之前，接口中只许可涌现：

（1）公共的静态的常量：个中public static final可以省略

（2）公共的抽象的方法：个中public abstract可以省略

理解：接口是从多个相似类中抽象出来的规范，不须要供应详细实现

在JDK1.8时，接口中许可声明默认方法和静态方法：

（3）公共的默认的方法：个中public 可以省略，建议保留，但是default不能省略

（4）公共的静态的方法：个中public 可以省略，建议保留，但是static不能省略

在JDK1.9时，接口又增加了：

（5）私有方法

除此之外，接口中不能有其他成员，没有布局器，没有初始化块，由于接口中没有成员变量须要动态初始化。

接口不能直接创建工具，但是可以通过接口名直接调用接口的静态方法和静态常量。

package com.atguigu.interfacetype; public class TestUsb3 { public static void main(String[] args) { //通过“接口名.”调用接口的静态方法 Usb3.show(); //通过“接口名.”直策应用接口的静态常量 System.out.println(Usb3.MAX_SPEED); } }

接口不能创建工具，但是可以被类实现（implements ，类似于被继续）。

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。
实现的动作类似继续，格式相仿，只是关键字不同，实现利用 implements关键字。

【润色符】 class 实现类 implements 接口{ // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写 // 重写接口中默认方法【可选】 } 【润色符】 class 实现类 extends 父类 implements 接口{ // 重写接口中抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写 // 重写接口中默认方法【可选】 }

把稳：

1.如果接口的实现类是非抽象类，那么必须==重写接口中所有抽象方法==。

2.默认方法可以选择保留，也可以重写。

重写时，default单词就不要再写了，它只用于在接口中表示默认方法，到类中就没有默认方法的观点了

3.接口中的静态方法不能被继续也不能被重写

示例代码：

package com.atguigu.interfacetype; public class MobileHDD implements Usb3 { //重写/实现接口的抽象方法，【必选】 public void out() { System.out.println("读取数据并发送"); } public void in(){ System.out.println("吸收数据并写入"); } //重写接口的默认方法，【可选】 //重写默认方法时，default单词去掉 public void end(){ System.out.println("清理硬盘中的隐蔽回收站中的东西，再结束"); } }

•对付接口的静态方法，直策应用“接口名.”进行调用即可

–也只能利用“接口名.”进行调用，不能通过实现类的工具进行调用

•对付接口的抽象方法、默认方法，只能通过实现类工具才可以调用

–接口不能直接创建工具，只能创建实现类的工具

package com.atguigu.interfacetype; public class TestMobileHDD { public static void main(String[] args) { //创建实现类工具 MobileHDD b = new MobileHDD(); //通过实现类工具调用重写的抽象方法，以及接口的默认方法，如果实现类重写了就实行重写的默认方法，如果没有重写，就实行接口中的默认方法 b.start(); b.in(); b.stop(); //通过接口名调用接口的静态方法 // MobileHDD.show(); // b.show(); Usb3.show(); } }

之前学过，在继续体系中，一个类只能继续一个父类。
而对付接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。
并且，一个类能继续一个父类，同时实现多个接口。

实现格式：

【润色符】 class 实现类 implements 接口1，接口2，接口3。
。
。
{ // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写 // 重写接口中默认方法【可选】 } 【润色符】 class 实现类 extends 父类 implements 接口1，接口2，接口3。
。
。
{ // 重写接口中所有抽象方法【必须】，当然如果实现类是抽象类，那么可以不重写 // 重写接口中默认方法【可选】 }

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。
如果抽象方法有重名的，只须要重写一次。

定义多个接口：

package com.atguigu.interfacetype; public interface A { void showA(); void show(); }

package com.atguigu.interfacetype; public interface B extends A { void showB(); void show(); }

定义实现类：

package com.atguigu.interfacetype; public class C implements A,B { @Override public void showA() { System.out.println("showA"); } @Override public void showB() { System.out.println("showB"); } @Override public void show() { System.out.println("show"); } }

测试类

package com.atguigu.interfacetype; public class TestC { public static void main(String[] args) { C c = new C(); c.showA(); c.showB(); c.show(); } }

一个接口能继续另一个或者多个接口，接口的继续也利用 extends 关键字，子接口继续父接口的方法。

定义父接口：

package com.atguigu.interfacetype; public interface Chargeable { void charge(); void in(); void out(); }

定义子接口：

package com.atguigu.interfacetype; public interface UsbC extends Chargeable,Usb3 { void reverse(); }

定义子接口的实现类：

package com.atguigu.interfacetype; public class TypeCConverter implements UsbC { @Override public void reverse() { System.out.println("正反面都支持"); } @Override public void charge() { System.out.println("可充电"); } @Override public void in() { System.out.println("吸收数据"); } @Override public void out() { System.out.println("输出数据"); } }

所有父接口的抽象方法都有重写。

方法署名相同的抽象方法只须要实现一次。

实现类实现接口，类似于子类继续父类，因此，接口类型的变量与实现类的工具之间，也可以构成多态引用。
通过接口类型的变量调用方法，终极实行的是你new的实现类工具实现的方法体。

接口的不同实现类：

package com.atguigu.interfacetype; public class Mouse implements Usb3 { @Override public void out() { System.out.println("发送脉冲旗子暗记"); } @Override public void in() { System.out.println("不吸收旗子暗记"); } }

package com.atguigu.interfacetype; public class KeyBoard implements Usb3{ @Override public void in() { System.out.println("不吸收旗子暗记"); } @Override public void out() { System.out.println("发送按键旗子暗记"); } }

测试类

package com.atguigu.interfacetype; public class TestComputer { public static void main(String[] args) { Computer computer = new Computer(); Usb3 usb = new Mouse(); computer.setUsb(usb); usb.start(); usb.out(); usb.in(); usb.stop(); System.out.println("--------------------------"); usb = new KeyBoard(); computer.setUsb(usb); usb.start(); usb.out(); usb.in(); usb.stop(); System.out.println("--------------------------"); usb = new MobileHDD(); computer.setUsb(usb); usb.start(); usb.out(); usb.in(); usb.stop(); } }

当一个类，既继续一个父类，又实现多少个接口时，父类中的成员方法与接口中的抽象方法重名，子类就近选择实行父类的成员方法。
代码如下：

定义接口：

package com.atguigu.interfacetype; public interface Friend { default void date(){//约会 System.out.println("吃喝玩乐"); } }

定义父类：

package com.atguigu.interfacetype; public class Father { public void date(){//约会 System.out.println("爸爸约用饭"); } }

定义子类：

package com.atguigu.interfacetype; public class Son extends Father implements Friend { @Override public void date() { //(1)不重写默认保留父类的 //(2)调用父类被重写的 // super.date(); //(3)保留父接口的 // Friend.super.date(); //(4)完备重写 System.out.println("学Java"); } }

定义测试类：

package com.atguigu.interfacetype; public class TestSon { public static void main(String[] args) { Son s = new Son(); s.date(); } }

•当一个类同时实现了多个父接口，而多个父接口中包含方法署名相同的默认方法时，怎么办呢？

无论你多难决议，终极都是要做出选择的。

声明接口：

package com.atguigu.interfacetype; public interface BoyFriend { default void date(){//约会 System.out.println("神秘约会"); } }

选择保留个中一个，通过“接口名.super.方法名”的方法选择保留哪个接口的默认方法。

package com.atguigu.interfacetype; public class Girl implements Friend,BoyFriend{ @Override public void date() { //(1)保留个中一个父接口的 // Friend.super.date(); // BoyFriend.super.date(); //(2)完备重写 System.out.println("学Java"); } }

测试类

package com.atguigu.interfacetype; public class TestGirl { public static void main(String[] args) { Girl girl = new Girl(); girl.date(); } }

•当一个子接口同时继续了多个接口，而多个父接口中包含方法署名相同的默认方法时，怎么办呢？

另一个父接口：

package com.atguigu.interfacetype; public interface Usb2 { //静态常量 long MAX_SPEED = 6010241024;//60MB/s //抽象方法 void in(); void out(); //默认方法 public default void start(){ System.out.println("开始"); } public default void stop(){ System.out.println("结束"); } //静态方法 public static void show(){ System.out.println("USB 2.0可以高速地进行读写操作"); } }

子接口：

package com.atguigu.interfacetype; public interface Usb extends Usb2,Usb3 { @Override default void start() { System.out.println("Usb.start"); } @Override default void stop() { System.out.println("Usb.stop"); } }

小贴士：

子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

•当子类继续父类又实现父接口，而父类中存在与父接口常量同名的成员变量，并且该成员变量名在子类中仍旧可见。

•当子类同时继续多个父接口，而多个父接口存在相同同名常量。

此时在子类中想要引用父类或父接口的同名的常量或成员变量时，就会有冲突问题。

父类和父接口：

package com.atguigu.interfacetype; public class SuperClass { int x = 1; }

package com.atguigu.interfacetype; public interface SuperInterface { int x = 2; int y = 2; }

package com.atguigu.interfacetype; public interface MotherInterface { int x = 3; }

子类：

package com.atguigu.interfacetype; public class SubClass extends SuperClass implements SuperInterface,MotherInterface { public void method(){ // System.out.println("x = " + x);//模糊不清 System.out.println("super.x = " + super.x); System.out.println("SuperInterface.x = " + SuperInterface.x); System.out.println("MotherInterface.x = " + MotherInterface.x); System.out.println("y = " + y);//没有重名问题，可以直接访问 } }

•接口本身不能创建工具，只能创建接口的实现类工具，接口类型的变量可以与实现类工具构成多态引用。

•声明接口用interface，接口的成员声明有限定：（1）公共的静态常量（2）公共的抽象方法（3）公共的默认方法（4）公共的静态方法（5）私有方法（JDK1.9以上）

•类可以实现接口，关键字是implements，而且支持多实现。
如果实现类不是抽象类，就必须实现接口中所有的抽象方法。
如果实现类既要继续父类又要实现父接口，那么继续（extends）在前，实现（implements）在后。

•接口可以继续接口，关键字是extends，而且支持多继续。

•接口的默认方法可以选择重写或不重写。
如果有冲突问题，另行处理。
子类重写父接口的默认方法，要去掉default，子接口重写父接口的默认方法，不要去掉default。

•接口的静态方法不能被继续，也不能被重写。
接口的静态方法只能通过“接口名.静态方法名”进行调用。

1、什么是内部类？

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

2、为什么要声明内部类呢？

总的来说，遵照高内聚低耦合的面向工具开拓总原则。
便于代码掩护和扩展。

详细来说，当一个事物的内部，还有一个部分须要一个完全的构造进行描述，而这个内部的完全的构造又只为外部事物供应做事，不在其他地方单独利用，那么全体内部的完全构造最好利用内部类。
而且内部类由于在外部类的里面，因此可以直接访问外部类的私有成员。

3、内部类都有哪些形式？

根据内部类声明的位置（犹如变量的分类），我们可以分为：

（1）成员内部类：

•静态成员内部类

•非静态成员内部类

（2）局部内部类

•有名字的局部内部类

•匿名的内部类

如果成员内部类中不该用外部类的非静态成员，那么常日将内部类声明为静态内部类，否则声明为非静态内部类。

语法格式：

【润色符】 class 外部类{ 【其他润色符】 【static】 class 内部类{ } }

有static润色的成员内部类叫做静态内部类。
它的特点：

•和其他类一样，它只是定义在外部类中的另一个完全的类构造

–可以继续自己的想要继续的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关

–可以在静态内部类中声明属性、方法、布局器等构造，包括静态成员

–可以利用abstract润色，因此它也可以被其他类继续

–可以利用final润色，表示不能被继续

–编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名和$符号。

•和外部类不同的是，它可以许可四种权限润色符：public，protected，缺省，private

–外部类只许可public或缺省的

•只可以在静态内部类中利用外部类的静态成员

–在静态内部类中不能利用外部类的非静态成员哦

–如果在内部类中有变量与外部类的静态成员变量同名，可以利用“外部类名.”进行差异

•在外部类的表面不须要通过外部类的工具就可以创建静态内部类的工具（常日该当避免这样利用）

实在严格的讲（在James Gosling等人编著的《The Java Language Specification》）静态内部类不是内部类，而是类似于C++的嵌套类的观点，外部类仅仅是静态内部类的一种命名空间的限定名形式而已。
以是接口中的内部类常日都不叫内部类，由于接口中的内部成员都是隐式是静态的（即public static)。
例如：Map.Entry。

没有static润色的成员内部类叫做非静态内部类。
非静态内部类的特点：

•和其他类一样，它只是定义在外部类中的另一个完全的类构造

–可以继续自己的想要继续的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关

–可以在非静态内部类中声明属性、方法、布局器等构造，但是不许可声明静态成员，但是可以继续父类的静态成员，而且可以声明静态常量。

–可以利用abstract润色，因此它也可以被其他类继续

–可以利用final润色，表示不能被继续

–编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名和$符号。

•和外部类不同的是，它可以许可四种权限润色符：public，protected，缺省，private

–外部类只许可public或缺省的

•还可以在非静态内部类中利用外部类的所有成员，哪怕是私有的

•在外部类的静态成员中不可以利用非静态内部类哦

–就犹如静态方法中不能访问本类的非静态成员变量和非静态方法一样

•在外部类的表面必须通过外部类的工具才能创建非静态内部类的工具（常日该当避免这样利用）

–如果要在外部类的表面利用非静态内部类的工具，常日在外部类中供应一个方法来返回这个非静态内部类的工具比较得当

–因此在非静态内部类的方法中有两个this工具，一个是外部类的this工具，一个是内部类的this工具

package com.atguigu.inner.member; public class TestMemberInnerClass { public static void main(String[] args) { Outer.outMethod(); System.out.println("-----------------------"); Outer out = new Outer(); out.outFun(); System.out.println("####################################"); Outer.Inner.inMethod(); System.out.println("------------------------"); Outer.Inner inner = new Outer.Inner(); inner.inFun(); System.out.println("####################################"); Outer outer = new Outer(); // Outer.Nei nei = outer.new Nei(); Outer.Nei nei = out.getNei(); nei.inFun(); } } class Outer{ private static String a = "外部类的静态a"; private static String b = "外部类的静态b"; private String c = "外部类工具的非静态c"; private String d = "外部类工具的非静态d"; static class Inner{ private static String a ="静态内部类的静态a"; private String c = "静态内部类工具的非静态c"; public static void inMethod(){ System.out.println("Inner.inMethod"); System.out.println("Outer.a = " + Outer.a); System.out.println("Inner.a = " + a); System.out.println("b = " + b); // System.out.println("c = " + c);//不能访问外部类和自己的非静态成员 // System.out.println("d = " + d);//不能访问外部类的非静态成员 } public void inFun(){ System.out.println("Inner.inFun"); System.out.println("Outer.a = " + Outer.a); System.out.println("Inner.a = " + a); System.out.println("b = " + b); System.out.println("c = " + c); // System.out.println("d = " + d);//不能访问外部类的非静态成员 } } class Nei{ private String a = "非静态内部类工具的非静态a"; private String c = "非静态内部类工具的非静态c"; public void inFun(){ System.out.println("Nei.inFun"); System.out.println("Outer.a = " + Outer.a); System.out.println("a = " + a); System.out.println("b = " + b); System.out.println("Outer.c = " + Outer.this.c); System.out.println("c = " + c); System.out.println("d = " + d); } } public static void outMethod(){ System.out.println("Outer.outMethod"); System.out.println("a = " + a); System.out.println("Inner.a = " + Inner.a); System.out.println("b = " + b); // System.out.println("c = " + c); // System.out.println("d = " + d); Inner in = new Inner(); System.out.println("in.c = " + in.c); } public void outFun(){ System.out.println("Outer.outFun"); System.out.println("a = " + a); System.out.println("Inner.a = " + Inner.a); System.out.println("b = " + b); System.out.println("c = " + c); System.out.println("d = " + d); Inner in = new Inner(); System.out.println("in.c = " + in.c); } public Nei getNei(){ return new Nei(); } }

语法格式：

【润色符】 class 外部类{ 【润色符】 返回值类型 方法名(【形参列表】){ 【final/abstract】 class 内部类{ } } }

局部内部类的特点：

•和外部类一样，它只是定义在外部类的某个方法中的另一个完全的类构造

–可以继续自己的想要继续的父类，实现自己想要实现的父接口们，和外部类的父类和父接口无关

–可以在局部内部类中声明属性、方法、布局器等构造，但不包括静态成员，除非是从父类继续的或静态常量

–可以利用abstract润色，因此它也可以被同一个方法的在它后面的其他内部类继续

–可以利用final润色，表示不能被继续

–编译后有自己的独立的字节码文件，只不过在内部类名前面冠以外部类名、$符号、编号。

•这里有编号是由于同一个外部类中，不同的方法中存在相同名称的局部内部类

•和成员内部类不同的是，它前面不能有权限润色符等

•局部内部类犹如局部变量一样，有浸染域

•局部内部类中是否能访问外部类的静态还是非静态的成员，取决于所在的方法

•局部内部类中还可以利用所在方法的局部常量，即用final声明的局部变量

–JDK1.8之后，如果某个局部变量在局部内部类中被利用了，自动加final

–为什么在局部内部类中利用外部类方法的局部变量要加final呢？考虑生命周期问题。

示例代码：

package com.atguigu.inner.local; public class TestLocalInner { public static void main(String[] args) { Runner runner = Outer.getRunner(); runner.run(); System.out.println("-------------------"); Outer.outMethod(); System.out.println("-------------------"); Outer out = new Outer(); out.outTest(); } } class Outer{ private static String a = "外部类的静态a"; private String b = "外部类工具的非静态b"; public static void outMethod(){ System.out.println("Outer.outMethod"); final String c = "局部变量c"; class Inner{ public void inMethod(){ System.out.println("Inner.inMethod"); System.out.println("out.a = " + a); // System.out.println("out.b = " + b);//缺点的，由于outMethod是静态的 System.out.println("out.local.c = " + c); } } Inner in = new Inner(); in.inMethod(); } public void outTest(){ class Inner{ public void inMethod(){ System.out.println("out.a = " + a); System.out.println("out.b = " + b);//可以，由于outTest是非静态的 } } Inner in = new Inner(); in.inMethod(); } public static Runner getRunner(){ class LocalRunner implements Runner{ @Override public void run() { System.out.println("LocalRunner.run"); } } return new LocalRunner(); } } interface Runner{ void run(); }

当我们在开拓过程中，须要用到一个抽象类的子类的工具或一个接口的实现类的工具，而且只创建一个工具，而且逻辑代码也不繁芜。
那么我们原来怎么做的呢？

（1）编写类，继续这个父类或实现这个接口

（2）重写父类或父接口的方法

（3）创建这个子类或实现类的工具

这里，由于考虑到这个子类或实现类是一次性的，那么我们“费尽心机”的给它取名字，就显得多余。
那么我们完备可以利用匿名内部类的办法来实现，避免给类命名的问题。

new 父类(【实参列表】){ 重写方法... } //()中是否须要【实参列表】，看你想要让这个匿名内部类调用父类的哪个布局器，如果调用父类的无参布局，那么()中就不用写参数，如果调用父类的有参布局，那么()中须要传入实参

new 父接口(){ 重写方法... } //()中没有参数，由于此时匿名内部类的父类是Object类，它只有一个无参布局

匿名内部类是没有名字的类，因此在声明类的同时就创建好了唯一的工具。

把稳：

匿名内部类是一种分外的局部内部类，只不过没有名称而已。
所有局部内部类的限定都适用于匿名内部类。
例如：

•在匿名内部类中是否可以利用外部类的非静态成员变量，看所在方法是否静态

•在匿名内部类中如果须要访问当前方法的局部变量，该局部变量须要加final

思考：这个工具能做什么呢？

（1）利用匿名内部类的工具直接调用方法

interface A{ void a(); } public class Test{ public static void main(String[] args){ new A(){ @Override public void a() { System.out.println("aaaa"); } }.a(); } }

（2）通过父类或父接口的变量多态引用匿名内部类的工具

interface A{ void a(); } public class Test{ public static void main(String[] args){ A obj = new A(){ @Override public void a() { System.out.println("aaaa"); } }; obj.a(); } }

（3）匿名内部类的工具作为实参

interface A{ void method(); } public class Test{ public static void test(A a){ a.method(); } public static void main(String[] args){ test(new A(){ @Override public void method() { System.out.println("aaaa"); } }); } }

表明因此“@注释名”在代码中存在的，还可以添加一些参数值，例如：

@SuppressWarnings(value=”unchecked”) @Override @Deprecated

表明Annotation是从JDK5.0开始引入。

虽然说表明也是一种注释，由于它们都不会改变程序原有的逻辑，只是对程序增加了某些注释性信息。
不过它又不同于单行注释和多行注释，对付单行注释和多行注释是给程序员看的，而表明是可以被编译器或其他程序读取的一种注释，程序还可以根据表明的不同，做出相应的处理。
以是表明是插入到代码中以便有工具可以对它们进行处理的标签。

用于检测被润色的方法为有效的重写方法，如果不是，则报编译缺点!

只能标记在方法上。

它会被编译器程序读取。

用于表示被标记的数据已经由时，不建议利用。

可以用于润色 属性、方法、布局、类、包、局部变量、参数。

它会被编译器程序读取。

抑制编译警告。

可以用于润色类、属性、方法、布局、局部变量、参数

它会被编译器程序读取。

示例代码：

package com.atguigu.annotation; import java.util.ArrayList; public class TestAnnotation { @SuppressWarnings("all") public static void main(String[] args) { int i; ArrayList list = new ArrayList(); list.add("hello"); list.add(123); list.add("world"); Father f = new Son(); f.show(); f.methodOl(); } } class Father{ @Deprecated void show() { System.out.println("Father.show"); } void methodOl() { System.out.println("Father Method"); } } class Son extends Father{ / @Override void method01() { System.out.println("Son Method"); }/ }

JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）,供Java开拓职员编写单元测试之用。
多数Java的开拓环境都已经集成了JUnit作为单元测试的工具。
JUnit测试是程序员测试，即所谓白盒测试，由于程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。

要利用JUnit，必须在项目的编译路径中必须引入JUnit的库，即干系的.class文件组成的jar包。
如何把JUnit的jar添加到编译路径如图所示：

后面会学习maven，在maven仓库中统一管理所有第三方框架和工具组件的jar，但是现在没有学习maven之前，可以利用本地jar包。

第一步：在当前IDEA项目目录下建立junitlibs，把下载的JUnit的干系jar包放进去：

第二步：在项目中添加Libraries库

第三步：选择要在哪些module中运用JUnit库

第四步：检讨是否运用成功

把稳Scope：选择Complie，否则编译时，无法利用JUnit。

第5步：下次如果有新的模块要利用该libs库，这样操作即可

2、编写和运行@Test单元测试方法

JUnit4版本，哀求@Test标记的方法必须知足如下哀求：

•所在的类必须是public的，非抽象的，包含唯一的无参布局的。

•@Test标记的方法本身必须是public，非抽象，非静态的，void无返回值，()无参数的。

package com.atguigu.junit; import org.junit.Test; public class TestJUnit { @Test public void test01(){ System.out.println("TestJUnit.test01"); } @Test public void test02(){ System.out.println("TestJUnit.test02"); } @Test public void test03(){ System.out.println("TestJUnit.test03"); } }

3、设置实行JUnit用例时支持掌握台输入

在idea64.exe.vmoptions配置文件中加入下面一行设置，重启idea后生效。

须要把稳的是，要看你当前IDEA读取的是哪个idea64.exe.vmoptions配置文件文件。
如果在C盘的用户目录的config下（例如：C:\.IntelliJIdea2019.2）也有一个idea64.exe.vmoptions文件，那么将优先利用C盘用户目录下的。
否则用的是IDEA安装目录的bin目录（例如：D:_IDEA_2019.2.3）下的idea64.exe.vmoptions文件。

-Deditable.java.test.console=true