精华内容
下载资源
问答
  • java中的内部类内部接口详解

    千次阅读 2020-05-08 06:24:42
    一般来说,我们创建接口的时候都是一个一个文件,一个接口一个文件,但有时候为了方便或者某些特殊的原因,java并不介意在一个文件中写多个和多个接口,这就有了我们今天要讲的内部类内部接口。...

    简介

    一般来说,我们创建类和接口的时候都是一个类一个文件,一个接口一个文件,但有时候为了方便或者某些特殊的原因,java并不介意在一个文件中写多个类和多个接口,这就有了我们今天要讲的内部类和内部接口。

    内部类

    先讲内部类,内部类就是在类中定义的类。类中的类可以看做是类的一个属性,一个属性可以是static也可以是非static的。而内部类也可以定义在类的方法中,再加上匿名类,总共有5种内部类。

    静态内部类

    我们在class内部定义一个static的class,如下所示:

    @Slf4j
    public class StaticInnerClass {
    
        static class Inner {
            void print() {
                log.info("Inner class is: " + this);
            }
        }
    
        public static void main(String[] args) {
            StaticInnerClass.Inner inner = new StaticInnerClass.Inner();
            inner.print();
        }
    }
    

    因为static变量可以直接根据类名来存取,所以我们使用new StaticInnerClass.Inner()来实例化内部类。

    非静态内部类

    class中定义的类也可以是非静态的,如下所示:

    @Slf4j
    public class InnerClass {
    
         class Inner {
            void print() {
                log.info("Inner class is: " + this);
            }
        }
    
        public static void main(String[] args) {
            InnerClass.Inner inner = new InnerClass().new Inner();
            inner.print();
        }
    }
    

    要访问到类的变量,需要实例化外部内,然后再实例化内部类:new InnerClass().new Inner()。

    注意这里我们需要使用到两个new。

    静态方法内部类

    我们可以在静态方法中定义一个类,这个类其实就相当于方法中的变量,这个变量当然不能是static的。我们看下面的例子:

    @Slf4j
    public class StaticMethodInnerClass {
    
        private static String x = "static x";
    
        public static void print() {
            class MyInner {
                public void printOuter() {
                    log.info("x is " + x);
                }
            }
            MyInner i = new MyInner();
            i.printOuter();
        }
    
        public static void main(String[] args) {
            StaticMethodInnerClass.print();
        }
    }
    

    方法中的类,我们是无法在外部实例化的。

    非静态方法的内部类

    同样的非静态方法也可以定义内部类:

    @Slf4j
    public class MethodInnerClass {
    
        private  String x = "non static x";
    
        public  void print() {
            class MyInner {
                public void printOuter() {
                    log.info("x is " + x);
                }
            }
            MyInner i = new MyInner();
            i.printOuter();
        }
    
        public static void main(String[] args) {
            new MethodInnerClass().print();
        }
    }
    

    注意,这里需要先实例化外部类才可以继续调用。

    匿名类

    最后一个,匿名类,直接在需要的时候实例化的类。匿名类我们遇到了很多次了,比如在构建SortedSet的时候,可以传入自定义的Comparator,我们可以用匿名类来实现,也可以直接使用lambda表达式。

    public class AnonymousClass {
    
        public static void main(String[] args) {
            SortedSet sortedSet1 = new ConcurrentSkipListSet(new Comparator(){
                @Override
                public int compare(Object o1, Object o2) {
                    return 0;
                }
            });
    
            SortedSet sortedSet2 = new ConcurrentSkipListSet((o1, o2) -> 0);
        }
    }
    

    内部接口

    Inner Interface是指在接口中定义的接口。最常见的就是Map中的Entry了:

    public interface Map<K, V> {
        interface Entry<K, V> {
            K getKey();
        }
    

    这里的内部接口一定是static的,因为接口是不能实例化的,所以为了访问到接口中的接口,必须定义为static。如果不指定,则默认就是static。

    我们看一个该内部接口的实现:

    public class MapImpl implements Map.Entry{
        @Override
        public Object getKey() {
            return 0;
        }
    
        @Override
        public Object getValue() {
            return null;
        }
    
        @Override
        public Object setValue(Object value) {
            return null;
        }
    }
    

    总结

    本文讲解了5个内部类的实现和一个内部接口的应用。大家只要把内部的类或者接口看成一个变量,就可以很好的理解上面的内容了。

    本文的例子https://github.com/ddean2009/learn-java-base-9-to-20

    更多精彩内容且看:

    本文作者:flydean程序那些事

    本文链接:http://www.flydean.com/inner-class-inner-interface/

    本文来源:flydean的博客

    欢迎关注我的公众号:程序那些事,更多精彩等着您!

    展开全文
  • Java接口内部类

    千次阅读 2018-09-20 15:00:16
    与Android事件相关的Java知识主要包括:接口内部类,下面讲解这些知识点。 1、接口 Java接口主要描述应该具备什么功能。接口是一种契约机制,描述了相关的应遵循一定的、统一的格式定义。在Java中,接口...

    在学习Android事件机制之前,有必要把相关的Java知识先进行一下回顾。与Android事件相关的Java知识主要包括:接口、内部类,下面讲解这些知识点。

    1、接口

    Java下接口主要描述类应该具备什么功能。接口是一种契约机制,描述了相关的类应遵循一定的、统一的格式定义。在Java中,接口通过关键字Interface定义。例如下面的接口定义:

    package com.zhangw.crazyandroid;

     

    public interface UserDao {

        String findUserName(String id);

    }

           该接口描述了这样一种契约,实现该接口的类必须提供findUserName方法,该方法必须要有一个String类型的参数。

           为了让类实现某个接口,只需要一下两步:

    1. 通过Implements声明某个类实现特定的接口;
    2. 对接口的中所有方法进行定义;

    下面给出UserDao接口的实现,如下所示:

    package com.zhangw.crazyandroid;

     

    public class UserTableDao implements UserDao {

        public String findUserName(String id) {

            return "zhangw";

        }

    }

    这里需要注意的是,在接口中,不用把方法申明为public,因为接口中的方法都是public。但是在实现接口时,必须在实现类里面将对应的方法申明为public,否则方法默认为包可见。

    关于接口还有几点要说明:

    1. 接口不是类,不能用new实例化;
    2. 可以申明接口的变量,但是接口的变量必须复制具体实现类的对象;
    3. 可以使用instance检查一个类是否实现了特定的接口,如下所示:

    if(userDao instanceof UserDao){

       Log.d("接口测试", "是UserDao接口");

    }

    1. 类似于类的继承关系,接口也可以进行继承扩展;
    2. 一个类可以实现多个接口,实现的多个接口之间用,分割
    3. 接口中可以定义常量
    4. 在Java SE 8中,接口可以定义静态方法,但这样的设计有悖于接口抽象机制的初衷,不推荐。
    5. 接口可以通过关键字default声明默认方法,提供默认实现,这样实现接口的开发人员可以只覆盖需要的方法,例如下面代码所示:

    package com.salary.myjava;

     

    public interface UserDao {

        String queryNameById(String id);

        default String queryOrgById(String id){return id;};

    }

    2、内部类

    内部类是定义在一个类里面的类,内部类有以下特点:

    1. 内部类方法可以访问外部类的数据
    2. 内部类可以对同一个包中的其他类隐藏起来;
    3. 通常使用匿名内部类实现回调机制

    下面给出一个内部类的样例

    package com.salary.myjava;

     

    public class MyWindow {

        private String title = "111";

        private String name = "222";

     

        // 内部接口

        public interface StartListener{

            String getWindowTitle();

        }

       

        // 内部类

        public class UserDaoImp implements UserDao{

            public String queryNameById(String id){

                return MyWindow.this.title;

            }

        }

     

        public void load(){

            UserDao userDao = new UserDaoImp();

            System.out.println(userDao.queryNameById("111"));

        }

     

        public void load2(){

            //  匿名类

            StartListener startListener = new StartListener(){

                public String getWindowTitle(){

                    return MyWindow.this.title;

                }

            };

            System.out.print(startListener.getWindowTitle());

        }

    }

        这里我们定义了UserDaoImp类,该类是MyWindow的内部类,此外我们还在MyWinow类的内部定了一个接口StartListener,并在load2方法中,通过一个匿名类实现了该接口。

          这里需要说明的是:

    1. 内部类主要用于方法的回调处理;
    2. 在内部类可以通过<外部类的名称.this>访问外部类的this指针。
    3. 在类的内部也可以定义接口,如上所StartListener

    (张伟:2018年9月20日)

    (转载时请注明来源)

    展开全文
  • java 接口内部类

    千次阅读 2013-04-05 12:06:50
    接口是对的一组需求描述。接口中的方法自动的属于public。接口中的属性自动的属于public static final。因此接口中的属性是常量,必须声明的时候进行初始化。 下面是一个接口的示例: public interface ...
    接口是对类的一组需求描述。接口中的方法自动的属于public。接口中的属性自动的属于public static final。因此接口中的属性是常量,必须声明的时候进行初始化。
    
    下面是一个接口的示例:
    public interface InterfaceM {
        String id="1190";
        void value();
    }

    实现测试类:
    public class Test implements InterfaceM{

        @Override
        public void value() {
            System.out.println("id:"+Test.id);
        }
         
        public static void main(String[] args){
            (new Test()).value();
            
        }
    }

    运行结果:
    run:
    id:1190
    成功生成(总时间:1 秒)

    接口和抽象类的比较
    先说一下接口和抽象类的一些区别:
    接口的属性是常量;抽象类的属性则没有什么限制,同正常类的属性是一样的。接口的方法都是方法的声明,没有实现,就是没有方法体;抽象类的方法中非抽象方法和正常类的一样,抽象方法要加abstract修饰,同时没有方法体。更深层次的区别是接口时一种双方交互的协议;抽象类则是一种类型的限定,一种提供公共属性和方法的载体。
    更底层的区别是Java选择单继承多实现的原因是多继承会让语言本身变得更加复杂,效率也会降低。

    内部类
    使用内部类的原因有三点:
    内部类可以访问该类作用域中所有的数据,包括私有数据
    内部类可以对同一个包中的其他类隐藏起来
    当想要定义一个回调函数且不想编写大量的代码时,使用匿名内部类比较便捷。

    先看下面的一个例子:
    public class Test{
        private String id="1899";

        private void detai(){
           System.out.println("I am a private method in Test class!");
        }
        
        public class Inner{
           public void info(){
              System.out.println("id:"+id);
              
              detai();
              System.out.println("I am a inner class method");
           }
        }
        
        public void value(){
           Inner inner=new Inner();
           inner.info();
           System.out.println("I'm a public method in Test class!");
        }
       

         
        public static void main(String[] args){
           Test test=new Test();
           test.value();
            
        }
    }
    运行结果:
    run:
    id:1899
    I am a private method in Test class!
    I am a inner class method
    I'm a public method in Test class!
    成功生成(总时间:0 秒)
    从这里面可以看见一些内部类的语法规则:
    可以毫无限制的引用外部类的属性和方法,private限定不起作用
    外部类引用内部类可以像引用其他类一样的引用方式,static参照其他的普通类一样使用。

    下面是局部内部类的情形:
    public class Test{
        private String id="1899";

        private void detai(){
           System.out.println("I am a private method in Test class!");
        }

        public void value() {
            class Inner {
                public void info() {
                    System.out.println("id:" + id);
                    detai();
                    System.out.println("I am a inner class method");
                }
            }
            Inner inner = new Inner();
            inner.info();
            System.out.println("I'm a public method in Test class!");
        }
       

         
        public static void main(String[] args){
           Test test=new Test();
           test.value();
            
        }
    }

    如果内部类没有引用外部类的非静态属性和方法,可以把内部类声明为static,来消去对外部类的引用。

    一般在开发中最常用的是接口,内部类多用在swing等图形界面开发添加Listener的时候使用。
    展开全文
  • 大家面试的时候肯定被问过java 接口、抽象、具体内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。

    大家面试的时候肯定被问过java 接口、抽象类、类、内部类、匿名内部类的区别及它们之间的关系。那么下面我就来整理下它们之间的关系。(主要是总结了下网上的资料,不是自己原创的。)总结的不好,请勿喷。^_^

    java 接口:
     使用interface来定义一个接口。接口定义同类的定义类似,也是分为接口的声明和接口体,其中接口体由常量定义和方法定义两部分组成。定义接口的基本格式如下:

    [修饰符] interface 接口名 [extends 父接口名列表]{

    [public] [static] [final] 常量;
    [public] [abstract] 方法;
    }
    修饰符:可选,用于指定接口的访问权限,可选值为public。如果省略则使用默认的访问权限。
    接口名:必选参数,用于指定接口的名称,接口名必须是合法的Java标识符。一般情况下,要求首字母大写。(个人习惯:在接口类名前先写一个I_后面跟着接口名称)
    extends 父接口名列表:可选参数,用于指定要定义的接口继承于哪个父接口。当使用extends关键字时,父接口名为必选参数。
    方法:接口中的方法只有定义而没有被实现。

    接口中可以定义变量和方法,但是一般人不会在接口中定义变量,因为在接口中定义的变量会被隐式的定义为public static final变量(并且只能是public static final变量,用private修饰会报编译错误),而方法会被隐式地指定为public abstract方法且只能是public abstract方法(用其他关键字,比如private、protected、static、 final等修饰会报编译错误)。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法,编译器会编译不过去,就会报错。并且接口中所有的方法不能有具体的实现。说java接口中的方法必须是抽象方法。如果接口中存在非抽象方法,编译器会编译不过去,就会报错。并且接口允许任何类去实现它,一个类如果实现一个接口,那么这个类就要把这个借口中的所有方法都实现了。

    所以说java接口中的方法都是极度抽象的类型,它比抽象类更加严格的“抽象”。

    其实java中的接口是为了解决java中单继承而来的,大家都知道,java中一个类只能有继承一个父类,不像C++中可以多继承,一个孩子可以有多个爸爸。java严格按照我们生活中的人与人的关系,一个孩子只能有一个爸爸,但是可以有多个干爹(现在的干爹都不靠谱啊,原因你懂的。),一个孩子可以继承父亲的所有遗产,但是也可以拥有多个干爹的遗产,前提是他的干爹愿意把遗产给他。(这里指的是别的接口中的方法)。

    java 抽象类:
    下面是java抽象类的定义语法。
    public abstract class Demo01 {
    
    	public abstract void addUser();//抽象方法
    	
    }
    java抽象类必须要以abstract  来进行修饰,抽象类可以继承抽象类。一个类中存在一个抽象方法,那么这个类必须要定义成抽象类。java中抽象类的访问控制修饰符默认是public类型的,抽象类中的抽象方法(其前有abstract修饰)不能用private、static、synchronized、native访问修饰符修饰。因为,抽象方法没有方法体,是用来被继承的,所以不能用private修饰;static修饰的方法可以通过类名来访问该方法(即该方法的方法体),抽象方法用static修饰没有意义;使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象,因为该方法不是在该抽象类中实现的。是在其子类实现的。所以,锁应该归其子类所有。所以,抽象方法也就不能用synchronized关键字修饰了;native这个东西本身就和abstract冲突,他们都是方法的声明,只是一个把方法实现移交给子类,另一个是移交给本地操作系统。如果同时出现,就相当于即把实现移交给子类,又把实现移交给本地操作系统,那到底谁来实现具体方法呢?  总之:抽象类是提取具体类的公因式。
    java 内部类:
    java内部类一般使用不是很多,但是其实也很好理解。就是一个类中再次定义了一个类。可以理解为在一个大的厂房里面又盖了个小的厂房。大厂房有它自己的构造组成。小厂房也是有小厂房的构造组成的。内部类破坏了良好的代码结构,但是我们平时还是需要用到的,因为内部类可以随意使用外部类的属性和方法。
    下面是内部类访问外部类的示例及内部类的基本格式:
    package test;
    
    public class test {
    	private String name = "小熊猫";
    	
    	
    	class in {
    		private String name = "丢丢";
    		
    		public void sal(){
    			String name = "小熊猫丢丢";
    			
    			System.out.println("局部变量name:"+name);
    			System.out.println("内部类变量name:"+this.name);
    			System.out.println("外部类变量name:"+test.this.name);
    			
    		}
    		
    	}
    	
    	public static class ma {
    		public static void main(String[] args) {
    			test.in in = new test().new in();
    			in.sal();
    			
    		}
    	}
    
    }

    其实java内部类也是一个类,与其他类不同的是内部类是类中类,它的作用范围只能在这个类中。

    java 匿名内部类:
    匿名内部类的定义语法如下:

    new 父类构造器(参数列表)|实现接口()    
        {    
         //匿名内部类的类体部分    
        } 
    虽然看上去很简单,但是还有一些注意事项需要我们注意的:
    1:使用匿名内部类必须实现一个接口或者继承一个类,但是鱼和熊掌不可兼得,至于是继承类还是实现接口需要根据业务要求去走了。
    2:匿名内部类中不可以定义构造函数。
    3:匿名内部类中不可以有任何静态方法和静态成员变量(这个是因为静态方法或者静态成员变量在加载的时候会直接加载,而普通的成员变量或方法需要在类加载的时候才会去       加载)
    4:匿名内部类也是局部内部类,所以局部内部类的限制对匿名内部类同样有效。
    5:匿名内部类不能是抽象的,它必须要实现继承的类或者实现接口中所有的抽象方法。


    关于java类的一些类就先写到这了,下面会陆续写一些关于多线程与高并发的一些文档,如有一些不对的地方欢迎大家指出,大家共同学习共同进步。

    展开全文
  • Java内部类内部接口

    千次阅读 2015-05-28 14:05:53
    内部类 定义 指在一个外部内部再定义一个内部类作为外部,的一个成员或者一个局部成员, 并且依附于外部而存在的。 访问权限可和Java成员变量的访问权限变量修饰一样 ’ ...内部接口
  • 详解 Java 内部类

    万次阅读 多人点赞 2018-09-04 00:17:56
    内部类Java 里面算是非常常见的一个功能了,在日常开发中我们肯定多多少少都用过,这里总结一下关于 Java内部类的相关知识点和一些使用内部类时需要注意的点。 从种类上说,内部类可以分为四类:普通内部类...
  • Java内部类和匿名内部类的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部类和匿名内部类的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部类: (1)内部类的同名方法 内部类可以调用外部的方法,如果内部类有同名方法...
  • Java内部类内部接口

    千次阅读 2018-06-03 23:02:47
    public class ParcellA {//外部 private int pMember;//声明一个私有成员 private static int pstMember;//声明一个私有静态成员 private final int pfMember=9;//常量值 private final static int ...
  • Java基础14 面向对象~接口内部类

    千次阅读 多人点赞 2021-01-12 16:46:45
    接口 生活中的接口 如:USB接口,任何的产品只要符合USB规格就可以插入。 什么是程序中的接口接口就是程序实现的一种规则。 定义接口的语法: public interface 接口名{ 静态常量的定义; 方法的定义; } 定义接口...
  • 文章目录抽象方法和抽象抽象方法抽象抽象的概念以及使用为什么需要抽象类接口接口的概念接口的使用接口与抽象的区别使用一个人的例子更直观的了解下接口内部类内部类的概念内部类的作用内部类的分类成员...
  • Java内部类

    千次阅读 2019-05-02 02:28:01
    一:Java内部类详解 二:匿名内部类 一:Java内部类详解 成员内部类:声明一个新 class ,作为该的一个成员 局部内部类:在一个方法内部,重新声明一个 静态内部类:static 修饰内部类 匿名内部类java...
  • java接口内的匿名内部类

    千次阅读 2016-12-31 13:03:14
    什么是接口和匿名内部类接口: ... Java接口的方法只能是抽象的和公开的,Java接口不能有构造器。 匿名内部类:匿名内部类也就是没有名字的内部类 正因为没有名字,所以匿名内部类只能使用一次,它通常用来简化代码编
  •  Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现;  也就是说,接口自身自提供方法的基本声明,而不提供方法体;接口中声明的方法只能被实现该接口的子类所具体实现。...
  • Java语法】抽象接口内部类

    万次阅读 2019-06-24 09:03:39
    抽象的使用要点 代码示例 //抽象方法只有声明,没有实现 //抽象方法只能在抽象中 public abstract class Animal { abstract public void shout();// 抽象方法 public void eat()// 普通方法 { System.out...
  • 初识JAVA内部类

    万次阅读 多人点赞 2021-03-21 22:22:28
    如果一个存在的意义就是为指定的另一个,可以把这个类放入另一个内部。 就是把定义在内部的情况就可以形成内部类的形式。 A中又定义了B,B就是内部类,B可以当做A的一个成员看待: 2 特点 1...
  • 学习java中 看到的高级特性关于内部成员这一章 出现这么一句话把我拦住鸟 读不太明白 还请大神解释一下
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部外部创建非静态内部类2.2 在外部外部创建静态内部类2.3 在外部类内部创建内部类语法3 内部类的分类3.1 成员内部类3.2 静态...
  • java匿名内部类什么是匿名内部类?匿名内部类的使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承) 什么是匿名内部类? 匿名内部类,顾名思义,就是不知道这个到底是什么名字,也...
  • method1(new Worker());

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 654,410
精华内容 261,764
关键字:

java接口放内部类

java 订阅