精华内容
下载资源
问答
  • 有些时候使用匿名内部类的解决方案比较简便、更切实际、更利于理解package anonymousInnerClass;import java.awt.Toolkit; import java.awt.event.*; import java.util.Date;import javax.swing.*;public class ...

    匿名内部类

    有些时候使用匿名内部类的解决方案比较简便、更切实际、更利于理解,下面是用匿名内部类实现语音时钟程序:

    package anonymousInnerClass;
    
    import java.awt.Toolkit;
    import java.awt.event.*;
    import java.util.Date;
    
    import javax.swing.*;
    
    public class AnnoymousInnerClass {
    
        /**
         * 用匿名内部类实现语音时钟程序
         * 
         * @param args
         */
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            TalkingClock clock = new TalkingClock();
            clock.start(1000, true); // 时间间隔是1s
    
            JOptionPane.showMessageDialog(null, "Quit program?");
            System.exit(0);
        }
    
    }
    
    class TalkingClock {
    
        /**
         * 
         * @param interval
         * @param beep
         * 局部类的方法只可以引用定义为final的局部变量,将beep参数声明为final
         * 对它进行初始化后不能够再进行修改,因此,就使得局部变量与在局部类内建
         * 立的拷贝保持一致。
         */
        public void start(int interval, final boolean beep) {  
            ActionListener listener = new ActionListener() {
                public void actionPerformed(ActionEvent envent) { // 匿名内部类
                    Date now = new Date();
                    System.out.println("At the tone, the time is " + now);
                    if (beep)
                        Toolkit.getDefaultToolkit().beep(); // 机器会发出蜂鸣声
                }
            };
            Timer t = new Timer(interval, listener);
            t.start();
        }
    
    }
    

    静态内部类

    有时候,使用内部类只是为了把一个类隐藏在另外一个类的内部,并不需要内部类引用外围类对象。为此,可以将内部类声明为static,以便消除产生的引用。

    package staticInnerClass;
    
    public class StaticInnerClassTest {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            double[] d= new double[20];
            for(int i=0;i<d.length;i++)
                d[i]=100*Math.random();
            ArrayAlg.Pair p = ArrayAlg.minmax(d);
            System.out.println("min="+p.getFirst());
            System.out.println("min="+p.getSecond());
    
        }
    
    }
    
    class ArrayAlg {
    
        public static class Pair {
            private double first;
            private double second;
    
            public Pair(double f, double s) {
                first = f;
                second = s;
            }
    
            public double getFirst() {
                return first;
            }
    
            public double getSecond() {
                return second;
            }
    
        }
    
        /**
         * 
         * @param values
         * @return 
         * 静态类的返回值也应该声明为静态类
         */
        public static Pair minmax(double[] values){
            double min = Double.MAX_VALUE;
            double max = Double.MIN_VALUE;
            for(double v : values){
                if(min>v) min=v;
                if(max<v) max=v;
            }
            return new Pair(min,max);
        }
    }
    
    展开全文
  • 我们常说的内部类就是最普通的内部类,而非局部匿名静态的。如: public class outer{ //外部 private String name; private int age; class inner{ //内部类 … } } 内部类可以访问外部的方法和属性,即使...

    内部类(inner class)
    内部类顾名思义就是类中类,定义在类中的类。我们常说的内部类就是最普通的内部类,而非局部匿名静态的。如:
    public class outer{ //外部类
    private String name;
    private int age;
    class inner{ //内部类

    }
    }
    内部类可以访问外部类的方法和属性,即使他们是私有的,而且内部类对于同一个包中的其他类是隐藏起来的,除了本身的外部类,其他类并不知道他的存在。
    在内部类中是无法声明静态域的,除非在前面加上final,主要是因为对于一个静态域,希望他只有一个实例,但对于每一个外部类实例,他们都有各自的内部类实例,如果不将这个域设为final的,就不能保证他的唯一性。
    内部类中也不能有static方法。

    局部内部类
    相较于前面提到的内部类,局部内部类他也是定义在类中的类,只不过他所在的位置更为苛刻,是被定义在类中局部块中的,比如在一个方法中,例:
    public class outer{ //外部类
    private String name;
    private int age;
    void method(){
    class inner{ //局部内部类

    }
    }
    }
    可以看出内部类被定义在了method方法中,这里必须说明,局部内部类前不能加public private修饰符,他的作用域是被限定在这个局部块中的,只有这个局部块能对他进行访问。

    匿名内部类(anonymous inner class)
    匿名内部类就是没有名字的内部类,创建他的通常语法格式为:
    new 父类名/接口名(){
    …//内部类的属性和方法
    }
    由于这个类没有名称,所以不能进行二次利用,当只创建类的一个对象时就可以使用匿名内部类,并且由于构造器名要与类名相同,所以在类中是不能定义构造器的。

    静态内部类
    在内部类前加上static修饰符就变成了静态内部类,静态内部类是不能引用外部类的非静态域。
    public class outer{ //外部类
    private String name;
    private int age;
    static class inner{ //静态内部类

    }
    }

    展开全文
  • 成员内部 静态内部 局部内部 匿名内部类

    内部类

    • 内部类可以直接访问外部类的成员

    •     public class Outer {
          int num = 10;
          class Inner {
              public void show() {
                  System.out.println("num=" + num);
              }
          }
      
          public static void main(String[] args) {
              Outer.Inner inner = new Outer().new Inner();
              inner.show();
              }
          }
      
      • 运行结果

    • 外部类访问内部类的成员,需要创建内部类的对象

      public class Outer1 {
      Inner inner = new Inner();
      
      public void show() {
          int num = inner.num = 20;
          System.out.println("num=" + num);
      }
      
      class Inner {
          int num;
      }
      
      public static void main(String[] args) {
          Outer1 outer = new Outer1();
          outer.show();
      }
      

      }

    • 运行结果

    静态内部类

    • 内部类中有静态方法,那么这个内部类就是静态内部类
    • 静态内部类不需要外部类对象

      public class Outer3 {
          static int num = 10;
          static class Inner {
              public static void show() {
                  System.out.println("num=" + num);
              }
          }
          public static void main(String[] args) {
              Outer3.Inner inner = new Outer3.Inner();
              inner.show();
          }
      }
      
    • 运行结果

    • 静态内部类不能访问外部类的非静态属性和方法

    成员内部类

    • 如何new对象

      • 外部类.内部类 对象名=new 外部类().new 内部类

        public class Outer {
        int num = 10;
        class Inner {
            public void show() {
                System.out.println("num=" + num);
            }
        }
        
        public static void main(String[] args) {
            //Outer.Inner inner = new Outer().new Inner();
            //相当于  Outer outer=new Outer();
            // Outer.Inner inner=outer.new Inner();
            Outer.Inner inner = new Outer().new Inner();
            inner.show();
            }
        }
        
      • 运行结果

    • 使用成员内部类会造成内存泄漏,内存越用越少。因为你在释放外部类对象的时候,内部类持有外部类对象的引用,GC不能回收

    局部内部类

    • 在外部类的方法中定义一个内部类,叫做局部内部类

      public class Outer4 {
      private String name;
      private int age;
      
      public void show() {
          class Inner {
              public void showInner(String name, int age) {
                  System.out.println(name + "今年" + age + "岁");
              }
          }
          Inner inner = new Inner();
          inner.showInner("小明", 15);
      }
      
      public static void main(String[] args) {
          Outer4 outer = new Outer4();
          outer.show();
      }
      

      }

      • 运行结果

    • 局部内部类访问方法中的变量,变量需定义成final修饰的,在内部类中访问局部变量,而定义的这个局部变量在之后还会使用,如果不定义成final修饰的,变量会随着方法的结束从栈内存中消失,就会导致局部内部类不能访问局部局部变量。

      • Inner类

        public abstract class Inner {
            public abstract void show();
        }
        
      • Outer类

        public class Outer {
            public Inner showInner(){
                final int i=10;
                Inner inner=new Inner() {
                    @Override
                    public void show() {
                        System.out.println("i="+i);
                    }
                };
                return inner;
            }
            public static void main(String[] args) {
                Outer outer=new Outer();
                Inner inner=outer.showInner();
                inner.show();
            }
        }
        
      • 运行结果

    匿名内部类

    • 匿名内部类只使用一次

      • Animal类

        public abstract class Animal {
            public abstract void eat();
        }
        
      • 测试类

        public class Test {
        
        class Cat extends Animal {
            @Override
            public void eat() {
                System.out.println("猫在吃老鼠");
            }
        }
        public static void main(String[] args) {
            new Animal() {
                @Override
                public void eat() {
                    System.out.println("猫在吃鱼");
                }
            }.eat();
        }
        }
        
      • 运行结果

    展开全文
  • 内部: 成员内部可访问外部所有的方法和成员变量。 不能有静态的方法和成员变量。...匿名内部类: 没有类名,没有class关键字也没有extends和implements等关键字修饰。 的定义和实例化同时进行。...

    内部类

        成员内部类可访问外部类所有的方法和成员变量。

        不能有静态的方法和成员变量。

    静态内部类:

        只能访问外部类的静态成员变量与静态方法。

        静态内部类的非静态成员可访问外部类的静态变量,而不可访问外部类的非静态变量。

    匿名内部类:

        没有类名,没有class关键字也没有extends和implements等关键字修饰。

        类的定义和对象的实例化同时进行。

    展开全文
  • Java 内部分四种:成员内部、局部内部静态内部匿名内部类
  • * 标题:Java内部[成员内部、局部内部匿名内部类静态内部] * * 作者:Nstar * * 时间:2020年3月13日 * * 内容: * * 问:什么是内部? * 答:在 Java 中,可以将一个定义在另一个里面或者一...
  • //嵌套分为静态嵌套和内部 内部的其余两种形式:局部 匿名内部类 // 外部 内部使“多重继承”的解决方案变得更加完整。 /* 1.静态内部可以有静态成员(方法,属性),而非静态内部则不能有静态成员...
  • 如题,在实际开发中,关于静态类静态方法、内部匿名内部类、非静态类一般都会遇到,特别是你在研究开源框架源码的时候很是常见,它是内聚性的体现。本文针对这些“概念”的实战,做些总结。
  • 分四种:成员内部、局部内部静态内部匿名内部类。 1、成员内部: 即作为外部的一个成员存在,与外部的属性、方法并列。 注意:成员内部中不能定义静态变量,但可以访问外部的所有成员。 public ...
  • 静态内部类静态内部类 首先先说一下非静态内部类静态内部类 这两者斗是依附于一个外部的,然后在该外部里面实现自身的定义,在实现上的区别就是 static 修饰与否的区别: public class InnerClassTest ...
  • 下面类B是类A的内部类。即内部类对象引用了实例化该内部对象的外围类对象。 public class A{ class B {} } 2 为什么需要内部类?(来自JAVA核心技术) 内部类方法可以访问该类定义所在的作用域中的数据,包括私有...
  • 1、静态类就是静态内部类如果一个要被声明为static的,那么只有一种情况,就是**静态内部类**。如果在外部声明为static,编译会报错,提示外部前面不允许使用修饰符static。
  • 内部:内部分为四种: 1、静态内部(static inner classes)1.1、相关使用例子:2、... inner classes):3.1、相关使用例子:4、匿名内部类(anonymous inner classes):4.1、相关使用例子: 内部
  • 附属只能用默认的访问修饰符,没有静态附属 二、内部类 1、内部类一般定义成private,直接在中其他方法中调用; 2、内部类地位可以想象成中的方法,内部类可以随意使用外部的成员变量;public class A ...
  • 分四种:成员内部、局部内部静态内部匿名内部类。 1、成员内部: 即作为外部的一个成员存在,与外部的属性、方法并列。 注意:成员内部中不能定义静态变量,但可以访问外部的所有成员。 public ...
  • 1 内部类内部类是建立在外部里面的,可以调用外部的方法,但是外部到不可以调用内部类的private属性,方法等。内部类持有外部内的原因可以理解...2 静态内部类 静态内部类并不是一开始就创建的!它与静...
  • Java 内部 分四种:成员内部、局部内部静态内部匿名内部类。 1、成员内部:即作为外部的一个成员存在,与外部的属性、方法并列。 注意:成员内部中不能定义静态变量,但可以访问外部的所有成员...
  • 前言自己看了一眼oracle官网关于内部类的介绍, 不多, 但是有些点还是要注意的....我们说的内部类, 官方的叫法是嵌套(Nested Classes), 嵌套包括两种, 分别是静态嵌套(Static Nested Classes)和内部类(In
  • 一、内部类 内部类(innerclasses):把一个放在另一个内部定义    内部类可以使用public、default、protected 、private以及static修饰。而外部顶级(我们以前接触的)只能使用public和default修饰。 注意 ...
  •  内部分为: 成员内部静态嵌套、方法内部匿名内部类。  (1)、内部仍然是一个独立的,在编译之后内部会被编译成独立的.class文件,但是前面冠以外部的类名和$符号。  (2)、内部不能用普通...
  • 1.常规内部类 内部类就像一个实例成员一样...内部类对象中不能声明静态成员,原因很简单,内部类的实例对象是外部实例对象的一个成员。(继承的或实现的接口可以有静态成员)在外部内部,可以用 Inner inn
  • Java基础笔记 – 内部 静态内部 成员内部 局部内部 匿名内部类 本文由包小卷发表于2年前 | Java基础 | 评论关闭 | 被围观 2,995 views+ 内部: 使用内部减少了命名冲突。 一个内部可以定义在一个...
  • 静态内部类的非静态成员可以访问外部静态变量,而不可访问外部的非静态变量。非静态内部类的非静态成员可以访问外部的非静态变量。 成员内部类可以随意使用外部的成员方法及成员变量,尽管这些成员被...
  • 分四种:成员内部、局部内部静态内部匿名内部类。 1、成员内部: 即作为外部的一个成员存在,与外部的属性、方法并列。 注意:成员内部中不能定义静态变量,但可以访问外部的所有成员。 public ...
  • 有些情况下,我们把一个放在另一个内部定义,称为内部类(innerclasses)。 内部类可以使用public、default、protected 、private以及static修饰。而外部顶级(我们以前接触的)只能使用public和default修饰...
  • java四种内部静态内部,成员内部,方法内部匿名内部类)详解
  • 内部:  成员内部可访问外部所有的方法和成员变量。  不能有静态的方法和成员变量。...匿名内部类:  没有类名,没有class关键字也没有extends和implements等关键字修饰。  的定义和对象...
  • 分四种:成员内部、局部内部静态内部匿名内部类。  1、成员内部: 即作为外部的一个成员存在,与外部的属性、方法并列。 注意:成员内部中不能定义静态变量,但可以访问外部的所有成员。 public...
  • 内部类不是很好理解,但说白了其实也就是一个中还包含着另外一个 如同一个人是由大脑、肢体、器官等身体结果组成,而内部类相当于其中的某个器官之一,例如心脏:它也有自己的属性和行为(血液、跳动) 显然,...
  • 内部类,又称之为嵌套,是在中在定义另外一个内部类几乎可以处于一个类内部任何位置,可以与实例变量处于同一级,或处于方法之内,甚至是一个表达式的一部分。 外部:包含内部类 内部类的名字不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 98,116
精华内容 39,246
关键字:

匿名内部类是静态的吗