精华内容
下载资源
问答
  • java 静态内部类

    2017-12-08 17:57:32
    今天闲来无事 看了看effective java这书的时候 看到内部类这一块,其实内部类说熟悉不熟悉 ,但是也用过,只是我们用的比较少 ...1.静态内部类跟静态方法一样,只能访问静态的成员变量和方法,不

    今天闲来无事 看了看effective java这书的时候 看到内部类这一块,其实内部类说熟悉不熟悉 ,但是也用过,只是我们用的比较少

    如果一个类要被声明为static的,只有一种情况,就是静态内部类。如果在外部类声明为static,程序会编译都不会过。在一番调查后个人总结出了3点关于内部类和静态内部类(俗称:内嵌类)

    1.静态内部类跟静态方法一样,只能访问静态的成员变量和方法,不能访问非静态的方法和属性,但是普通内部类可以访问任意外部类的成员变量和方法

     

    2.静态内部类可以声明普通成员变量和方法,而普通内部类不能声明static成员变量和方法。

     

    3.静态内部类可以单独初始化: 

    Inner i = new Outer.Inner();

     普通内部类初始化:

    Outer o = new Outer();
    Inner i = new o.Inner();

     

      静态内部类使用场景一般是当外部类需要使用内部类,而内部类无需外部类资源,并且内部类可以单独创建的时候会考虑采用静态内部类的设计,在知道如何初始化静态内部类,在《Effective Java》第二章所描述的静态内部类builder阐述了如何使用静态内部类:

    复制代码
    public class Outer {
        private String name;
        private int age;
    
        public static class Builder {
            private String name;
            private int age;
    
            public Builder(int age) {
                this.age = age;
            }
    
            public Builder withName(String name) {
                this.name = name;
                return this;
            }
    
            public Builder withAge(int age) {
                this.age = age;
                return this;
            }
    
            public Outer build() {
                return new Outer(this);
            }
        }
    
        private Outer(Builder b) {
            this.age = b.age;
            this.name = b.name;
        }
    }
    复制代码

    静态内部类调用外部类的构造函数,来构造外部类,由于静态内部类可以被单独初始化说有在外部就有以下实现:

    public Outer getOuter()
    {
        Outer outer = new Outer.Builder(2).withName("Yang Liu").build();
        return outer;
    }

     

    对于静态类总结是:1.如果类的构造器或静态工厂中有多个参数,设计这样类时,最好使用Builder模式,特别是当大多数参数都是可选的时候。

                                   2.如果现在不能确定参数的个数,最好一开始就使用构建器即Builder模式。


    展开全文
  • java静态内部类

    千次阅读 2015-07-01 11:25:23
    转载:... 如果一个类要被声明为static,只有一种情况,就是静态内部类。即外部类是不能被static修饰的。 静态内部类和内部类的区别: 1、静态内部类和静态方法一样,只能访问外部类的静

    转载:http://www.cnblogs.com/Alex--Yang/p/3386863.html

       http://book.51cto.com/art/201202/317517.htm


    如果一个类要被声明为static,只有一种情况,就是静态内部类。即外部类是不能被static修饰的。

    静态内部类和内部类的区别:


    1、静态内部类和静态方法一样,只能访问外部类的静态的成员和方法。

    2、静态内部类可以定义普通的成员变量和方法。普通内部类不能声明static的变量和方法。

    3、静态内部类可以单独初始化

    Inner i = new Outer.Inner();

       普通内部类的初始化

    Outer o = new Outer();
    Inner i = o.new Inner();

    4、静态内部类不持有外部类的引用,所以只能访问外部类的静态方法和静态的属性(即使这些静态的方法和属性是private,也是可以访问的)。

         普通的内部类是持有外部类的引用。所以普通的内部类可以直接访问外部类的属性、方法、即使是private也可以访问。(普通类的实例不能访问类的私有方法和属性)


    静态内部类的使用场景是: 当外部类需要是用内部类,而内部类无需外部类的资源,并且内部类可以单独创建的时候,会考虑使用静态内部类。


    在《Effective Java》第二章所描述的静态内部类builder阐述了如何使用静态内部类:


    public class Outer {
        private String name;
        private int age;
    
        public static class Builder {
            private String name;
            private int age;
    
            public Builder(int age) {
                this.age = age;
            }
    
            public Builder withName(String name) {
                this.name = name;
                return this;
            }
    
            public Builder withAge(int age) {
                this.age = age;
                return this;
            }
    
            public Outer build() {
                return new Outer(this);
            }
        }
    
        private Outer(Builder b) {
            this.age = b.age;
            this.name = b.name;
        }
    }

    静态内部类调用外部类的构造函数,来构造外部类,由于静态内部类可以被单独初始化说有在外部就有以下实现:


    public Outer getOuter()
    {
        Outer outer = new Outer.Builder(2).withName("Yang Liu").build();
        return outer;
    }


    总结:

    1、如果类的构造器或者静态工厂中有多个参数,设计这样类时,最好使用builder模式,特别是大多数参数都是可选的时候。

             2、如果现在不能确定参数的个数,最好一个开始就使用构造器即builder模式。

           3、静态内部类提高了封装性,和代码的可读性。


    展开全文
  • 首先我们看下RecyclerView的ViewHolder...java静态内部类: static class EndViewHolder extends BlocksView.ViewHolder { public EndViewHolder(View itemView) { super(itemView); itemView.setMinimumHeight

    首先我们看下RecyclerView的ViewHolder的写法,java和kotlin分别用静态内部类进行实现,代码是随意找的:

    java静态内部类:

        static class EndViewHolder extends BlocksView.ViewHolder {
    
            public EndViewHolder(View itemView) {
                super(itemView);
                itemView.setMinimumHeight(ResourceUtil.getDimen(R.dimen.dimen_106dp));
            }
        }

    kotlin静态内部类:

        class FeedViewHolder(itemView: View?, context: Context) : RecyclerView.ViewHolder(itemView) {
            var iv_photo: ImageView = itemView?.findViewById(R.id.iv_photo) as ImageView
            var tv_title: TextView = itemView?.findViewById(R.id.tv_title) as TextView
            var tv_time: TextView = itemView?.findViewById(R.id.tv_detail) as TextView
            init {
                tv_title?.typeface = Typeface.createFromAsset(context?.assets, "fonts/FZLanTingHeiS-L-GB-Regular.TTF")
    
            }
        }

    从上面两个代码片段能很明显看出来java的静态内部类需要static关键字修饰,而kotlin直接用class就表示该类为静态内部类。

    java普通内部类不用修饰,直接创建即为内部类;而kotlin需要用inner关键字修饰,表示内部类。

    详细对比:

    java内部类、静态内部类:

    /**外部内*/
    public class InnerClassJava {
    
        private int a;
    
        //静态内部类和非静态内部类的区别
        //非静态内部类,持有外部类的状态的
        public class Inner{
            public void hello(){
                //可以访问到外部类的成员变量
                System.out.println(a);
                System.out.println(InnerClassJava.this.a);
            }
        }
        //静态内部类
        public static class StaticInner{
            public void hello(){
                //不能访问外部类的成员变量
                //System.out.println(a);
            }
        }
    
        public static void main(String[] args) {
            //如果要实例化非静态内部类Inner
            //Inner inner = new Inner();  //这样肯定是不行的
            //如果是静态内部类就可以随便new了
            //Inner inner = new Inner();
    
    
            //首先要实例化外部类
            InnerClassJava innerClassJava = new InnerClassJava();
            //再用外部类的实例去new内部类
            Inner inner = innerClassJava.new Inner();
    
            //在Java里面写一个匿名内部类
            View view = new View();
            //在java中,匿名内部类就能继承一个类,不能实现接口
            view.setOnClickListener(new OnClickListener() {
                @Override
                public void onClick() {
    
                }
            });
        }
    }

    看一下Kotlin中的内部类:

    /**外部类*/
    open class Outter{
    
        val a: Int = 0
        //默认静态内部类
        //不能访问外部类的成员变量
        class StaticInner{
            fun hello(){
                //println(a)
            }
        }
    
        //非静态内部类,关键字inner
        //可以访问外部类的成员变量
        inner class Inner{
            fun hello(){
                println(a)
                println(this@Outter.a)
            }
        }
    }
    
    /**定义一个点击监听的接口*/
    interface OnClickListener{
        fun onClick()
    }
    
    /**定义一个View类*/
    class View{
        //可变的
        var onClickListener: OnClickListener ?= null
    }
    fun main(args: Array<String>) {
        //静态内部类实例化
        val staticInner = Outter.StaticInner()
        //非静态内部类实例化
        val inner = Outter().Inner()
    
        //注册view
        val view = View()
        //这边涉及到一个匿名内部类,就是没有名字的内部类,继承一下Outter类
        //kotlin中匿名内部类,就和普通的类一样,可以继承一个类,实现多个接口
        view.onClickListener = object: Outter(),OnClickListener{
            override fun onClick() {
                TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
            }
        }
    }

     

    展开全文
  • 一、非静态内部类: 1、变量和方法不能声明为静态的。(类的编译顺序:外部类–静态方法或属性–内部类,如果内部类声明为静态的,造成编译顺序冲突。个人理解) 2、实例化的时候需要依附在外部类上面。比如:B是A的非...

    一、非静态内部类:

    1、变量和方法不能声明为静态的。(类的编译顺序:外部类–静态方法或属性–内部类,如果内部类声明为静态的,造成编译顺序冲突。个人理解)

    2、实例化的时候需要依附在外部类上面。比如:B是A的非静态内部类,实例化B,则:A.B b = new A().new B();

    3、内部类可以引用外部类的静态或者非静态属性或者方法。

    二、静态内部类:

    1、属性和方法可以声明为静态的或者非静态的。

    2、实例化静态内部类:比如:B是A的静态内部类,A.B b = new A.B();

    3、内部类只能引用外部类的静态的属性或者方法。

    4、如果属性或者方法声明为静态的,那么可以直接通过类名直接使用。比如B是A的静态内部类,b()是B中的一个静态属性,则可以:A.B.b();

    三、关于java静态方法的相关总结:

    一个类的静态方法只能访问静态属性(静态方法是属于类的,而普通方法是属于对象的。)

    一个类的静态方法不能够直接调用非静态方法;
    如访问控制权限允许,static 属性和方法可以使用类名加“.”方式调用;当然也可以使用实例加“.”方式调用;
    静态方法中不存在当前对象,因而不能使用“this”,当然也不能使用”super”;
    静态方法不能被非静态方法覆盖;
    构造方法不允许声明为 static 的;
    局部变量不能使用static修饰;

    问题:为什么一个类的静态方法只能访问静态属性或静态方法?

    回答:静态方法是属于类的,而普通方法是属于对象的。
    属于类的静态方法可以在对象不存在的时候就能访问到,而普通方法必须先new一个对象才能用这个对象访问
    。当我们访问调用静态方法的时候(使用类名.静态方法名)这个时候就没有对象创建,所以普通方法是访问不到的。
    为了避免这种错误,所以java就不允许在静态方法中访问非静态方法。可以想一下main方法。

    原文地址:http://www.cnblogs.com/aademeng/articles/6192944.html

    展开全文
  • java 静态内部类的使用

    万次阅读 2018-11-05 19:06:39
    java 静态内部类的使用
  • Java中内部类加载时间:一般是只有运到了才会初始化,而不是外部内加载的时候(不管是静态还是非静态内部类)。 注意到一个问题: 内部类只有是静态的,其内部类中才能有静态属性和静态方法; 如果内部类非静态的...
  • 最近遇到一个疑惑,为啥静态内部类不可以继承非静态内部类理解呢?一查资料,都是千篇一律,都是对内部类的讲解,都不能直接找到这个疑惑的答案。请教了一些大神,最后明白了其中原委,这里做个记录,哪天又不清楚了...
  • JAVA 静态内部类用法

    千次阅读 2016-01-27 14:13:12
    Java静态内部类(static class)   在一个类中创建另外一个类,叫做成员内部类。这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。   一、静态内部类的使用目的。 在 ...
  • Java静态内部类怎么调用外部类的泛型,2个泛型可以名字一样,但是没有任何关系啊。。。。。。。
  • Java 静态内部类 与 内部类区别

    千次阅读 2018-05-30 10:52:37
    静态内部类的作用:只是为了降低包的深度,方便类的使用,静态内部类适用于包含类当中,但又不依赖于外在的类,不用使用外在类的非静态属性和方法,只是为了方便管理类结构而定义。在创建静态内部类的时候,不需要...
  • 静态内部类,都不能有static成员和static方法。静态属性不依赖于对象,因为它保存在jvm的静态区,所以访问时不需要有存活的对象;而非静态内部类也相当于外部类的非静态属性,而它的表现也符合非静态(需要外部类...
  • java 静态内部类和Builder模式

    千次阅读 2015-10-30 22:29:10
    java中可以在类内部定义静态内部类。可以用于构建多参数的对象,并且保证类的一致性。 2. 与非静态内部内的区别 静态内部类与非静态内部类的区别如下: 在非静态内部类中不可以声明静态成员。只有静态内部...
  • JAVA静态内部类加载顺序

    千次阅读 2019-05-23 21:16:17
    今天偶然机会碰到了JAVA静态内部类加载实例,原本以为和外部类一样,但实验结果确出人意料,特此记录。希望大牛们能指出原因所在。 首先给上代码: public class LoadTest2 { public static class Inner{//...
  • Java 静态内部类作用

    千次阅读 2019-03-07 11:13:31
    需要了解2个概念:内部类和静态修饰符static 1)首先,用内部类是因为内部类与所在外部类有一定的关系,往往只有该外部类调用此内部类。所以没有必要专门用一个Java文件...这样静态内部类就可以理解了,因为这个类...
  • Java静态内部类详解

    千次阅读 多人点赞 2018-09-08 11:26:13
    1. 什么情况下可以使用静态的类?...2.静态内部类的使用条件限制 静态的内部类中不能访问外部类中非静态的变量和方法。 class Outer{ public String name = "什么神奇"; private int...
  • Java静态内部类(static class)

    万次阅读 多人点赞 2018-02-24 17:03:47
    一、静态内部类的使用目的。 在定义内部类的时候,在其前面加上一个权限修饰符static。这个内部类就变为了静态内部类。如在进行代码程序测试的时候,如果在每一个Java源文件中都设置一个主方法(主方法是某个应用...
  • Java静态内部类的作用

    千次阅读 2019-02-22 05:00:22
    在一个类中创建另外一个类,叫做成员内部类。这个成员内部类可以静态...不过在特定的情况下,静态内部类也能够发挥其独特的作用。   一、静态内部类的使用目的。   在定义内部类的时候,可以在其前面加上一个权...
  • Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。想要理解static应用于内部类时的含义,你就必须记住,普通的内部类对象...
  • java静态内部类加载顺序

    千次阅读 2018-12-13 21:43:01
    静态内部类加载顺序 我们先来区分一下两个概念:类加载、加载。 类加载的过程包括加载,初始化,验证,解析,准备,初始化等五个过程。加载是类加载的一部分。 区分完这两个概念之后我们再来看下面的问题。 我们...
  • java静态内部类了解一下

    千次阅读 2018-11-08 17:20:16
    Java的内部类主要分为成员内部类、局部内部类、匿名内部类、静态内部类。 public class 外部类的名称 { //外部类的成员 public class 内部类的名称 { //内部类的成员 } } 内部类的作用; ...
  • public class Test { public static void main(String args[]) { Out out=new Out(); } } class Out { Man m=new Man();... static class In { ...不是初始化了内部类吗,为什么没有加载内部类的成员变量?
  • Java静态内部类特性详解

    千次阅读 2017-07-08 12:46:14
      关于静态内部类,《Effective Java》一书中还给出了一个这样的使用例子: public class Outer { private String name; private int age; public static class Builder { private String name; ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 409,882
精华内容 163,952
关键字:

java静态内部类

java 订阅