精华内容
下载资源
问答
  • java接口放内部类
    千次阅读
    2022-04-10 09:07:39

    1. 匿名内部类介绍

    使用 Java 编程时,常常需要创建不会被再次使用的对象。在这种情况下,非常适合使用一种特殊
    的内部类:匿名内部类。这种类没有名称,是在同一条语句中声明和创建的。
    要使用匿名内部类,可将引用对象的代码替换为关键字 new、对构造函数的调用以及用大括号
    ({和})括起的类定义。
    既然是匿名类,所以你无法在别的地方实例化和使用这个类。
    匿名内部类也可用于接口(interface)的实现

    特点

    匿名对象:没有名字的对象。
    new ClassName().run();
    
    非匿名对象:含有名字的对象。
    ClassName c=new ClassName();
    c.run();
    

    2. 匿名内部类语法

    例如一般的写法:

    ThreadClass task = new ThreadClass();
    Thread runner = new Thread(task);
    runner.start();
    

    转化成:

    Thread runner = new Thread(new Runnable() {
        public void run() {
            // thread does its work here
        }
    });
    runner.start();
    

    即,这相当于将 Thread(task)的参数task替换成下面的代码实现:

    new Runnable() {
        public void run() {
            // thread does its work here
        }
    }
    

    2.1 匿名内部类的另一种写法

    new 类名或者接口名() {
        重写方法;
    }
    
    var t = new Thread() {
        public void run() {
            这是被重写的方法;
        }
    }
    

    3. 我的代码实现

    class GoogleInc {
        void google1() {
            System.out.println("Google 1 Inc class, google 1");
        }
    
        void google2() {
            System.out.println("Google 2 Inc class, google 2");
        }
    }
    
    
    class AnonymousClass {
        AnonymousClass(GoogleInc golc) {
            golc.google1();
            golc.google2();
        }
    }
    
    
    public class AnonymousInnerClass {
        public static void main(String[] args) {
            AnonymousClass gc = new AnonymousClass(new GoogleInc() {
                // Overloaded function [google1()]
                void google1() {
                    System.out.println("Anonymous inner class, google 1");
                }
    
                void doAnotherAnything() {
                    System.out.println("Do another anything");
                }
            });
        }
    }
    

    4. 使用匿名内部类实现接口

    HardwareInc这是一个接口,这个接口同时还继承了另外一个接口,继承另外一个接口只是将另外一个接口的抽象方法添加到这个接口中,并没有其他的特别之处,这样这个接口中的抽象方法总数为这个接口的抽象方法数加另一个接口的抽象方法数

    public interface HardwareInc {
        public void designPhone();
        public void designComputer();
        public void designWatch();
    }
    
    class HuaweiInc {
        // Use anonymous inner classes to implement interfaces HardwareInc
        HuaweiInc(HardwareInc hwi) {
            hwi.designPhone();
            hwi.designComputer();
            hwi.designWatch();
            hwi.elec();
            hwi.software();
        }
    }
    
    // Use anonymous inner classes to implement interfaces HardwareInc
    HuaweiInc HwInc = new HuaweiInc(new HardwareInc() {
        @Override
        public void designPhone() {
            System.out.println("Huawei design Huawei mate40");
        }
    
        @Override
        public void designComputer() {
            System.out.println("Huawei design Huawei matebook");
        }
    
        @Override
        public void designWatch() {
            System.out.println("Huawei design watchGT");
        }
    
        @Override
        public void elec() {
            System.out.println("Huawei have elec developer");
        }
    
        @Override
        public void software() {
            System.out.println("Huawei have software developer");
        }
    });
    
    更多相关内容
  • 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中的内部类内部接口详解

    千次阅读 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-06-03 23:02:47
    public class ParcellA {//外部 private int pMember;//声明一个私有成员 private static int pstMember;//声明一个私有静态成员 private final int pfMember=9;//常量值 private final static int ...

    内部类

    package Learn.com.seven;
    
    public class ParcellA {//外部类
        
        private int pMember;//声明一个私有成员
        private static int pstMember;//声明一个私有静态成员
        private final int pfMember=9;//常量值
        private final static int pfsMember=0;//常量静态成员
        
        /**
         * 
         *  -#  普通内部类可以访问外部类的所有成员和方法,
         *  -#  如何在其他的类访问此内部类呢
         *  -#  必须使用外部类的对象来创建内部类对象
         *  -#  ParcellA parcel = new ParcellA(); 见Entry.java
         *      ParcellA.Contents content = parcel.new Contents();
         */
        public class Contents{//嵌套定义一个内部类
            private int i = 11;
            
            public int value(){//给内部类,定义的一个方法
                System.out.println(pMember);//所有成员
                System.out.println(pstMember);
                System.out.println(pfMember);
                System.out.println(pfsMember);
                outClassMethod();//可以访问外部类的普通方法
                outClassStaticMehtod();//及静态方法
                return i;
            }    
          
            /**
             * @see 但是若Contesnts是静态的,则可以声明静态成员和静态方法
             */
    //        private static int j=0;//非静态内部类,不能声明[静态成员]
    //        private static int  out(){//非静态内部类,不能声明[静态方法]        
    //        }
        
        }
        /**
         * 
         *    - 定义一个嵌套静态内部类
         *    -# 不能访问外部内的【非静态成员】,只能访问外部类的【静态成员】。同理也不能访问外部类的非静态方法
         *      
         */
        public static class InnerStaticClass{
            private static int memberOfStatic;//可以定义静态成员        
            private static int Out(){//可以定义静态方法
                //outClassMethod();//不能访问外部类的非静态方法
                //System.out.println(pMember);//由于ParcellA,是静态内部类,所以不能访问外部内的非静态成员
                  //因为静态类,是在加载类时,就初始化了。而非静态成员,是在创建对象时才初始化,分配内存
                  //因此,在静态类初始化时访问外部类的非静态成员时,非静态成员还不存在,所以不能访问
                System.out.println(pstMember);//可以访问静态成员
                System.out.println(pfsMember);//可以访问常量成员.由于final int是不可变的成员,即在程序运行中它的值不可以修改。因此
                              //final成员的值,就可以在加载类时就确定下来。所以在静态内部类访问它时,它是已知的,所以就 
                              //可以访问
                System.out.println(pfsMember);//同上原因,所以可以访问        
                outClassStaticMehtod();//可以访问静态方法            
                return memberOfStatic;
            }    
            
            public void Myout(){
                Out();
            }
        }
       
        class Destination{//定义另一个内部类,注意默认访问权限为包访问权限,不能在另一个包访问
            private String label;
            Destination(String WhereTo){//内部类的构造方法
                label =WhereTo;
            }
            String ReadLabel(){//给内部类,定义的一个方法
                return label;
            }
        }
        
        
        public void outClassMethod(){
            System.out.println("outClass Non_Static Method");
        }
        public static void outClassStaticMehtod(){
            System.out.println("outClass Static Method");
        }
    }
    
    
    
    package Learn.com.test;
    import Learn.com.seven.ParcellA;
    
    public class Entry {
    
        public static void main(String[] args) {
            ParcellA parcel = new ParcellA();
            //由于Contests这个内部类,是public权限,所以可以访问,
            //但注意必须是用外部类ParcellA的对象来parcel.new 来创建内部类的对象.
            //并且声明内部类的对象时,需要使用ParcellA.Contents 这种"外部类.内部类"的方式
            
            ParcellA.Contents content = parcel.new Contents();
            content.value();
                    
            
            //由于Destination,是包访问权限,所以下面的访问错误 
            //ParcellA.Destination desten = parcel.new Destination("china");
            
            //注意,由于InnerStaticClass是ParcellA的静态内部类,所以可以直接用它来创建对象
            //对于这种用法,在android中的布局中用到,比如
            //LinearLayout.LayoutParams params =  new LinearLayout.LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.FILL_PARENT);
            //LinearLayout.LayoutParams 类就是LinearLayout中的静态内部类,可以通过android的LinearLayout.java源码查看        
            ParcellA.InnerStaticClass obj = new ParcellA.InnerStaticClass();
            obj.Myout();//可以调用public方法    ,只能访问自己的方法,在这里不能直接访问外部类的方法,外部方法对它不可见                    
        }
    
    }
    

    普通内部类

    常规内部类:常规内部类没有用static修饰且定义在在外部类类体中。

    1. 常规内部类中的方法可以直接使用外部类的实例变量和实例方法。
    2. 在常规内部类中可以直接用内部类创建对象
    public class MyOuter {
        private int x = 100;
         
        class MyInner{
            private String y="Hello!";
            public void innerMethod(){
                System.out.println("内部类中 String ="+y);
                System.out.println("外部类中的x ="+x);
                outerMethod();
                System.out.println("x is "+MyOuter.this.x);
            }
        }
         
        public void outerMethod(){
            x++;
        }
         
        public void makeInner(){
            //在外部类方法中创建内部类实例
            MyInner in = new MyInner();
        }
         
        public static void main(String[] args){
            MyOuter mo = new MyOuter();
            //使用外部类构造方法创建 mo 常规内部类需要通过外部类实例来new
            MyOuter.MyInner inner = mo.new MyInner();
            inner.innerMethod();
        }
    }
    

    应用

    @Service("brandShopUgcExecutor")
    @Slf4j
    public class BrandShopUgcExecutor implements JobExecutor {
       
        private List<Integer> sortReviews(List<ReviewData> reviewDataList) {
            BrandShopUgcExecutor brandShopUgcExecutor = new BrandShopUgcExecutor();
            //使用内部类
            OrderByWeight orderByWeight = brandShopUgcExecutor.new OrderByWeight();
            OrderByFollowNote orderByFollowNote = brandShopUgcExecutor.new OrderByFollowNote();
            Ordering<ReviewData> ordering = Ordering.from(orderByWeight).compound(orderByFollowNote);
            //使用匿名内部类更合适,因为只有这一个地方使用
         Ordering.from(new Comparator<ReviewData>() {
    
                @Override
                public int compare(ReviewData o1, ReviewData o2) {
                    return Doubles.compare(getReviewWeight(o2), getReviewWeight(o1));
                }
            }).compound(new Comparator<ReviewData>() {
    
                @Override
                public int compare(ReviewData o1, ReviewData o2) {
                    return Ints.compare(o1.getFollowNoteNo(), o2.getFollowNoteNo());
                }
            });
            Collections.sort(reviewDataList, ordering);
            List<Integer> reviewIdList = Lists.newArrayList();
            for (ReviewData reviewData : reviewDataList) {
                reviewIdList.add(reviewData.getReviewId());
            }
            return reviewIdList;
        }
    
        /**
         * 按权重排序
         */
        public class OrderByWeight implements Comparator<ReviewData> {
            @Override
            public int compare(ReviewData r1, ReviewData r2) {
                return Doubles.compare(getReviewWeight(r2), getReviewWeight(r1));
            }
        }
    
        /**
         * 按回复数排序
         */
        public class OrderByFollowNote implements Comparator<ReviewData> {
            @Override
            public int compare(ReviewData r1, ReviewData r2) {
                return Ints.compare(r1.getFollowNoteNo(), r2.getFollowNoteNo());
            }
        }
    }
    

    静态内部类

    静态内部类:与类的其他成员相似,可以用static修饰内部类,这样的类称为静态内类。静态内部类与静态内部方法相似,只能访问外部类的static成员,不能直接访问外部类的实例变量,与实例方法,只有通过对象引用才能访问。

    public class MyOuter2 {
         
        public static int x=100;
         
        public static class Myinner{
            private String y="Hello!";
            /**
             * 由于static内部类不具有任何对外部类实例的引用,
             * 因此static内部类中不能使用this关键字来访问外部类中的实例成员,
             * 但是可以访问外部类中的static成员。这与一般类的static方法相通
             */
            public void innerMethod(){
                System.out.println("x="+x);
                System.out.println("y="+y);
            }
        }
         
        public static void main(String[] args){
            MyOuter2.Myinner si = new MyOuter2.Myinner();
            si.innerMethod();
        }
        
    }
    

    局部内部类

    局部内部类:在方法体或语句块(包括方法、构造方法、局部块或静态初始化块)内部定义的类成为局部内部类。
    局部内部类不能加任何访问修饰符,因为它只对局部块有效。

    1. 局部内部类只在方法体中有效,就想定义的局部变量一样,在定义的方法体外不能创建局部内部类的对象
    2. 在方法内部定义类时,应注意以下问题:
      2.1 方法定义局部内部类同方法定义局部变量一样,不能使用private、protected、public等访问修饰说明符修饰,也不能使用static修饰,但可以使用final和 abstract修饰
      2.2方法中的内部类可以访问外部类成员。对于方法的参数和局部变量,必须有final修饰才可以访问。
      2.3static方法中定义的内部类可以访问外部类定义的static成员
    public class MyOuter3 {
        private int size=5,y=7;
         
        public Object makeInner(int localVar){
            final int finalLocalVar = localVar;
             
            //创建内部类,该类只在makeInner()方法有效,就像局部变量一样。
            //在方法体外部不能创建MyInner类的对象
            class Myinner{
                int y=4;
                public String toString(){
                    return "OuterSize:"+size+" localVar:"+finalLocalVar+"\nthis.y="+this.y;
                }
            }
             
            return new Myinner();
        }
         
        public static void main(String[] args){
            Object obj = new MyOuter3().makeInner(47);
            System.out.println(obj.toString());
        }
    }
    

    匿名内部类

    定义类的最终目的是创建一个类的实例,但是如果某个类的实例只是用一次,则可以将类的定义与类的创建,放到与一起完成,或者说在定义类的同时就创建一个类以这种方法定义的没有名字的类成为匿名内部类。
    声明和构造匿名内部类的一般格式如下:

       new ClassOrInterfaceName(){
        类体 }
    
    1. 匿名内部类可以继承一个类或实现一个接口,这里的ClassOrInterfaceName是匿名内部类所继承的类名或实现的接口名。但匿名内部类不能同时实现一个接口和继承一个类也不能实现多个接口。如果实现了一个接口,该类是Object类的直接子类,匿名类继承一个类或实现一个接口,不需要extends和implements关键字。
    2. 由于匿名内部类没有名称,所以类体中不能定义构造方法,由于不知道类名也不能使用关键字来创建该类的实例。实际上匿名内部类的定义、构造、和第一次使用都发生在同样一个地方。此外,上式是一个表达式,返回的是一个对象的引用,所以可以直接使用或将其复制给一个对象变量。例:
       TypeName obj=new Name(){
       此处为类体
          }
      同样,也可以将构造的对象作为调用的参数。例:
        
       someMethod(new Name(){
       此处为类体  });*/
    

    内部接口

    为了弄清楚内部接口是如何工作的,我们可以拿它与内部类作比较。内部类可以被认为是一个外部类内部定义的一个常规方法。因为一个方法可以被声明为静态和非静态,类似的内部类也可以被声明为静态和非静态。静态类类似于静态方法,它只能访问外部类的静态成员属性。非静态方法可以访问外部类的所有成员属性。

    • 一种对那些在同一个地方使用的接口进行逻辑上分组;
    • 封装思想的体现;
    • 因为接口是不能实例化的,内部接口只有当它是静态的才有意义。因此,默认情况下,内部接口是静态的,不管你是否手动加了static关键字。
    public class MyOuter4 {
        private int size=5;
        private int id;
         
        public interface OnClickListener{
            void onClick(int id);
        }
         
        public void onClick(OnClickListener obj){
            obj.onClick(this.id);
        }
         
        public Object makeInner(int localvar){
            final int finallocalvar = localvar;
            return new Object(){
                public String toString(){
                    return "OuterSize="+size+"\nfinalLocalvar="+finallocalvar;
                }
            };
        }
         
        public static void main(String args[]){
            Object obj=new MyOuter4().makeInner(67);
            System.out.println(obj.toString());
             
            MyOuter4 m = new MyOuter4();
            m.onClick(new OnClickListener() {
                 
                @Override
                public void onClick(int id) {
                    System.out.println(id);
                }
            });
        }
    }
    
    public class Util {
        public interface Worker {
            void work();
        }
    }
      
    package com.dao.util;
     
    import com.dao.util.Util.Worker;
     
    public class Demo implements Worker {
        public void work() {
            System.out.println("Is working");
        }
    
    

    在这个util类里面封装了会改变的Worker,也就是说,util类里面有自己的算法:一部分是固定,另外一部分是可变的,而这个可变的部分就变成了一个接口(接口是特殊的抽象类其实的意思大概的这个worker可能在不同的工作环境有不同的工作方式,例如work(),onvaction())所以在类里面放一个接口不是什么新的设计,而是一种思想方式,让代码扩展性更高。

    参考:
    https://www.cnblogs.com/activity-life/p/3622850.html
    https://www.cnblogs.com/as3lib/p/6107915.html(java 四种内部类和内部接口)

    展开全文
  • java匿名内部类(实现接口

    千次阅读 2020-04-02 22:27:54
    匿名内部类适合创建那种只需一次使用的,匿名内部类的语法有点奇怪,创建匿名内部类时会立即创建一个该的实例,这个的定义立即消失,匿名内部类不能重复使用。 下面用实现接口的方式来介绍匿名内部类: //...
  • Java 面向对象编程之接口内部类

    千次阅读 2018-12-01 13:13:04
    接口内部类本质上也是,是抽象的抽象,这三种类有各自的特点。this,super,static,final是四个常见的的关键字,他们是怎么样来描述的属性和行为? ...
  • 详解 Java 内部类

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

    千次阅读 2022-03-03 15:25:40
    抽象 1.被abstract修饰的方法为抽象方法,抽象方法没有方法体 2.若一个中有抽象方法,那么这个必须声明为抽象 3.若抽象作为父类被继承,那么继承他的子类有两种解决方案: 作为抽象子类,不实现或实现...
  • Java 匿名(匿名内部类)

    万次阅读 多人点赞 2020-12-25 23:41:48
    Java匿名(匿名内部类) 学习的参考博文:无恨之都 1. 初识 匿名 标准说法: 内部类包括:成员、局部、匿名(匿名内部类)。 匿名概念: 匿名可以使你的代码更加简洁 (JDK8之后Lambda更简洁)。 你可以...
  • Java内部类和匿名内部类的用法

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

    千次阅读 2021-03-07 00:47:13
    内部类可以声明public、protected、private等访问限制,可以声明 为abstract的供其他内部类或外部继承与扩展,或者声明为static、final的,也可以实现特定的接口。外部按常规的访问方式使用内部 ,唯一的...
  • java内部类最全详解

    万次阅读 多人点赞 2022-03-20 10:58:56
    1、成员内部类 内部类与外部的关系 a.成员内部类的创建需要依赖于外部对象-(成员方法必须通过对象调用),在没有外部实例之前无法创建成员内部类对象 b.内部类与外部相对独立,不是is a 的关系...
  • 软件接口:即程序代码,特殊的。表示一种规范,是具有的N个方法的特征集合。 比如在现实生活中时,显示器封装了很多个电子元件等,最终向外暴露数据交互的孔,也就是接口。其目的是搭建设备和设备之间通信桥梁。 ...
  • Java学习笔记13:Java_接口内部类

    千次阅读 2021-08-08 20:00:47
    1.接口 1.1信息管理系统集合改进 (应用) 使用数组容器的弊端 容器长度是固定的,不能根据添加功能自动增长 没有提供用于赠删改查的方法 优化步骤 创建新的StudentDao,OtherStudentDao 创建ArrayList...
  • Java实验之接口与实现、内部类与异常 Java实验之接口与实现 评价成绩 体操比赛计算选手成绩的办法是去掉一个最高分和最低分后再计算平均分,而学校考 察一个班级的某科 目的考试情况时,是计算全班同学的平均成绩。...
  • Java 内部类和异常(详细版)】

    千次阅读 多人点赞 2021-04-08 17:24:17
    内部类和异常1 内部类2 匿名2.1 和子类有关的匿名2.2 和接口有关的匿名3 异常3.1 try-catch语句3.2 自定义异常4 断言 1 内部类 Java支持在一个中声明另一个,这样的称作内部类,而包含内部类...
  • Java的匿名内部类

    万次阅读 多人点赞 2019-06-09 14:42:20
    从上面的定义可以看出,匿名内部类必须继承一个父类,或实现一个接口,但最多只能继承一个父类,或实现一个接口。 两条规则。 匿名内部类不能是抽象。 匿名内部类不能定义构造器。由于匿名内部类没有...
  • Java基础之匿名内部类,匿名内部类是什么?为什么要用匿名内部类,匿名内部类详解。 什么是匿名内部类? 顾名思义 匿名 就是没有名字,一个没有名字的内部类,称为匿名内部类。 下面先看一个例子,比如说你想和你的女...
  • 本文主要介绍了Java内部类的基本原理,使用方法和各种细节。 有关内部类实现回调,事件驱动和委托机制的文章将在后面发布。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人...
  • Java基础14 面向对象~接口内部类

    千次阅读 多人点赞 2021-01-12 16:46:45
    接口 生活中的接口 如:USB接口,任何的产品只要符合USB规格就可以插入。 什么是程序中的接口接口就是程序实现的一种规则。 定义接口的语法: public interface 接口名{ 静态常量的定义; 方法的定义; } 定义接口...
  •  最近有同事跟我说了他面试时遇到的问题,考官问:“接口和抽象可以被new嘛?”。这可能不是考官的原话,但是据他表达考官大概就是这个意思了。听到这个问题,我的第一反应是肯定不行啊,直接对接口和抽象调用...
  • Java内部类序列化

    千次阅读 2018-12-27 15:10:02
    一个能够序列化,需要满足两个条件: ...Java的嵌套(nested class)一共有四种: static nested class 静态嵌套  inner class 内部类(非静态)  local class 本地(定义在方法内部)  anonymous cla...
  • java匿名内部类什么是匿名内部类?匿名内部类的使用场景?匿名内部类如何创建?匿名内部类的实现和使用例1(实现接口)例2(继承) 什么是匿名内部类? 匿名内部类,顾名思义,就是不知道这个到底是什么名字,也...
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部外部创建非静态内部类2.2 在外部外部创建静态内部类2.3 在外部类内部创建内部类语法3 内部类的分类3.1 成员内部类3.2 静态...
  • Java内部类

    千次阅读 2018-12-28 11:21:17
    Java内部类真的很难理解,但有必要搞懂,因为内部类让外部更丰富多彩了,就好像一个人的心中还可以住着另外一个人。
  • Java内部类 (详细讲述java内部类

    千次阅读 2022-06-26 00:29:07
    深入浅出讲述java内部类以及使用。。。。
  • JAVA基础——接口(全网最详细教程)

    万次阅读 多人点赞 2018-05-10 09:46:42
    官方解释:Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现,因此这些方法可以在不同的地方被不同的实现,而这些实现可以具有不同的行为(功能)。 我的解释:接口...
  • Java内部类(一篇就够)

    千次阅读 多人点赞 2020-08-14 16:05:06
    Java内部类,相信大家都用过,但是多数同学可能对它了解的并不深入,只是靠记忆来完成日常工作,却不能融会贯通,遇到奇葩问题更是难以有思路去解决。这篇文章带大家一起死磕Java内部类的方方面面。 友情提示:这篇...
  •  Java接口是一系列方法的声明,是一些方法特征的集合,一个接口只有方法的特征没有方法的实现;  也就是说,接口自身自提供方法的基本声明,而不提供方法体;接口中声明的方法只能被实现该接口的子类所具体实现。...
  • Java中匿名内部类的使用

    万次阅读 多人点赞 2018-10-04 16:24:35
     匿名内部类本质上是一个重写或实现了父类或接口的子类对象。  2、使用场景:  当接口类型作为参数传递时,可以直接使用匿名内部类方式创建对应的对象 3、匿名内部类嵌套使用 ① 需求:按main方法中给...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 792,568
精华内容 317,027
关键字:

java接口放内部类