精华内容
下载资源
问答
  • Java枚举解析

    2016-05-25 13:11:45
    枚举类与普通类的区别 枚举类的父类是java.lang.Enum类 非抽象枚举类默认使用final修饰,不能存在子类 枚举类的构造器只能使用private修饰符,默认就是private 枚举类的所有实例必须在枚举类的第...
        

    enum关键字与class和interface地位相同,其一样有成员变量、方法、可以实现一个或多个接口,也可以有构造器

    枚举类与普通类的区别

    • 枚举类的父类是java.lang.Enum类

    • 非抽象枚举类默认使用final修饰,不能存在子类

    • 枚举类的构造器只能使用private修饰符,默认就是private

    • 枚举类的所有实例必须在枚举类的第一行显式列出,否则这个枚举类永远不能产生实例,列出的实例,系统会自动添加public static final修饰

    抽象的枚举类,系统默认使用abstract修饰,而不用final修饰

    package com.em;
    
    public enum EmFestival {
        //会产生如下四个实例
        SPRING,SUMMER,FALL,WINTER;
    
    }
    

    枚举值就代表可能会产生的实例

    package com.em;
    
    public class FestivalTest {
        public static String jude(EmFestival v){
            switch (v) {
            case SPRING:
                return "春天";
            case SUMMER:
                return "夏天";
            case FALL:
                return "秋天";
            case WINTER:
                return "冬天";
            }
            return null;
        }
        
        public static void main(String[] args) {
            System.out.println(jude(EmFestival.SPRING));
        }
    }
    

    为什么使用枚举类?

    • 存在命名空间,可以将其他的静态常量区分开

    • 打印输出的意义明确,不想普通常量那样,都用数字表示含义,无法直接表达含义

    枚举类方法

    • compare(E o):用于与指定的枚举对象比较顺序,同一个枚举实例只能与相同类型的枚举实例进行比较。如果该枚举对象位于指定枚举对象之后,则返回正整数

    • name():返回此枚举实例的名称

    • ordinal():返回枚举值在枚举类中的索引值(从0开始)

    • toString():与name方法一致,推荐使用toString

    • valueOf():一个静态方法,用于返回指定枚举类中指定名称的枚举值

    package com.em;
    
    
    public enum EmFestival {
        //会产生如下四个实例
        SPRING("春天"),SUMMER("夏天"),FALL("秋天"),WINTER("冬天");
        private final String fest;
        private EmFestival(String fest){
            this.fest=fest;
        }
        public String getFest() {
            return fest;
        }
        
    }
    

    实现接口的枚举类

    枚举类实现接口,与正常类没有什么区别

    package com.em;
    
    import java.io.FileDescriptor;
    import java.io.IOException;
    
    import sun.nio.ch.SelChImpl;
    import sun.nio.ch.SelectionKeyImpl;
    
    
    public enum EmFestival implements SelChImpl{
    //    会产生如下四个实例
        SPRING("春天"),SUMMER("夏天"),FALL("秋天"),WINTER("冬天");
    
        @Override
        public boolean isOpen() {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public void close() throws IOException {
            // TODO Auto-generated method stub
            
        }
    
        @Override
        public FileDescriptor getFD() {
            // TODO Auto-generated method stub
            return null;
        }
    
        @Override
        public int getFDVal() {
            // TODO Auto-generated method stub
            return 0;
        }
    
        @Override
        public void kill() throws IOException {
            // TODO Auto-generated method stub
            
        }
    
        @Override
        public void translateAndSetInterestOps(int arg0, SelectionKeyImpl arg1) {
            // TODO Auto-generated method stub
            
        }
    
        @Override
        public boolean translateAndSetReadyOps(int arg0, SelectionKeyImpl arg1) {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public boolean translateAndUpdateReadyOps(int arg0, SelectionKeyImpl arg1) {
            // TODO Auto-generated method stub
            return false;
        }
    
        @Override
        public int validOps() {
            // TODO Auto-generated method stub
            return 0;
        }
    
        private final String fest;
        private EmFestival(String fest){
            this.fest=fest;
        }
        public String getFest() {
            return fest;
        }
        
    }
    

    包含抽象方法的枚举类

    枚举类里定义抽象方法时不能使用abstract关键字将枚举类定义成抽象类(因为系统自动会添加abastract),但因为枚举类需要显式创建枚举值,而不是作为父类,所以定义每个枚举值时必须为抽象方法提供实现,否则出现编译错误

    package com.em;
    
    public enum EmFestival {
        // 会产生如下四个实例
        SPRING("春天") {
            @Override
            public String getFestival() {
                return "春天";
            }
        },
        SUMMER("夏天") {
            @Override
            public String getFestival() {
                return "夏天";
            }
        },
        FALL("秋天") {
            @Override
            public String getFestival() {
                return "秋天";
            }
        },
        WINTER("冬天") {
            @Override
            public String getFestival() {
                return "冬天";
            }
        };
        public abstract String getFestival();
    
        private final String fest;
    
        private EmFestival(String fest) {
            this.fest = fest;
        }
    
        public String getFest() {
            return fest;
        }
    
    }
    

    更多内容可以关注微信公众号,或者访问AppZone网站

    http://7xp64w.com1.z0.glb.clouddn.com/qrcode_for_gh_3e33976a25c9_258.jpg

    展开全文
  • 1)auto这个关键字用于声明变量生存期为自动,即将不在任何类、结构、枚举、联合函数中定义变量视为全局变量,而在函数中定义变量视为局部变量。这个关键字不怎么多写,因为所有变量默认就是auto。 (2)...
  • 常见值类型数据有:整值型(整形,浮点型,十进制型),布尔类型,枚举类型; 引用类型有:接口,数组,Object类型,类,委托,字符串,null类型。 在C#中每种类型存储方式有两种:1)分配在托管栈中;2)...


    在C#中值类型的变量直接存储数据,而引用类型的变量持有的是数据的引用,数据存储在数据堆中。

    常见的值类型数据有:整值型(整形,浮点型,十进制型),布尔类型,枚举类型;

    引用类型有:接口,数组,Object类型,类,委托,字符串,null类型。

    在C#中每种类型的存储方式有两种:1)分配在托管栈中;2)分配在托管堆中;

    内存的分配有CLR管理(即公共语言运行时),这两种方法的区别是:

    1)分配在托管栈中的变量会在创建它们的方法返回时自动释放,例如在一个方法中声明Char型的变量UserInput=C,当实例化它的方法结束时,UserInput变量在栈上占用的内存就会自动释放;

    2)分配在托管堆中的变量并不会在创建它们的方法结束时释放内存,它们所占用的内存会被CLR中的垃圾回收机制释放。

    看下面的代码:

    1 static void Main(string[] args)
    2         {
    3             //当nStudent声明并赋值是,这时在托管栈上就会开辟一块内存来存储nStudent的值,当实例化nStudent的Main()方法结束时,
    4             //nStudent在托管栈上占用的内存会自动释放。
    5             int nStudent = 0;
    6             //当声明strStuName时,这个时候“小明”存储在托管堆中,而托管栈中存储的是strStuName指向的引用。
    7             string strStuName = "小明";

    9             Console.WriteLine("学生的总数是{0},五号的名字是{1}", nStudent, strStuName);
    10             Console.ReadKey();
    11         }

    装箱和拆箱

    当值类型的数据转换成引用类型时,CLR会先在托管堆配置一块内存,将值类型的数据复制到这块内存,然后再让托管栈上的引用类型的变量指向这块内存,这样的过程称为装箱。相反的话,有引用类型转换成值类型的话就称为拆箱。

    一般情况下,.NET会主动的帮我们完成装箱操作,但是拆箱并非主动,我们必须知道拆箱对象的实力类型,然后明确的去执行拆箱操作。

    1 int BirthdayNum = 1989;
    2             object BoxBirthdayNum = BirthdayNum;//系统自动装箱
    3             int nBirthdayNum = (int)BoxBirthdayNum;//明确数据类型的拆箱

    因为花费了更多的时间,所以装箱和拆箱对程序的性能有一定的影响。

    --------------------------------------------------------------------------------------------------------------------------------------

    类型推断

    在C#中有两种类型的数据,一种是值类型,另一种是引用类型。

    值类型包括:内置值类型、用户自定义值类型、和枚举,如 int,float bool 等,以及struct等。

    引用类型包括接口类型、用户自定义的类、委托等。如 string 、DateTime、数组等。

    值类型是存储在堆栈中,而引用类型是存储在托管堆上,C#程序首先被编译成IL程序,然后在托管执行。值类型直接从堆栈中里面取值,而引用类型必须要先从堆栈里面取出它的地址,再根据这个地址在堆里找到对应的值。


    值类型与饮用类型的本质区别有以下几点:

    1.内存分配: 值类型是分配在栈中的;而引用类型是分配在堆中。

    2.效率: 值类型效率高,不需要地址转换;引用类型效率较低,需要进行地址转换。

    3.内存回收: 值类型使用完后立即回收;引用类型使用完后不立即回收,而是交给GC处理回收。

    4.赋值操作: 值类型是创建一个新对象;引用类型创建一个引用。

    5.类型扩展: 值类型不易扩展,所有值类型都是密封(seal)的,所以无法派生出新的值类型;引用类型具有多态的特性方便扩展。

    这是别人的总结,我在这里拿来用下。

    下面我在说说它们在用法上的区别了,C#之所以要分这两种数据类型的原因是达到更好的性能,把一些基本类型如int、bool规定为值类型,而把包含许多字段的较大类型规定为引用类型,如用户自定义的类。值类型主要是负责存储数据,引用类更多是用在代码的重用性上。

    从C#3.0开始,C#引入了一个隐式类型推断的关键字var,编译器可以通过它的初始值来判断变量的具体类型。var只能用于局部变量的声明,不能用于字段级的变量声明。使用var关键字时,var必须得有初始值,这样编译器才能判断是否是真实变量。

    1 class Program
    2     {
    3         static void Main(string[] args)
    4         {
    5             var i = 10;//隐式类型
    6             int m = 10;//显示类型

    8             var Program=new Program();
    9             Program.nAge = 20;
    10             Program.SayHello();
    11         }
    12 
    13         private int nAge;
    14         public void SayHello()
    15         {
    16             var message = "my age is {0}";
    17             Console.WriteLine(message, nAge);
    18         }
    19     }

    message初始值的变量为字符串类型,因此编译器可以推断其类型为String类型。

    转载链接:http://www.cr173.com/html/17724_1.html


    展开全文
  •  hashTable 线程安全 不允许有null值 效率低 方法是Synchronized HashTable 数组默认大小是11 增加方式为 old*2+1 HashTable 使用Enumeration(枚举)方式实现2. HashMap 线程不安全 允许有nul...

    HashTable HashMap TreeMap 本质区别

    1.      hashTable 线程安全  不允许有null的键和值  效率低  方法是Synchronized的

            HashTable 数组默认大小是11  增加方式为 old*2+1

            HashTable 使用Enumeration(枚举)方式实现

    2.      HashMap  线程不安全  允许有null的键和值  效率高一点  方法不是Synchronize要提供的同步

            HashMap  数组默认大小是16  增长方式是2的指数倍

            HashMap  使用Interator(迭代方式)调用

    3.      TreeMap 能够保存记录 按照键排序 默认升序排序

     

    HashTable HashMap TreeMap 使用区别

    1.      HashMap 的元素排序方式不固定 (通过hashcode对其内容进行快速查找)

            TreeMap 的元素都保持固定排序模式

    2.      HashMap 适用于 在Map中插入 删除 定位元素

            TreeMap  适用于按照自然顺序或自定义排序遍历键key

    分析: 一般情况 HashMap比TreeMap 快一些  若需要排序的Map 才使用TreeMap

    展开全文
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。 值类型包括C#基本类型(用...

    解析:CLR支持两种类型:值类型和引用类型。用Jeffrey Richter(《CLR via C#》作者)的话来说,“不理解引用类型和值类型区别的程序员将会把代码引入诡异的陷阱和诸多性能问题”。这就要求我们正确理解和使用值类型和引用类型。 值类型包括C#的基本类型(用关键字int、char、float等来声明),结构(用struct关键字声明的类型),枚举(用enum关键字声明的类型);而引用类型包括类(用class关键字声明的类型)和委托(用delegate关键字声明的特殊类)。 C#中的每一种类型要么是值类型,要么是引用类型。所以每个对象要么是值类型的实例,要么是引用类型的实例。值类型的实例通常是在线程栈上分配的(静态分配),但是在某些情形下可以存储在堆中。引用类型的对象总是在进程堆中分配(动态分配)。

    (1)在C#中,变量是值还是引用仅取决于其基本数据类型。 C# 的基本数据类型都与平台无关。C#的预定义类型并没有内置于语言中,而是内置于.NET Framework中。.NET使用通用类型系统(CTS)定义可以在中间语言(IL)中使用的预定义数据类型。C#中所有的数据类型都是对象。它们可以 有方法、属性等。例如,在C#中声明一个int变量时,声明实际上是CTS(通用类型系统)中System.Int32的一个实例:

    int i; i = 1; string s; s = i.ToString();

      (2)System.Object和System.ValueType。 引 用类型和值类型都继承自System.Object类。不同的是,几乎所有的引用类型都直接从System.Object继承,而值类型则继承其子类,即 直接继承System.ValueType。作为所有类型的基类,System.Object提供了一组方法,这些方法在所有类型中都能找到。其中包含 toString方法及clone等方法。System.ValueType继承System.Object。它没有添加任何成员,但覆盖了所继承的一些 方法,使其更适合于值类型。 (3)值类型。 C#的所有值类型均隐式派生自System.ValueType: 结构体:struct(直接派生于System.ValueType)。 数 值类型:整型,sbyte(System.SByte的别 名),short(System.Int16),int(System.Int32),long(System.Int64),byte(System.Byte),ushort(System.UInt16),uint(System.UInt32),ulong(System.UInt64),char(System.Char)。 浮点型:float(System.Single),double(System.Double)。 用于财务计算的高精度decimal型:decimal(System.Decimal)。 bool型:bool(System.Boolean的别名)。 用户定义的结构体(派生于System.ValueType)。 枚举:enum(派生于System.Enum)。 可空类型。 每种值类型均有一个隐式的默认构造函数来初始化该类型的默认值。例如:

    int i = 0; 等价于: int i = new int();

    使用new运算符时,将调用特定类型的默认构造函数并对变量赋予默认值。在上例中,默认构造函数将值0赋给了i。 所有的值类型都是密封(seal)的,所以无法派生出新的值类型。 值 得注意的是,System.ValueType直接派生于System.Object。即System.ValueType本身是一个类类型,而不是值类 型。其关键在于ValueType重写了Equals()方法,从而对值类型按照实例的值来比较,而不是引用地址来比较。可以用 Type.IsValueType属性来判断一个类型是否为值类型:

    TestType testType = new TestType ();
    if (testTypetype.GetType().IsValueType)
    {    
      Console.WriteLine("{0} is value type.", testType.ToString());
    }

    (4)引用类型

    C#有以下一些引用类型:

    数组(派生于System.Array)

    用户需定义以下类型。

    类:class(派生于System.Object);

    接口:interface(接口不是一个“东西”,所以不存在派生于何处的问题。接口只是表示一种contract约定[contract])。

    委托:delegate(派生于System.Delegate)。

    object(System.Object的别名);

    字符串:string(System.String的别名)。

    可以看出:

    引用类型与值类型相同的是,结构体也可以实现接口;引用类型可以派生出新的类型,而值类型不能;引用类型可以包含null值,值类型不能;引用类型变量的赋值只复制对象的引用,而不复制对象本身。而将一个值类型变量赋给另一个值类型变量时,将复制包含的值。

    (5)内存分配。

    值类型的实例经常会存储在栈上的。但是也有特殊情况。如果某个类的实例有个值类型的字段,那么实际上该字段会和类实例保存在同一个地方,即堆中。不过引用类 型的对象总是存储在堆中。如果一个结构的字段是引用类型,那么只有引用本身是和结构实例存储在一起的(在栈或堆上,视情况而定)。如下例所示:

    public struct ValueTypeStruct
    {
        private object referenceTypeObject;
        public void Method()
        {
            referenceTypeObject = new object();
            object referenceTypeLocalVariable = new object();
        }
    }
    ValueTypeStruct valueTypeStructInstance = new ValueTypeStruct();
    valueTypeStructInstance.Method();
    //referenceTypeObject 和 referenceTypeLocalVariable
    都在哪存放? 单看valueTypeStructInstance,这是一个结构体实例,感觉似乎是整块都在栈上。但是字段referenceTypeObject是引用类型,局部变量referenceTypeLocalVarible也是引用类型。
     
    public class ReferenceTypeClass
    {
        private int _valueTypeField;
        public ReferenceTypeClass()
        {
            _valueTypeField = 0;
        }
        public void Method()
        {
            int valueTypeLocalVariable = 0;
        }
    }
    ReferenceTypeClass referenceTypeClassInstance = new ReferenceTypeClass();
    // _valueTypeField在哪存放?
    referenceTypeClassInstance.Method();
    // valueTypeLocalVariable在哪存放?

    referenceTypeClassInstance 也有同样的问题,referenceTypeClassInstance本身是引用类型,似乎应该整块部署在托管堆上。但字段 _valueTypeField是值类型,局部变量valueTypeLocalVariable也是值类型,它们究竟是在栈上还是在托管堆上?

    对上面的情况正确的分析是:引用类型在栈中存储一个引用,其实际的存储位置位于托管堆。为了方便,简称引用类型部署在托管堆上。值类型总是分配在它声明的地方,作为字段时,跟随其所属的变量(实例)存储;作为局部变量时,存储在栈上。

    (6)辨明值类型和引用类型的使用场合。

    在C#中,我们用struct/class来声明一个类型为值类型/引用类型。考虑下面的例子:

    SomeType[] oneTypes = new SomeType[100];

    如果SomeType是值类型,则只需要一次分配,大小为SomeType的100倍。而如果SomeType是引用类型,刚开始需要100次分配,分配后 数组的各元素值为null,然后再初始化100个元素,结果总共需要进行101次分配。这将消耗更多的时间,造成更多的内存碎片。所以,如果类型的职责主 要是存储数据,值类型比较合适。

    一般来说,值类型(不支持多态)适合存储供 C#应用程序操作的数据,而引用类型(支持多态)应该用于定义应用程序的行为。通常我们创建的引用类型总是多于值类型。如果满足下面情况,那么我们就应该创建为值类型:

    该类型的主要职责用于数据存储。

    该类型的共有接口完全由一些数据成员存取属性定义。

    该类型永远不可能有子类。 该类型不具有多态行为。

    答案:在C#中,变量是值还是引用仅取决于其数据类型。

    C#的值类型包括:结构体(数值类型、bool型、用户定义的结构体),枚举,可空类型。

    C#的引用类型包括:数组,用户定义的类、接口、委托,object,字符串。数组的元素,不管是引用类型还是值类型,都存储在托管堆上。

    引用类型在栈中存储一个引用,其实际的存储位置位于托管堆。简称引用类型部署在托管推上。值类型总是分配在它声明的地方:作为字段时,跟随其所属的变量(实 例)存储;作为局部变量时,存储在栈上。值类型在内存管理方面具有更好的效率,并且不支持多态,适合用做存储数据的载体;引用类型支持多态,适合用于定义 应用程序的行为。

    转载于:https://www.cnblogs.com/leo7718/p/3758009.html

    展开全文
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。 值类型包括C#基本类型...
  • 9. 适配器模式、外观模式以及装饰者模式之间的区别。 1. 生活中的适配器 上图,中间的适配器改变了插座的接口,最后成功让电脑能够使用充电。 接下来让我们看看,现有系统、适配器厂商类之间的关系。 2....
  • C#值类型引用类型解析

    千次阅读 2012-10-24 19:05:42
    在C#中值类型的变量直接存储数据,而引用类型的变量持有的是数据的引用,数据存储在数据堆中。 常见的值类型数据有:整值型(整形,浮点型,十...内存的分配有CLR管理(即公共语言运行时),这两种方法的区别是: 1)
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。 值类型包括C#基本类型(用...
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。 值类型包括C#基本类型...
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。值类型包括C#基本类型(用...
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。 值类型包括C#基本类型(用...
  • 枚举 类型推论 类型兼容性 高级类型 Symbols Iterators Generators 模块 命名空间 命名空间模块 模块解析 声明合并 JSX Decorators 混入 三斜线指令 JavaScript文件里类型检查 实用工具类型 如何书写声明...
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。 值类型包括C#基本类型(用...
  • 用Jeffrey Richter(《CLR via C#》作者)话来说,“不理解引用类型值类型区别的程序员将会把代码引入诡异陷阱诸多性能问题”。这就要求我们正确理解使用值类型引用类型。 值类型包括C#基本类型...
  • 在C#中值类型的变量直接存储数据,而引用类型的变量持有的是数据的引用,数据存储在数据堆中。 常见的值类型数据有:整值型(整形,浮点型,十...内存的分配有CLR管理(即公共语言运行时),这两种方法的区别是:...
  • 答案: for in 会遍历自身及原型链上枚举属性 ...ECMAScript 将对象属性分为两种:数据属性访问器属性。 var parent = Object.create(Object.prototype, { a: { value: 123, writable: true, enu
  • 《深入理解C++11:C++11新特性解析与应用》内容简介:国内首本全面深入解读C++11新...附录中则介绍了C++11标准与其他相关标准兼容性和区别、C++11中弃用特性、编译器对C++11支持情况,以及学习C++11相关资源。
  • 自己购买电子书, 现上传供大家下载!!! 《深入理解C++11:C++11新特性解析与应用...附录中则介绍了C++11标准与其他相关标准兼容性和区别、C++11中弃用特性、编译器对C++11支持情况,以及学习C++11相关资源
  • 基本上c语言中常量类似但有区别 在const关键字基础上添加了readonlyreadonly关键字在笔记中说明 常量是固定值程序执行期间不会改变常量可以是任何基本数据类型比如整数常量浮点常量字符常量或者字符串常量还有...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 191
精华内容 76
关键字:

枚举和解析的区别