精华内容
下载资源
问答
  • interface关键字的使用

    2019-12-16 16:55:57
    interface能用来修饰的只要类 interface在jdk7及以前的使用 1.在jdk7中interface只能有全局变量和抽象方法 2.全局变量默认为 public static final 3.抽象方法默认为 public abstract 4.接口中无法定义构造器 ,意味...

    interface能用来修饰的只要类

    interface在jdk7及以前的使用
    1.在jdk7中interface只能有全局变量和抽象方法
    2.全局变量默认为 public static final
    3.抽象方法默认为 public abstract
    4.接口中无法定义构造器 ,意味着接口无法实例化。
    5.接口的使用,使用 implements 来实现该接口(如果实现类覆盖了接口中的所有抽象方法,那么此类就是一个普通的类,则此实现类就可以实例化,如果实现类没有覆盖接口中所有的抽象方法,则此实现类仍为一个抽象类)
    6.Java中接口是多实现的

    interface  A{
        public abstract void getMethodA();
    }
    
    interface  B{
        public abstract void getMethodB();
        
    }
    
    class c implements A,B{
    
        @Override
        public void getMethodA() {
            
        }
    
        @Override
        public void getMethodB() {
            
        }
    }
    

    6.如果在一个类中需要同时继承一个类实现一个或者多个接口时,继承(extends)要写在实现(implements)的前面
    在这里插入图片描述
    7.类和类之间可以继承,类和接口之间可以实现,接口和接口之间也是可以继承的,并且该继承可以是多继承

    interface  D{
        public abstract void getMethodD();
    }
    
    interface  E{
        public abstract void getMethodE();
    
    }
    
    //  接口之间的多继承
    interface F extends D,E{
    
    }
    

    interface在jdk8的使用
    1.interface关键字在jdk8版本当中除了可以定义全局变量和抽象方法之外,还可以定义静态方法和默认方法

    interface  InterfaceJava8Test1{
        //  静态方法
        public static void getStaticMethod1(){
            System.out.println("InterfaceJava8Test1的静态方法");
        }
    
        //  默认方法
        public default void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test1的默认方法");
        }
    }
    

    2.再默认方法中如果不使用访问修饰符修饰符默认为public修饰符,而不是default修饰符 提示内容:修饰符public对于interface修饰的是多余的
    在这里插入图片描述
    3.接口中的静态方法和默认方法实现类中不需要继续方法的覆盖

    
    interface  InterfaceJava8Test1{
        //  静态方法
        public static void getStaticMethod1(){
            System.out.println("InterfaceJava8Test1的静态方法");
        }
    
        //  默认方法
        public default void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test1的默认方法");
        }
    
    }
    // 	实现类 
    class InterfaceJava8Test2 implements InterfaceJava8Test1{
    
    }
    

    4.接口中静态方法,实现类无法调用,它只能由接口本身调用
    在这里插入图片描述
    5.实现类的对象可以直接调用接口中的默认方法,并且接口本身无法调用自身的默认方法
    在这里插入图片描述
    6.实现了可以重写接口中的默认方法,再调用时,调用的为该类重写后的方法
    7.如果子类或者实现类中继承的父类和实现接口中声明的同名同参数的方法一样,并且再其子类或者父类没有进行方法重写覆盖时,默认调用的是该父类中的方法 (只适用于方法,不适用于属性)

    public class InterfaceJava8 {
        public static void main(String[] args)
        {
            InterfaceJava8Test2 in2=new InterfaceJava8Test2();
    //        in2.getStaticMethod1(); //静态方法无法实现类来调用 只能由接口本身来调用
            in2.getDefaultMethod2();
            InterfaceJava8Test1.getStaticMethod1(); //  接口本身调用静态方法
    //        InterfaceJava8Test1.getDefaultMethod2(); //接口本身无法调用自身的默认方法
            in2.getDefaultMethod3();  // 输出结果为父类中的结果
    
        }
    
    }
    
    interface  InterfaceJava8Test1{
        //  静态方法
        public static void getStaticMethod1(){
            System.out.println("InterfaceJava8Test1的静态方法");
        }
    
        //  默认方法
        public   default  void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test1的默认方法");
        }
    
        public  default void getDefaultMethod3(){
            System.out.println("InterfaceJava8Test1的默认方法2");
        }
    
    }
    
    class InterfaceJava8Test2   extends InterfaceJava8Super  implements InterfaceJava8Test1{
    
        public     void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test2的默认方法");
        }
    
    }
    
    class InterfaceJava8Super{
        //  同名同参数的方法
        public   void getDefaultMethod3(){
            System.out.println("InterfaceJava8Super中的方法");
        }
    }
    
    

    in2.getDefaultMethod3(); 输出结果为 :InterfaceJava8Super中的方法
    8.如果实现类中实现了多个接口,并且多个接口中有相同的默认方法,而且实现类没有继承父类,或者说父类中没有声明和该接口同名同参数的方法,那么实现类必须重写接口中相同的多个默认方法 (接口冲突)

    如下接口 InterfaceJava8Test1和接口InterfaceJava8Test3中有同名同参数的方法,并且InterfaceJava8Test2同时实现了该二个接口,默认情况下接口中的默认方法可以不写,当时同时继承了二个接口,并且该方法相同,再调用的时候不知道调用的是那个接口中的默认方法,所以子类InterfaceJava8Test2必须重写这个方法,然后调用该方法时,得到的将是子类重写的方法

    interface  InterfaceJava8Test1{
        //  静态方法
        public static void getStaticMethod1(){
            System.out.println("InterfaceJava8Test1的静态方法");
        }
    
        //  默认方法
        public   default  void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test1的默认方法");
        }
    
        public  default void getDefaultMethod3(){
            System.out.println("InterfaceJava8Test1的默认方法2");
        }
    
    }
    
    interface  InterfaceJava8Test3{
        public  default void getDefaultMethod3(){
            System.out.println("InterfaceJava8Test1的默认方法2");
        }
    
    }
    
    class InterfaceJava8Test2   implements InterfaceJava8Test1,InterfaceJava8Test3{
    
        public     void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test2的默认方法");
        }
    
        @Override
        public void getDefaultMethod3()
        {
            
        }
    
    }
    

    9.再实现类中怎么得到接口中的原默认方法 格式:接口名.super.默认方法名

    interface  InterfaceJava8Test1{
        //  静态方法
        public static void getStaticMethod1(){
            System.out.println("InterfaceJava8Test1的静态方法");
        }
    
        //  默认方法
        public   default  void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test1的默认方法");
        }
    
        public  default void getDefaultMethod3(){
            System.out.println("InterfaceJava8Test1的默认方法2");
        }
    
    }
    
    class InterfaceJava8Test2   implements InterfaceJava8Test1{
    
        public     void getDefaultMethod2(){
            System.out.println("InterfaceJava8Test2的默认方法");
        }
    
        public void myMethod(){
            InterfaceJava8Test1.super.getDefaultMethod3(); //   得到InterfaceJava8Test1中的getDefaultMethod3方法
        }
    
    }
    
    展开全文
  • interface接口的修饰关键字

    千次阅读 2020-10-13 12:10:43
    interface接口方法 默认的修饰符是 public abstract;...2.在JDK1.8中,接口可以使用default关键字定义非抽象方法,实现该接口的时候不用实现非抽象方法,当然你也可以选择重写。 public interface Main{ de

    interface接口的修饰符

    可以用public修饰,或者使用默认的修饰符(不写修饰符),但是不可以使用private或者protected修饰

    interface接口方法

    默认的修饰符是 public abstract;不可以使用private或者protected修饰。
    备注:
    1.在JDK1.8中,接口可以定义静态方法,可以直接用接口名调用。

    public interface Main{	
    	static int ss() {
    		return 0;
    	}
    }
    

    2.在JDK1.8中,接口可以使用default关键字定义非抽象方法,实现该接口的时候不用实现非抽象方法,当然你也可以选择重写。

    public interface Main{	
    	default int ss() {
    		return 0;
    	}
    }
    

    interface变量属性

    默认的修饰符是 public static final

    展开全文
  • interface关键字

    千次阅读 2017-12-26 18:03:48
    interface关键字 1. 当一个类所有的方法都是抽象方法,那么我们可以将这个抽象类用另外一种形式定义。 ----接口 2. 接口中只能定义常量和抽象方法。 3. 接口的修饰符: public 和 默认不写 4. 接口中的成员都有...
    interface关键字
    1. 当一个类所有的方法都是抽象方法,那么我们可以将这个抽象类用另外一种形式定义。
    ----接口
    2. 接口中只能定义常量和抽象方法。
    3. 接口的修饰符: public 和 默认不写
    4. 接口中的成员都有默认的访问控制修饰符
    全局常量: public static final
    方法: public abstract
    在接口中定义抽象方法,abstract关键字可以不写。
    5. 在接口中的成员都是公共的权限(public)
    6. 接口不能被实例化。
    子类实现接口,并实现接口中所有的抽象方法,那么该子类才可以实例化对象。
    7. 一类可以实现多个接口。那么这个类必须实现所有接口中的抽象方法。
    8. 实现接口,使用 implements
    9. 一个类只能继承一个父类
    一个接口可以继承多个父接口
    一个类可以实现多个接口
    展开全文
  • 接口interface关键字的基础语法 1.接口也是一种引用数据类型。编译之后也是一个class字节码文件。 2.接口是完全抽象的。抽象类是半抽象的,或者也可以说接口是一种特殊的抽象类。 3.接口怎么定义? [修饰符列表] ...

    接口interface关键字的基础语法:

    1、接口也是一种引用数据类型,编译之后也是一个class字节码文件

    2、接口是完全抽象的,抽象类是半抽象的,或者也可以说接口是一种特殊的抽象类。

    3、接口怎么定义?
    [修饰符列表] interface 接口名{ }

    4、接口中所有的元素都是用public修饰的,都是公开的。

    5、接口中只有两部分内容:
    常量(public final static修饰的变量)
    抽象方法(public abstract修饰的方法)

    附提:java8新特性,让接口内容更多。

    6、接口中的方法都是抽象方法,抽象方法不能有方法体。

    7、接口中的常量都是public final static修饰的,抽象方法都是public abstract修饰的,修饰符可以省略不写

    8、接口支持多继承,一个接口可以继承多个接口。

    9、类与类之间叫做继承,接口与接口之间也叫继承,那么类与接口之间叫什么关系?

    答:我们称类与接口的关系为”实现“,接口不能实现类,只能类去实现接口,一个类可以实现多个接口。这种机制弥补了java中类只能单继承的缺陷


    如何理解类“实现”接口?
    答:我们先把接口理解为一种特殊的抽象类,类“实现”多个接口,相当于这个类 “特殊的继承(实现)” 了多个 “特殊的抽象类(接口)”。

    继承使用extends关键字,实现使用implements关键字。


    10、非抽象类继承抽象类,必须重写父类的所有抽象方法。
    非抽象类实现接口,必须实现接口的所有抽象方法

    所以抽象类实现接口,可以实现接口的抽象方法,也可以不实现。因为抽象方法可以在出现抽象类里面,实际上抽象方法就是只能在抽象类中。

    如果抽象类实现了接口的抽象方法,则抽象类的子类无需再重写。没实现的抽象方法,抽象类的子类一定得重写,不重写会报错。

    测试代码:

    public class Test {
        public static void main(String[] args) {
            //访问接口的常量,接口可以理解为一种特殊的抽象类,直接使用“接口名.”访问
            System.out.println("π = " + MyMath.PI);
            System.out.println("e = " + MyMath.E);
    
            //把接口理解成一种特殊的抽象类,那可以使用多态吗?可以,并且以后开发就是这么写代码的。
            //多态:父类型引用指向子类型对象,鹦鹉算数
            MyMath m1 = new Parrot();
            int res1 = m1.add(10, 20);
            int res2 = m1.sub(10, 20);
            System.out.println("a = " + res1 + ", b = " + res2);
    
            //多态:人算数
            MyMath m2 = new Person();
            int res3 = m2.add(10, 20);
            int res4 = m2.sub(10, 20);
            System.out.println("a = " + res3 + ", b = " + res4);
        }
    }
    
    //定义一个接口M1
    interface M1 {
    
    }
    
    //定义一个接口M2
    interface M2 {
    
    }
    
    //定义一个MyMath接口
    interface MyMath extends M1, M2 {
        //常量:圆周率PI
        public final static double PI = 3.1415926;
    
        //常量:自然对数的底数E
        double E = 2.718281828;  //接口中常量的public final static可以省略
    
        //抽象方法:加add
        public abstract int add(int a, int b);
    
        //抽象方法:减sub
        int sub(int a, int b);  //接口中抽象方法的public abstract可以省略
    }
    
    //定义一个人的类,实现M1,M2,MyMath接口
    class Person implements M1, M2, MyMath{
        @Override
        public int add(int a, int b) {
            return a + b;
        }
    
        @Override
        public int sub(int a, int b) {
            return a - b;
        }
    }
    
    //定义一个抽象鸟类,实现MyMath接口
    abstract class Bird implements MyMath{
        //抽象类Bird实现了MyMath的sub方法,Bird的子类不需要再重写
        public int sub(int a, int b) {
            return a - b;
        }
    
        //抽象类Bird没有实现MyMath的add方法,就必须留给Bird的子类实现。
        //抽象类中没实现接口的方法相当于继承过来了
        public abstract int add(int a, int b);
    }
    
    //定义一个鹦鹉类,继承抽象类Bird
    class Parrot extends Bird {
    
        public int add(int a, int b) {  //重写父类的抽象方法
            return a + b;
        }
    
    }
    

    接口看成一种特殊的抽象类,故也存在多态语法:

    测试代码

    public class Test02 {
        public static void main(String[] args) {
            /*D d = new D();
            d.m1();  //输出:m1()方法实现
            d.m2();  //输出:m2()方法实现*/
    
            //运用多态:父类型的引用指向子类型的对象
            //先测试一下接口与接口之间的转换关系
            A a = new D();
            B b = (B)a;  //此行编译通过,所以得出结论,java编译中允许没有继承关系的两个接口之间强制转换。
            //为什么?答:因为在编译时不实例化对象,编译器不知道a1指向的是什么类对象,万一这个类实现了这两个接口,这两个接口之间就可以强制转换,所有编译器认定所有两个接口之间都能强制转换。
            //C c = (C)a;  //此行编译通过,但运行时报错:ClassCastException: class D cannot be cast to class C (D and C are in unnamed module of loader 'app')
            //虽然java中允许没有继承关系的两个接口之间强制转换,但运行时可能出现ClassCastException,为防止这种情况,建议使用instanceof判断
            //上面两行转型代码应该这样写
            if (a instanceof B) {
    
            }
            if (a instanceof C) {
    
            }
    
            //现在我们再来测试接口的多态
            //D类实现了2个接口A,B,相当于父类型有2个,那怎么用多态?
            //第一种:A类型接口指向D类型引用
            A a1 = new D();
            //a1.m1();  //输出:m1()方法实现
            //a1.m2();  //编译报错:a1里找不到m2()方法,如果a1想调用a2方法,可以转换接口或者向下转型成D,下面再讲
            //第二种:B类型接口指向D类型引用
            //B b1 = new D();
            //b1.m2();  //输出:m2()方法实现
    
            //通过向下转型:接口A a1 --> D类型,向下转型用instanceof关键字先判断
            if (a1 instanceof D) {  //条件为true,因为a1指向的堆对象是D类型
                D d1 = (D) a1;
                //d1.m1();  //输出:m1()方法实现
                //d1.m2();  //输出:m2()方法实现
            }
    
            //接口A a1 --> B接口型
            if (a1 instanceof B) {  //条件为true,因为a1指向的堆对象是D类型,D类型实现(继承)了B接口,D属于B,条件成立
                B b1 = (B)a1;
                b1.m2();  //输出:m2()方法实现
            }
            //试一下A a1接口能不能 --> C接口
            if (a1 instanceof C) {  //条件不成立,因为a1指向的堆对象是D类型,D类型没有实现(继承)B接口,D不属于B,条件不成立
                C c1 = (C)a1;
                c1.m3();  //条件不成立,里面代码不执行,没输出
            }
    
        }
    }
    
    //接口A
    interface A {
        void m1();
    }
    
    //接口B
    interface B {
        void m2();
    }
    
    //接口C
    interface C {
        void m3();
    }
    
    //类D,实现了接口A,B
    class D implements A, B{
        @Override
        public void m1() {
            System.out.println("m1()方法实现");
        }
    
        @Override
        public void m2() {
            System.out.println("m2()方法实现");
        }
    
    }
    

    不同的类实现同一接口会有不同的作用:

    测试代码:

    /*
    * 继承和实现都存在的话,代码应该怎么写
    *   extends关键字在前,implements关键字在后,例如:class B extends A implements C1, C2 { }
    *
    * */
    public class Test03 {
        public static void main(String[] args) {
            Wings w1 = new Duck();
            w1.fly();
    
            Wings w2 = new Cat();
            w2.fly();
        }
    }
    
    //定义一个接口:Wings(翅膀)
    interface Wings {
        void fly();
    }
    
    //定义一个类:Animal(动物)
    class Animal {
    
    }
    
    //定义一个子类:Duck(鸭子)
    class Duck extends Animal implements Wings {
        @Override
        public void fly() {
            System.out.println("有了翅膀接口,我就是一只会飞的鸭子!");
        }
    }
    
    //定义一个子类:Cat(猫)
    class Cat extends Animal implements Wings {
        @Override
        public void fly() {
            System.out.println("有了翅膀接口,我就是一只会飞的猫!");
        }
    }
    

    ————————————————————————————
    总结:

    1、接口是一种引用数据类型,编译之后也产生“.class”文件。

    2、接口是完全抽象的,抽象类是半抽象的。

    3、接口怎么定义:[访问修饰符] interface 接口名 { }

    4、接口支持多继承,一个接口可以继承多个接口。

    5、接口中的元素都是公开的,都是public修饰的。

    6、接口中只有常量(public final static修饰)和抽象方法(public abstract)。

    7、接口中常量的public final static,抽象方法的public abstract修饰符都可省略不写

    8、接口中的抽象方法不能有方法体

    9、一个非抽象类实现接口时,必须将接口中所有抽象方法重写

    10、一个类可以同时实现多个接口。

    11、一个类继承父类,同时实现接口时,extends在前,implements在后

    12、接口也存在多态的使用:父类型的接口引用变量指向子类型对象。

    展开全文
  • 接口(interface关键字

    千次阅读 2018-07-01 11:14:32
    1. 接口 有时必须从几个类中派生出一个子类,继承...接口(interface)是抽象方法和常量值的定义的集合。 从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。 ...
  • java Interface的属性修饰关键字

    千次阅读 2019-03-14 16:23:24
    Interface里面的变量,必须由public static final 共同修饰。 int i=10;写法默认省略来以上三个关键字。 public:接口的意义是提供一种统一的规范,可以被任意class implement,所以变量被public修饰。 static:...
  • 一、接口的定义与使用 格式: (1)接口体中的抽象方法和常量 JDK8版本之前,接口体中...从JDK8版本开始,允许使用default关键字,在接口体中定义称作default的实例方法(不可以定义default的static方法),de...
  • 不能用来修饰interface修饰的方法

    万次阅读 2019-04-24 11:02:26
    不能用来修饰interface的有( )(仅限外部接口) 正确答案: A C D A private B public C protected D static 解析: 1、抽象类中的抽象方法(其前有abstract修饰)不能用private、...
  • Java之interface关键字

    2016-12-13 11:46:44
    接口是抽象方法和常量值的定义的集合 从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现 接口中的 方法默认用abstract修饰 ...public interface Run
  • 不能用来修饰interface的有

    千次阅读 2020-07-08 20:00:13
    不能用来修饰interface的有( )(仅限外部接口) 题目:不能用来修饰interface的有( )(仅限外部接口) A private B public C protected D static 题目及解析均来源于牛客,仅用于学习,侵权删 解析: 1、抽象类...
  • JAVA关键字——interface的使用(一) 1、接口的定义:用interface修饰的就是接口 public class Interface7 { public static void main(String[] args) { Plane plane = new Plane() ; plane.test(); } } //...
  • JAVA-Interface关键字

    千次阅读 2017-09-18 14:38:56
    把class 关键字换成interface 关键字即可 public interface Test{ }特点: 1:接口中所有的方法都是抽象方法。abstract关键字可以省略的。 2:所有的方法都是public修饰,也可以省略。 3:接口内的成员变量,...
  • 不能修饰接口的关键字

    千次阅读 2019-05-06 17:32:00
    接口不能用private、protected修饰,可以用final和abstract 接口里的方法不能用private、protected修饰 转载于:https://www.cnblogs.com/cn-chy-com/p/10820945.html
  • java之interface关键字

    2019-07-06 09:36:05
    接口里属性默认的修饰为:public static final,不管属性前面写没写都会 默认加上;同样方法的默认修饰为:public abstract,内部类:public static。都会默认加上。 2.接口不能被实例化。 ...
  • 2.interface关键字(接口) 3.多态 4.static(静态的) 1.abstract关键字(抽象类) 1.1对于重写的讨论 父类的方法,子类可以继承使用。但是父类的方法不一定适用于子类。或者说父类不期望子类重写这个方法。 ​ ...
  • c# 修饰关键字

    2019-02-14 15:26:00
    ,当对一个类应用 sealed 修饰符时,此修饰符会阻止其他类从该类继承。 static ,使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员。 virtual ,用于修饰方法、属性、索引器或事件声明,...
  • Java关键字我们接触的也都不少了,就以这篇文章收录下一些特殊使用的关键字,作为深入学习的记录。
  • 今天记录下c# 修饰class 的一些关键字的一些用法,不多说,每天记录笔记: 对应的代码,这里使用了接口,因为c#不支持c++中的多重继承,可以使用继承接口的形式达到多重继承的目的: using System; using System...
  • final关键字可以用来修饰变量,方法,类。 1)final的变量的值不能够被改变; 2)final的方法不能够被重写; 3)final的类不能够被继承。 下面说明一个接口--interface。 Java中通过interface来实现“多继承”...
  • 一、Virtual(虚方法修饰关键字) virtual 关键字用于在基类中修饰方法。virtual的使用会有两种情况: 情况1:在基类中定义了virtual方法,但在派生类中没有重写该虚方法。那么在对派生类实例的调用中,该虚方法...
  • 当抽象类中的方法都是抽象的时候,这时可以将该抽象类用另一种形式定义和表示,就是接口interface特点:对于接口中常见的成员:而且这些成员都有固定的修饰符,不写就默认存在1:全局常量 : 都是 public static ...
  • java8中,忽略内部接口的情况,不能用来修饰interface里的方法的有() A. private B. public C. protected D. static(jdk1.8开始,接口中可以定义静态方法了) 答案:AC Java8的接口方法可以有如下定义 only ...
  • 标识符 用来表示类名,变量名,方法名,类型名,数组名,文件名的有效字符序列称为标识符。 1)只有字母(区分大小写),...3)不能是关键字关键字。 常见的50个关键词 abstract assert boolea...
  • 修饰符与关键字

    2018-07-11 21:23:00
    访问控制符:private protected public 类、方法和变量修饰符:abstract class extends final implements interface native new static strictfp synchron...
  • 但是当抽象类中有abstract修饰的抽象方法时强制要求其继承者用override关键字重写基类中的抽象方法,抽象方法声明时不提供其自身的实现,抽象类不能被实例化。 三、interface接口 interface接口就是约束协议,不...
  • static 关键字:可以用于修饰属性,也可以用于修饰方法,还可以用于修饰 类(后面的课程讲) static 修饰属性:无论一个类生成了多少个对象,所有这些对象共同使用唯 一一份静态的成员变量;一个对象对该静态...
  • 面向对象-接口 interface关键字

    千次阅读 2017-11-28 15:10:17
    接口 (interface关键字) package lnterface; public class Interface {  public static void main(String[] args) {  Test F=new Test();//实例化子类对象  F.shwoA();//向上转型  
  • static关键字修饰什么

    万次阅读 2018-07-25 20:17:36
    static关键字是Java中常用的关键字之一,可能最常用的就是修饰变量和方法了,但是仅仅知道这些还远远不够。问题虽然很小,但是却反映了对Java的了解程度。 static修饰变量和方法 static可以修饰变量,这个变量...
  • 【定义】Java中,能够完成特定功能的...用关键字interface定义接口,通过关键字implements来实现接口; 接口中的成员变量具有公共性(public)、静态性(static)和最终性(final)。所以修饰符只能是public,因此...
  • default 这个关键字,说实话平时见到的场景很少,使用的也不多。 印象中有用到的时候,1.switch case 这个就是用在最后,所有条件都不匹配,默认进行处理; 2.自定义注解会有用到,给予一个默认值; 3. 就是咱们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,957
精华内容 33,982
关键字:

修饰interface的关键字