barriers / 阅读 / 详情

在java中,如何复制一个对象?比如说string对象

2023-07-27 03:14:15
共3条回复
可可

可以使用clone来实现,clone用于为引用类型的复制

1.使用clone方法的类必须先实现Cloneable接口,不然clone方法会直接返回CloneNotSupportedException不支持克隆的异常

2、实现Cloneable接口的类应该使用公共方法重写 Object.clone(它是受保护的)。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的,也无法保证它将获得成功。

3、在Java.lang.Object类中克隆方法是这么定义的:

protected Object clone()

throws CloneNotSupportedException

创建并返回此对象的一个副本。表明是一个受保护的方法,同一个包中可见。

按照惯例,返回的对象应该通过调用 super.clone 获得。

详见关于clone的API文档

小教板

可以使用clone()方法。

北有云溪

clone()方法

相关推荐

Cloneables应该实现的方法

方法如下:1、实现Cloneable接口表明该类的对象是允许克隆的。 2、允许克隆的意思是:可以调用clone()方法。 3、深拷贝还是浅拷贝,取决于如何重写Object的clone()方法。
2023-07-25 14:52:001

Java 中 如果clone为什么必须实现Cloneable接口

---------转载自网络-------1 Cloneable是标示接口与java.io.Serializable类似,用于告知JVM该对象实现clone。并且super.clone()可以返回一个复制。2 很多时候,会把protected的clone方法修改为public,暴露给其他人可以使用
2023-07-25 14:52:084

Java中对对象克隆,一定要实现Cloneable接口吗?

是的,,,
2023-07-25 14:52:257

在java中怎样在主方法中定义一个输入的对象

问题1:声明实现cloneable接口是为了让Employee类的对象能够通过调用自身的clone()方法实现实现“深层复制”操作,所谓“深层复制”指的就是对象字段的内容能够自我克隆,即此时此刻对象的安全拷贝,这与创建此对象的类的另一个新实例所使用的通常的内存分配方式不同,因为后者只是用被复制对象字段的内容初始化新对象的所有字段,实现cloneable接口就能保证对象使用前者的内存分配方式,尽管它只是一个标志(只有字段,没有方法),但是它有底层的一些功能。如果不实现cloneable,那么在Employee类的对象上调用clone()方法就会抛出CloneNotSupportedException异常。问题2:object类中有原始的clone()方法,但是Employee类继承自object类(object类是所有类的超类),所以override其clone()方法时可以将object类型改变为子类Employee的类型.问题3:因为从上面的代码不能看出Date类是否实现了cloneable接口,如果没有实现就必须抛出CloneNotSupportedException,否则在对象salary上调用clone方法将会导致在运行时出现问题。问题4:子类对象转化为父类时是隐式转换,父类对象转化为子类时是显式转换,必须使用()进行强制类型转换。问题5:从这里看来,salary对象引用指向的是Date类,如果Date类中没有重写clone()方法,那么salary.clone()返回的是Date类的超类对象的拷贝,这时就得使用强制类型转换。 如果帮助到您,请记得采纳为满意答案哈,谢谢!祝您生活愉快! vae.la
2023-07-25 14:52:431

java如何实现对象的深克隆?

/**定义用户**/publicclassUser{privateStringname;privateAddressaddress;//constructors,gettersandsetters}/**地址**/publicclassAddress{privateStringcity;privateStringcountry;//constructors,gettersandsetters}重载clone()方法Object父类有个clone()的拷贝方法,不过它是protected类型的,我们需要重写它并修改为public类型。除此之外,子类还需要实现Cloneable接口来告诉JVM这个类是可以拷贝的。重写代码让我们修改一下User类,Address类,实现Cloneable接口,使其支持深拷贝。/***地址*/publicclassAddressimplementsCloneable{privateStringcity;privateStringcountry;//constructors,gettersandsetters@OverridepublicAddressclone()throwsCloneNotSupportedException{return(Address)super.clone();}}/***用户*/publicclassUserimplementsCloneable{privateStringname;privateAddressaddress;//constructors,gettersandsetters@OverridepublicUserclone()throwsCloneNotSupportedException{Useruser=(User)super.clone();user.setAddress(this.address.clone());returnuser;}}需要注意的是,super.clone()其实是浅拷贝,所以在重写User类的clone()方法时,address对象需要调用address.clone()重新赋值。扩展:为什么要克隆?大家先思考一个问题,为什么需要克隆对象?直接new一个对象不行吗?答案是:克隆的对象可能包含一些已经修改过的属性,而new出来的对象的属性都还是初始化时候的值,所以当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。那么我把这个对象的临时属性一个一个的赋值给我新new的对象不也行嘛?可以是可以,但是一来麻烦不说,二来,大家通过上面的源码都发现了clone是一个native方法,就是快啊,在底层实现的。提个醒,我们常见的Objecta=newObject();Objectb;b=a;这种形式的代码复制的是引用,即对象在内存中的地址,a和b对象仍然指向了同一个对象。而通过clone方法赋值的对象跟原来的对象时同时独立存在的。
2023-07-25 14:52:501

在java中 clone为什么要用super.clone()方法?

1.Object中的clone执行的时候使用了RTTI(run-time type identification)的机制,动态得找到目前正在调用clone方法的那个reference,根据它的大小申请内存空间,然后进行bitwise的复制,将该对象的内存空间完全复制到新的空间中去,从而达到shallowcopy的目的。 所以你调用super.clone() 得到的是当前调用类的副本,而不是父类的副本。根本没有必用调用this.clone();2.要让实例调用clone方法就需要让此类实现Cloneable接口,API里面还有句话是:如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法,则会导致抛出 CloneNotSupportedException 异常,这便是“合法”的含义。 但请注意,Cloneable接口只是个标签接口,不含任何需要实现的方法,就像Serializable接口一样。总之,一般如果你的子类没有特殊需要而重写clone()方法就直接用super.clone() 就行了。
2023-07-25 14:53:091

java关于clone的问题

总之一句话,某个类想要有 clone 功能,这个类必须 implements Cloneable;然后覆写 public Object clone();这个方法即可;如下格式:public class C implements Cloneable{public C clone(){try{return (C)super.clone();}catch(Exception e){}return null;}}
2023-07-25 14:53:173

java.util.hashtable实现了哪个interface

一、Mapmap接口,集合类的接口,声明了map的常用方法。所有的map都继承自改接口二、java.io.Serializable接口,接口里没有声明任何方法,该接口用来实现对象的序列化反序列化功能三、java.lang.Cloneable接口里没有声明任何方法,该接口实现对象复制功能四. AbstractMap重要的类:AbstractMap<K,V>AbstractMap抽象类实现了一些简单且通用的方法,在这个抽象类中有两个方法非常值得关注,keySet和values方法源码的实现可以说是教科书式的典范。  抽象类通常作为一种骨架实现,为各自子类实现公共的方法。  Java中Map类型的数据结构有相当多,AbstractMap作为它们的骨架实现实现了Map接口部分方法,也就是说为它的子类各种Map提供了公共的方法,没有实现的方法各种Map可能有所不同。  抽象类不能通过new关键字直接创建抽象类的实例,但它可以有构造方法。AbstractMap提供了一个protected修饰的无参构造方法,意味着只有它的子类才能访问(当然它本身就是一个抽象类,其他类也不能直接对其实例化),也就是说只有它的子类才能调用这个无参的构造方法。  在Map接口中其内部定义了一个Entry接口,这个接口是Map映射的内部实现用于维护一个key-value键值对,key-value存储在这个Map.Entry中。AbstractMap对这个内部接口进行了实现,一共有两个:一个是可变的SimpleEntry和一个是不可变的SimpleImmutableEntry。1. SimpleEntry1.1 定义实现了Map.Entry<K, V>接口,并且实现了Serializable(可被序列化)。它的方法比较简单都是取值存值的操作,对于key值的定义是一个final修饰意味着是一个不可变的引用。1.2 setValuell另外其setValue方法稍微特殊,存入value值返回的并不是存入的值,而是返回的以前的旧值。源码:1.3 equals和hashCode需要重点学习的是它重写的equals和hashCode方法。eq方法 要想正确重写equals方法并能正确使用,通常还需要重写hashCode方法。因为集合中的元素,判断是否一样时,先hash再equals,这也是个知识点,详细的,学习一下原理。hashcode源码:可以看成求hashcode值时,即返回的int数据,是key.hashCode() ^ value.hashCode(),即key、value的hashcode值异或2. SimpleImmutableEntry2.1 定义源码:它相比于SimpleEntry其key和value成员变量都被定义为了final类型。即定义为不可变的Entry,不提供setValue方法,不能通过setValue方法进行修改。2.2 setValue调用setValue方法将会抛出UnsupportedOperationException异常。即定义为不可变的Entry,不提供setValue方法,不能通过setValue方法进行修改。   它的equals和hashCode方法和SimpleEntry一致。3. 实现的Map接口方法接下来查看AbstractMap抽象类实现了哪些Map接口中的方法。3.1 public int size()Map中定义了一个entrySet方法,返回的是Map.Entry的Set集合,直接调用Set集合的size方法即是Map的大小。3.2 public boolean isEmpty()调用size方法,等于0即为空。3.3 public boolean containsValue(Object value)  这个方法的实现较为简单,通过调用entrySet方法获取Set集合的迭代器遍历Map.Entry,获取对应的value与参数value比较。Map可以存储为null的value值,由于value=null在Map中存储比较特殊(不能计算hashCode值),所以在这里也做了判断参数value是否为空。public boolean containsKey(Object key)  这个方法实现和containsValue一致。3.4 public V get(Object key)  这个方法实现和containsValue类似,不同的是上面相等返回boolean,这个方法返回value值。3.5 public V put(K key, V value)  向Map中存入key-value键值对的方法并没有具体实现,会直接抛出一个UnsupportedOperationException异常。6 public V remove(Object key)  通过参数key删除Map中指定的key-value键值对。这个方法也很简单,也是通过迭代器遍历Map.Entry的Set集合,找到对应key值,通过调用 Iterator.remove() 方法删除Map.Entry。7. public void putAll(Map<? extends K, ? extends V> m)  这个方法也很简单遍历传入的Map,调用put方法存入就可以了。public void clear()  调用entrySet方法获取Set集合再调用Set#clear()方法清空。keyset 返回Map key值的Set集合。AbstractMap中定义了一个成员变量“transient Set<K> keySet”,在JDK7中keySet变量是由volatile修饰的,但在JDK8中并没有使用volatile修饰。在对keySet变量的注释中解释道,访问这些字段的方法本身就没有同步,加上volatile也不能保证线程安全。关于keySet方法的实现就有点意思了。  首先思考该方法是返回key值的Set集合,很自然的能想到一个简单的实现方式,遍历Entry数组取出key值放到Set集合中,类似下面代码:这就意味着每次调用keySet方法都会遍历Entry数组,数据量大时效率会大大降低。不得不说JDK源码是写得非常好,它并没有采取遍历的方式。如果不遍历Entry,那又如何知道此时Map新增了一个key-value键值对呢?  答案就是在keySet方法内部重新实现了一个新的自定义Set集合,在这个自定义Set集合中又重写了iterator方法,这里是关键,iterator方法返回Iterator接口,而在这里又重新实现了Iterator迭代器,通过调用entrySet方法再调用它的iterator方法。下面结合代码来分析:五、 DictionaryDictionary 类是一个抽象类,用来存储键/值对,作用和Map类相似。给出键和值,你就可以将值存储在Dictionary对象中。一旦该值被存储,就可以通过它的键来获取它。所以和Map一样, Dictionary 也可以作为一个键/值对列表。Dictionary类已经过时了。在实际开发中,你可以实现Map接口来获取键/值的存储功能。打开CSDN,阅读体验更佳HashMap、TreeMap、Hashable和LinkedHashMap_kgduu的博客HashMap、TreeMap、Hashable和LinkedHashMap Map是最重要的数据结构之一。开始会告诉怎么用HashMap、TreeMap、Hashtable和LinkedHashMap 1、Map概述 在Java SE中有4种Map的实现:HashMap、TreeMap、Hashtable和LinkedHashMap. HashMap:用哈...继续访问Python 接口:从协议到抽象基类_weixin_30492047的博客首先,基本的事实是,Python语言没有 interface 关键字,而且除了抽象基类,每个类都有接口:类实现或继承的公开属性(方法或数据属性),包括特殊方法,如__getitem__ 或 __add__。 按照定义,受保护的属性和私有属性不在接口中:即便“受保护...继续访问最新发布 Java集合(九)HashMap接口HashMap小结:(1)Map接口的常用实现类:HashMap、Hashtable和Properties(2)HashMap是Map接口使用频率最高的实现类(3)HashMap是以key-val对的方式来存储数据(HashMap$Node类型)(4)key不能重复,但是值可以重复,允许使用null键和null值(5)如果添加相同的key,则会覆盖原来的key-val,等同于修改.(key不会替换,val会替换)我们来把断点放在map.put("no1","张三丰“);继续访问Hashtable和HashMap的异同Hashtable和HashMap两者的原理相同,功能相同,很多情况下可以互用。 Hashtable和HashMap的主要区别如下: 1、Hashtable继承自Dictionary类,而HashMap实现了Map接口 2、Hashtable线程安全,HashMap重速度、轻安全,是线程非安全的,所以当运行到线程环境中时,需要程序员自己管理线程的同步问题。 3、Hashtable不允许null值(key和value都不允许),HashMap允许null值(key和value都允许) 其他异同点可参照博客:继续访问Hashable / Hasher_weixin_33909059的博客哈希函数的选择应该作为实现细节,而不是设计中的固定部分;因此,使用者不应该依赖于编译器自动生成的 Hashable 函数的具体特征。最可能的实现是在每个成员的哈希值上调用标准库中的_mixInt函数,然后将他们逻辑异或(^),如同目前Collection类...继续访问php的数据结构_PHP 的数据结构扩展_myh991235的博客Sequence 是类数组数据结构的基础接口,定义了很多重要且方便的方法,比如 contains, map, filter, reduce, find, first, last 等。从图中可知,Vector, Deque, Stack, Queue 都直接或者间接的实现了这个接口。 Hashable 在图中看起来比...继续访问33.Java之Map接口实现类(HashMap、HashTable、Properties、TreeSet 和 TreeMap基本介绍,HashMap 底层机制)Map 接口的常用实现类:HashMap、Hashtable 和 Properties 33.1 HashMap 基本介绍 是 Map 接口使用频率最高的实现类 是以 Key-value 的方式来存储数据(HashMap$Node类型) Key 不能重复,但是值可以重复,允许使用 Null 键和 Null 值 如果添加相同的 Key,则会覆盖原来的 Key-value,等同于修改(Key不会替换,value会替换) 与 HashSet 一样,不保证映射的顺序(即添加顺序与输出顺序不一样),因为底层是以继续访问Map接口:HashMap与HashTable的区别1)HashMap和Hashtable都实现了Map接口,但是继承的父类不同: public class Hashtable extends Dictionary implements Map public class HashMap extends AbstractMap implements Map2)HashMap是非synchronized,执行速度快,而HashTab...继续访问php7 唯一数字_PHP7中高效的数据结构_王雷Neo的博客实现Hashable接口的数据结构是Map和Set。 Map 一个Map 是一个键值对的连续集合,和数组几乎一致。键可以是任何类型,但是必须唯一。 强项: 性能和内存效率和数组几乎一致 当长度降低的时候自动释放内存 ...继续访问java常见笔试_Java 常见笔试题(2)_weixin_39998462的博客java.util.Hashtable实现了哪个接口? A. java.util.Map B. java.util.List C. java.util.Hashable D. java.util.Collection 9. 1. class A implements Runnable{ 2. int i; 3.继续访问实现原理_HashTable实现原理概要前一章,我们学习了HashMap。这一章,我们对Hashtable进行学习。我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Hashtable。第1部分 Hashtable介绍第2部分 Hashtable数据结构第3部分 Hashtable源码解析(基于JDK1.6.0_45)第4部分 Hashtable遍历方式第5部分 Hashtable示例转载请注明出处...继续访问Hashtable源码分析前言:Hashtable线程安全的集合类,虽然它线程安全,然而在日常开发中使用的频率很低,毕竟锁的颗粒度太大了。但是这并不妨碍我们对其内部原理进行了解。 注:本文jdk源码版本为jdk1.8.0_172。 1.Hashtable基本概念 Hashtable与HashMap一样,都是以键值对的形式存储数据。但是Hashtable的键值不能为null,而HashMap的键值是可以为...继续访问Swift自定义Class实现Hashable_weixin_30273763的博客增加代码后,发现编译器依然报错"Type "Bit" does not conform to protocol "Equatable""-没有实现Equatable协议。 2.实现Equatable Commend+click点击Hashable定义,进入后再点击Equatable协议定义,可以看到如下定义: ...继续访问Array,Vertor,Arraylist,Hashable,Hashmap等几个易混淆的概念_tjjhz...1.历史原因:Hashtable是基于陈旧的Dictionary类的,HashMap是Java1.2引进的Map接口的一个实现 2.同步性:Hashtable是线程安全的,也就是说是同步的,而HashMap是线程序不安全的,不是同步的继续访问Hashtable简述散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。......继续访问Map接口与实现类HashTableMap接口与实现类HashTable 源码位置 rt.jar/java.util包下 源码类 public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable 特点 1、集合中key不能重复,若put时集合已含有此key,那新值会替换旧值;key,value不能为null 2、HashTable/Map中存放数继续访问Java面试知识整理_加温的啤酒的博客_java面试知识整理都实现了list接口,都是有序的 vector线程是安全的,arraylist线程是不安全的 vector数据增长是原来的一倍,arraylist是数据增长是原来的0.5倍 hashmap和hashable的区别 hashmap是hashable的轻量级实现,hashmap允许空键值,hashable不允许 ...继续访问javase基础知识总结_id_1314520的博客interface接口: 默认所有方法都是抽象的,并且public修饰的. 属性: 默认为public修饰的常量(public final修饰的) abstract抽象类: 类名被abstract修饰的类; 里面可以有抽象方法, 也可以没有抽象方法; 实现接口类,可以重写也可以不重写接口...继续访问集合—Map接口实现类-Hashtable本次博客带领大家学习集合中的Map接口实现类-Hashtable。继续访问Hashtable 和 HashMapHashMap和Hashtable都实现了Map接口,但决定用哪一个之前先要弄清楚它们之间的分别。主要的区别有:线程安全性,同步(synchronization),以及速度。 1.HashMap几乎可以等价于Hashtable,除了HashMap是非synchronized的,并可以接受null(HashMap可以接受为null的键值(key)和值(value),而Hashtable则不行)。 2...继续访问hashMap和hashTable的区别以及HashMap的底层原理?hashMap和hashTable的区别? 1、继承的父类不同 HashTable继承Dictionary类,而hashMap继承了AbstractMap类,但是二者都实现了map接口。 2、线程安全性不同 Hashtable 线程安全,因为它每个方法中都加入了Synchronize。HashMap是线程不安全的。u200b HashMap底层是一个Entry数组,当发生hash冲突的时候,ha......继续访问java---Map接口的实现类HashMap和Hashtablepackage LyfPractice;import java.util.*;/** * Created by fangjiejie on 2016/12/19. */ /*Hashmap和Hashtable的区别 1.相同:都实现了Map接口,实现了key和value的保存与映射,有很多相同的方法 2.不同: Hashmap:是map接口的实现类 ,非同步,线程不安全 ,速度快,可以有继续访问Map 接口实现类-HashtableMap 接口实现类-Hashtable继续访问29. Map接口继承关系 / Map接口概述 / HashMap底层实现原理及相关知识 / Map常用方法 / TreeMap、PropertiesMap接口继承关系 Map接口概述 Map与Collection并列存在。用于保存具有映射关系的数据:key-value Map 中的 key 和 value 都可以是任何引用类型的数据 Map 中的 key 用Set来存放, 不允许重复,即同一个 Map 对象所对应 的类,须重写hashCode()和equals()方法 常用String类作为Map的“键” key 和 value 之间存在单向一对一关系,即通过指定的 key 总能找到 唯一的、确定的 value Map接口的常用实现类: HashM继续访问Map接口的实现类----HashMapMap接口的实现类----HashMap。继续访问JAVA基础 接口与继承 HashMap使用https://blog.csdn.net/u010575093/article/details/50731281 抽象类中可以定义成员变量,而接口中定义的成员变量实际上都是常量 接口不可继承抽象类,抽象类可实现多个接口。接口与接口之间是继承,用extends,可继承多个接口 mport java.util.HashMap; import java.util.Map; interface T...继续访问【Java_基础深入】LinkedHashMap 继承 HashMap又实现 Map 接口背后的设计思想JDK源码的类定义 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable public class LinkedHashMap<K,V> extends HashMap<K,V> implements...继续访问Map接口及其实现类HashMap、LinkedHashMap和Hashtable的简单介绍一、Map集合的特点 Map集合是一个双列集合,一个元素包含两个值(一个是key,一个是value)Map集合的特点 Map集合中的元素,key和value的数据类型可以相同也可以不同 Map集合中的元素,key是不允许重复的,value是可以重复的 Map集合中的元素,key和value是一一对应的 Map的常用方法 1、public V put (K key, V value)方法 作用:把指定的键与指定的值添加到Map集合中 返回值V的含义:存储键值对的时候,key如果不重复,返回值v是null;继续访问Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例转 http://www.cnblogs.com/skywang12345/p/3310887.html#top Java 集合系列11之 Hashtable详细介绍(源码解析)和使用示例 概要 前一章,我们学习了HashMap。这一章,我们对Hashtable进行学习。 我们先对Hashtable有个整体认识,然后再学习它的源码,最后再通过实例来学会使用Has继续访问HashTable实现原理有两个类都提供了一个多种用途的hashTable机制,他们都可以将可以key和value结合起来构成键值对通过put(key,value)方法保存起来,然后通过get(key)方法获取相对应的value值。一个是前面提到的HashMap,还有一个就是马上要讲解的HashTable。对于HashTable而言,它在很大程度上和HashMap的实现差不多,如果我们对HashMap比较了解的话,对Has
2023-07-25 14:53:241

JAVA源代码的扩展名为( )

当然是B啦
2023-07-25 14:53:355

为什么set,list,map不实现cloneable和serializable接口

集合类接口指定了一组叫做元素的对象。集合类接口的每一种具体的实现类都可以选择以它自己的方式对元素进行保存和排序。有的集合类允许重复的键,有些不允许。http://www.baidu.com/s?wd=52035271515
2023-07-25 14:54:071

java中两种占位符的使用方式

1、new  使用java的关键字new来创建对象实例。构造函数链中的所有构造函数都会被自动调用。Java代码:   CreateInstance instance = new CreateInstance ();2、clone 构造函数不被自动调用。  Java代码:    public class CreateInstance implements Cloneable{    public CreateInstance getInstance() throws CloneNotSupportedException{     return (CreateInstance) this.clone(); } }  如果需要复制上面的那个obj指向的对象实例时,调用newCreateInstance().getInstance()方法就ok了。JDK中Object#clone()方法的原型是:protectednativeObjectclone()throws CloneNotSupportedException;方法修饰符是protected,而不是public。 这种访问的不可见性使得对Object#clone()方法不可见。所以,必需重写Object的clone方法后才能使用。 Java代码:    public class CreateInstance implements Cloneable{    public CreateInstance clone throws CloneNotSupportedException{     return (CreateInstance) super.clone(); } } 值得注意的是 :如果需要使用clone方法,必需实现java.lang.Cloneable接口,否则会抛出java.lang.CloneNotSupportedException。 另外clone方法所做的的操作是直接复制字段的内容,换句话说,这个操作并不管该字段对应的对象实例内容。 像这样字段对字段的拷贝(fieldtofieldcopy)就成为"浅拷贝",clone方法所做的正是"浅拷贝"。3、newInstance 利用java.lang.Class类的newInstance方法,则可根据Class对象的实例,建立该Class所表示的类的对象实例。 创建CreateInstace类的对象实例可以使用下面的语句(这样需要一个已经存在的对象实例)。 CreateInstance instance = CreateInstance.class.newInstance(); 或者使用下面的语句(只需要存在相应的.class文件即可) CreateInstance instance = (CreateInstance)Class.forname("com.create.instance.CreateInstance").newInstance(); 如果包下不存在相应.class文件,则会抛出ClassNotFoundException。 注意 :newInstance创建对象实例的时候会调用无参的构造函数,所以必需确保类中有无参数的构造函数,否则将会抛出java.lang.InstantiationException异常。 无法进行实例化。
2023-07-25 14:54:151

java中声明Point类表示一个点的x轴和y轴坐标,声明构造方法和拷贝方法,声明若干get()和set()方法获得

类和接口。声明像素类Pixel继承Point类,因为像素是一个带颜色的坐标点。用JAVA。 如果对您有帮助,请记得采纳为满意答案,谢谢!祝您生活愉快!vaela
2023-07-25 14:54:232

软件设计模式主要有哪几种

软件设计模式主要有以下三大类共23种:一、创建型模式:1、工厂方法模式工厂方法模式的创建是因为简单工厂模式有一个问题,在简单工厂模式中类的创建依赖工厂类,如果想要拓展程序,必须对工厂类进行修改,这违背了开闭原则,所以就出现了工厂方法模式,只需要创建一个工厂接口和多个工厂实现类。2、抽象工厂模式抽象工厂模式是提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。区别于工厂方法模式的地方,工厂方法模式是创建一个工厂,可以实现多种对象;而抽象工厂模式是提供一个抽象工厂接口,里面定义多种工厂,每个工厂可以生产多种对象。3、单例模式单例模式能保证一个类仅有一个实例,并提供一个访问它的全局访问点,同时在类内部创造单一对象,通过设置权限,使类外部无法再创造对象。单例对象能保证在一个JVM中,该对象只有一个实例存在。4、建造者模式建造者模式是将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表示。在程序当中就是将一些不会变的基本组件,通过builder来进行组合,构建复杂对象,实现分离。5、原型模式:原型模式是用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。其实就是将对象复制了一份并返还给调用者,对象需继承Cloneable并重写clone方法。原型模式的思想就是将一个对象作为原型,对其进行复制、克隆,产生一个和原对象类似的新对象。二、结构型模式:1、适配器模式适配器模式是使得原本由于接口不兼容而不能一起工作的那些类可以一起工作,衔接两个不兼容、独立的接口的功能,使得它们能够一起工作,适配器起到中介的作用。2、装饰模式:装饰器模式是动态地给一个对象添加一些额外的职责,给一个对象增加一些新的功能,要求装饰对象和被装饰对象实现同一个接口,装饰对象持有被装饰对象的实例。除了动态的增加,也可以动态的撤销,要做到动态的形式,不可以用继承实现,因为继承是静态的。3、代理模式代理模式是为其他对象提供一种代理以控制对这个对象的访问,也就是创建类的代理类,间接访问被代理类的过程中,对其功能加以控制。4、外观模式外观模式是为子系统中的一组接口提供一个一致的界面,外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。5、桥接模式桥接模式是将抽象部分与实现部分分离,使它们都可以独立的变化。桥接模式就是把事物和其具体实现分开,使他们可以各自独立的变化(突然联想到了mvc模式)。6、组合模式:组合模式是将对象组合成树形结构以表示"部分-整体"的层次结构,组合模式使得用户对单个对象和组合对象的使用具有一致性。7、享元模式:享元模式是运用共享技术有效地支持大量细粒度的对象。享元模式的主要目的是实现对象的共享,即共享池,当系统中对象多的时候可以减少内存的开销,重用现有的同类对象,若未找到匹配的对象,则创建新对象,这样可以减少对象的创建,降低系统内存,提高效率。三、行为型模式:1、策略模式:策略模式是定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换,且算法的变化不会影响到使用算法的客户。2、模版方法模式:模板方法模式是定义一个操作中的算法的骨架,而将一些步骤延迟到子类中。该模式就是在一个抽象类中,有一个主方法,再定义1...n个方法,可以是抽象的,也可以是实际的方法,定义一个类,继承该抽象类,重写抽象方法,通过调用抽象类,实现对子类的调用。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤,将一些固定步骤、固定逻辑的方法封装成模板方法。调用模板方法即可完成那些特定的步骤。3、观察者模式:观察者模式是定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。也就是当被观察者状态变化时,通知所有观察者,这种依赖方式具有双向性,在QQ邮箱中的邮件订阅和RSS订阅,当用户浏览一些博客时,经常会看到RSS图标,简单来说就是当订阅了该文章,如果后续有更新,会及时通知用户。这种现象即是典型的观察者模式。4、迭代器模式:迭代器模式是提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。在Java当中,将聚合类中遍历各个元素的行为分离出来,封装成迭代器,让迭代器来处理遍历的任务;使简化聚合类,同时又不暴露聚合类的内部,在我们经常使用的JDK中各个类也都是这些基本的东西。5、责任链模式:责任链模式是避免请求发送者与接收者耦合在一起,让多个对象都有可能接收请求,将这些对象连接成一条链,并且沿着这条链传递请求,直到有对象处理它为止。有多个对象,每个对象持有对下一个对象的引用,这样就会形成一条链,请求在这条链上传递,直到某一对象决定处理该请求。6、命令模式:命令模式是将一个请求封装成一个对象,从而使发出者可以用不同的请求对客户进行参数化。模式当中存在调用者、接收者、命令三个对象,实现请求和执行分开;调用者选择命令发布,命令指定接收者。7、备忘录模式:备忘录模式是在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态。创建一个备忘录类,用来存储原始类的信息;同时创建备忘录仓库类,用来存储备忘录类,主要目的是保存一个对象的某个状态,以便在适当的时候恢复对象,也就是做个备份。8、状态模式:状态模式是允许对象在内部状态发生改变时改变它的行为。对象具有多种状态,且每种状态具有特定的行为。9、访问者模式:访问者模式主要是将数据结构与数据操作分离。在被访问的类里面加一个对外提供接待访问者的接口,访问者封装了对被访问者结构的一些杂乱操作,解耦结构与算法,同时具有优秀的扩展性。通俗来讲就是一种分离对象数据结构与行为的方法。10、中介者模式:中介者模式是用一个中介对象来封装一系列的对象交互,中介者使各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。11、解释器模式:解释器模式是给定一个语言,定义它的文法表示,并定义一个解释器,这个解释器使用该标识来解释语言中的句子,基本也就用在这个范围内,适用面较窄,例如:正则表达式的解释等。扩展资料:软件设计的概念以及意义:软件设计模式是对软件设计经验的总结,是对软件设计中反复出现的设计问题的成功解决方案的描述。为了记录这些成功的设计经验并方便以后使用,软件设计模式通常包含 4 个基本要素:模式名称、问题、解决方案以及效果。模式名称实际上就是一个帮助记忆的名称,是用于软件设计的技术术语,有助于设计者之间的交流。问题描述了设计者所面临的设计场景,用于告诉设计者在什么情况下使用该模式。解决方案描述了设计的细节,通常会给出方案的原理图示(例如 UML 的类图,序列图等,也可能是一些示意图)及相关文字说明,如果可能,还会给出一些代码实例,以便对解决方案的深入理解。效果描述了设计方案的优势和劣势,这些效果通常面向软件的质量属性,例如,可扩展性、可复用性等。软件设计模式的重要意义在于设计复用。设计模式可以使设计者更加方便地借鉴或直接使用已经过证实的成功设计方案,而不必花费时间进行重复设计。一些设计模式甚至提供了显示的类图设计及代码实例,为设计的文档化及软件的开发提供了直接的支持。
2023-07-25 14:54:321

java hashtable 初始化为啥是11

hashtable和hashmap,从存储结构和实现来讲基本上都是相同的,最大的不同就是hashtable是线程安全的,put等方法都加了synchronized关键字。另外就继承关系上面有点区别,这里就从如下几个方面来分析一下hashtable,从中穿插着和hashmap的对比说明。1、继承关系[java] view plain copy public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable 这里和hashmap的唯一区别就是hashtable继承Dictionary,这个抽象类没有实现任何方法,按照官方的说法是这个类已经过时了,hashMap则是继承abstractMap。2、关键类,这个类实现Iterator的功能,它实现了Enumeration和Iterator接口,其实Enumeration和Iterator的功能差不多,至于为什么需要同时实现两个接口,有一种说法是历史原因,具体的话我们就不去分析说明了,这里的Enumerator就是一个迭代器的功能,有hashNext和next方法。[java] view plain copy private class Enumerator<T> implements Enumeration<T>, Iterator<T> { Entry[] table = Hashtable.this.table; int index = table.length; Entry<K,V> entry = null; Entry<K,V> lastReturned = null; int type; /** * Indicates whether this Enumerator is serving as an Iterator * or an Enumeration. (true -> Iterator). */ boolean iterator; /** * The modCount value that the iterator believes that the backing * Hashtable should have. If this expectation is violated, the iterator * has detected concurrent modification. */ protected int expectedModCount = modCount; Enumerator(int type, boolean iterator) { this.type = type; this.iterator = iterator; } public boolean hasMoreElements() { Entry<K,V> e = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (e == null && i > 0) { e = t[--i]; } entry = e; index = i; return e != null; } public T nextElement() { Entry<K,V> et = entry; int i = index; Entry[] t = table; /* Use locals for faster loop iteration */ while (et == null && i > 0) { et = t[--i]; } entry = et; index = i; if (et != null) { Entry<K,V> e = lastReturned = entry; entry = e.next; return type == KEYS ? (T)e.key : (type == VALUES ? (T)e.value : (T)e); } throw new NoSuchElementException("Hashtable Enumerator"); } // Iterator methods public boolean hasNext() { return hasMoreElements(); } public T next() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); return nextElement(); } public void remove() { if (!iterator) throw new UnsupportedOperationException(); if (lastReturned == null) throw new IllegalStateException("Hashtable Enumerator"); if (modCount != expectedModCount) throw new ConcurrentModificationException(); synchronized(Hashtable.this) { Entry[] tab = Hashtable.this.table; int index = (lastReturned.hash & 0x7FFFFFFF) % tab.length; for (Entry<K,V> e = tab[index], prev = null; e != null; prev = e, e = e.next) { if (e == lastReturned) { modCount++; expectedModCount++; if (prev == null) tab[index] = e.next; else prev.next = e.next; count--; lastReturned = null; return; } } throw new ConcurrentModificationException(); } } } 3、关键属性和方法hashtable和hashmap的关键属性和方法的实现基本没有区别,或者说没有区别,最大的区别就是前者的方法有synchronized关键字,是线程安全的方法,后者不是线程安全的方法,另外hashtable不支持null的key和value,hashmap支持null的key和value。具体的方法实现和hashmap是一样的,这里就不在重复的分析了。最后总结,hashtable是线程安全的hashmap。
2023-07-25 14:54:501

Java 静态内部类作用?

大家继续回答啊!
2023-07-25 14:55:018

java编码规范有哪些?

JAVA代码规范:(1) 类名首字母应该大写。字段、方法以及对象(句柄)的首字母应小写。对于所有标识符,其中包含的所有单词都应紧靠在一起,而且大写中间单词的首字母。例如: ThisIsAClassName thisIsMethodOrFieldName 若在定义中出现了常数初始化字符,则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。 Java包(Package)属于一种特殊情况:它们全都是小写字母,即便中间的单词亦是如此。对于域名扩展名称,如com,org,net或者edu等,全部都应小写(这也是Java 1.1和Java 1.2的区别之一)。 (2) 为了常规用途而创建一个类时,请采取"经典形式",并包含对下述元素的定义: equals() hashCode() toString() clone()(implement Cloneable) implement Serializable (3) 对于自己创建的每一个类,都考虑置入一个main(),其中包含了用于测试那个类的代码。为使用一个项目中的类,我们没必要删除测试代码。若进行了任何形式的改动,可方便地返回测试。这些代码也可作为如何使用类的一个示例使用。 (4) 应将方法设计成简要的、功能性单元,用它描述和实现一个不连续的类接口部分。理想情况下,方法应简明扼要。若长度很大,可考虑通过某种方式将其分割成较短的几个方法。这样做也便于类内代码的重复使用(有些时候,方法必须非常大,但它们仍应只做同样的一件事情)。 (5) 设计一个类时,请设身处地为客户程序员考虑一下(类的使用方法应该是非常明确的)。然后,再设身处地为管理代码的人考虑一下(预计有可能进行哪些形式的修改,想想用什么方法可把它们变得更简单)。 (6) 使类尽可能短小精悍,而且只解决一个特定的问题。下面是对类设计的一些建议: ■一个复杂的开关语句:考虑采用"多形"机制 ■数量众多的方法涉及到类型差别极大的操作:考虑用几个类来分别实现 ■许多成员变量在特征上有很大的差别:考虑使用几个类 (7) 让一切东西都尽可能地"私有"--private。可使库的某一部分"公共化"(一个方法、类或者一个字段等等),就永远不能把它拿出。若强行拿出,就可能破坏其他人现有的代码,使他们不得不重新编写和设计。若只公布自己必须公布的,就可放心大胆地改变其他任何东西。在多线程环境中,隐私是特别重要的一个因素--只有private字段才能在非同步使用的情况下受到保护。 (8) 谨惕"巨大对象综合症"。对一些习惯于顺序编程思维、且初涉OOP领域的新手,往往喜欢先写一个顺序执行的程序,再把它嵌入一个或两个巨大的对象里。根据编程原理,对象表达的应该是应用程序的概念,而非应用程序本身。 (9) 若不得已进行一些不太雅观的编程,至少应该把那些代码置于一个类的内部。 (10) 任何时候只要发现类与类之间结合得非常紧密,就需要考虑是否采用内部类,从而改善编码及维护工作(参见第14章14.1.2小节的"用内部类改进代码")。 (11) 尽可能细致地加上注释,并用javadoc注释文档语法生成自己的程序文档。 (12) 避免使用"魔术数字",这些数字很难与代码很好地配合。如以后需要修改它,无疑会成为一场噩梦,因为根本不知道"100"到底是指"数组大小"还是"其他全然不同的东西"。所以,我们应创建一个常数,并为其使用具有说服力的描述性名称,并在整个程序中都采用常数标识符。这样可使程序更易理解以及更易维护。 (13) 涉及构建器和异常的时候,通常希望重新丢弃在构建器中捕获的任何异常--如果它造成了那个对象的创建失败。这样一来,调用者就不会以为那个对象已正确地创建,从而盲目地继续。 (14) 当客户程序员用完对象以后,若你的类要求进行任何清除工作,可考虑将清除代码置于一个良好定义的方法里,采用类似于cleanup()这样的名字,明确表明自己的用途。除此以外,可在类内放置一个boolean(布尔)标记,指出对象是否已被清除。在类的finalize()方法里,请确定对象已被清除,并已丢弃了从RuntimeException继承的一个类(如果还没有的话),从而指出一个编程错误。在采取象这样的方案之前,请确定finalize()能够在自己的系统中工作(可能需要调用System.runFinalizersOnExit(true),从而确保这一行为)。 (15) 在一个特定的作用域内,若一个对象必须清除(非由垃圾收集机制处理),请采用下述方法:初始化对象;若成功,则立即进入一个含有finally从句的try块,开始清除工作。 (16) 若在初始化过程中需要覆盖(取消)finalize(),请记住调用super.finalize()(若Object属于我们的直接超类,则无此必要)。在对finalize()进行覆盖的过程中,对super.finalize()的调用应属于最后一个行动,而不应是第一个行动,这样可确保在需要基础类组件的时候它们依然有效。 (17) 创建大小固定的对象集合时,请将它们传输至一个数组(若准备从一个方法里返回这个集合,更应如此操作)。这样一来,我们就可享受到数组在编译期进行类型检查的好处。此外,为使用它们,数组的接收者也许并不需要将对象"造型"到数组里。 (18) 尽量使用interfaces,不要使用abstract类。若已知某样东西准备成为一个基础类,那么第一个选择应是将其变成一个interface(接口)。只有在不得不使用方法定义或者成员变量的时候,才需要将其变成一个abstract(抽象)类。接口主要描述了客户希望做什么事情,而一个类则致力于(或允许)具体的实施细节。 (19) 在构建器内部,只进行那些将对象设为正确状态所需的工作。尽可能地避免调用其他方法,因为那些方法可能被其他人覆盖或取消,从而在构建过程中产生不可预知的结果(参见第7章的详细说明)。 (20) 对象不应只是简单地容纳一些数据;它们的行为也应得到良好的定义。 (21) 在现成类的基础上创建新类时,请首先选择"新建"或"创作"。只有自己的设计要求必须继承时,才应考虑这方面的问题。若在本来允许新建的场合使用了继承,则整个设计会变得没有必要地复杂。 (22) 用继承及方法覆盖来表示行为间的差异,而用字段表示状态间的区别。一个非常极端的例子是通过对不同类的继承来表示颜色,这是绝对应该避免的:应直接使用一个"颜色"字段。 (23) 为避免编程时遇到麻烦,请保证在自己类路径指到的任何地方,每个名字都仅对应一个类。否则,编译器可能先找到同名的另一个类,并报告出错消息。若怀疑自己碰到了类路径问题,请试试在类路径的每一个起点,搜索一下同名的.class文件。 (24) 在Java 1.1 AWT中使用事件"适配器"时,特别容易碰到一个陷阱。若覆盖了某个适配器方法,同时拼写方法没有特别讲究,最后的结果就是新添加一个方法,而不是覆盖现成方法。然而,由于这样做是完全合法的,所以不会从编译器或运行期系统获得任何出错提示--只不过代码的工作就变得不正常了。 (25) 用合理的设计方案消除"伪功能"。也就是说,假若只需要创建类的一个对象,就不要提前限制自己使用应用程序,并加上一条"只生成其中一个"注释。请考虑将其封装成一个"独生子"的形式。若在主程序里有大量散乱的代码,用于创建自己的对象,请考虑采纳一种创造性的方案,将些代码封装起来。 (26) 警惕"分析瘫痪"。请记住,无论如何都要提前了解整个项目的状况,再去考察其中的细节。由于把握了全局,可快速认识自己未知的一些因素,防止在考察细节的时候陷入"死逻辑"中。 (27) 警惕"过早优化"。首先让它运行起来,再考虑变得更快--但只有在自己必须这样做、而且经证实在某部分代码中的确存在一个性能瓶颈的时候,才应进行优化。除非用专门的工具分析瓶颈,否则很有可能是在浪费自己的时间。性能提升的隐含代价是自己的代码变得难于理解,而且难于维护。 (28) 请记住,阅读代码的时间比写代码的时间多得多。思路清晰的设计可获得易于理解的程序,但注释、细致的解释以及一些示例往往具有不可估量的价值。无论对你自己,还是对后来的人,它们都是相当重要的。如对此仍有怀疑,那么请试想自己试图从联机Java文档里找出有用信息时碰到的挫折,这样或许能将你说服。 (29) 如认为自己已进行了良好的分析、设计或者实施,那么请稍微更换一下思维角度。试试邀请一些外来人士--并不一定是专家,但可以是来自本公司其他部门的人。请他们用完全新鲜的眼光考察你的工作,看看是否能找出你一度熟视无睹的问题。采取这种方式,往往能在最适合修改的阶段找出一些关键性的问题,避免产品发行后再解决问题而造成的金钱及精力方面的损失。 (30) 良好的设计能带来最大的回报。简言之,对于一个特定的问题,通常会花较长的时间才能找到一种最恰当的解决方案。但一旦找到了正确的方法,以后的工作就轻松多了,再也不用经历数小时、数天或者数月的痛苦挣扎。我们的努力工作会带来最大的回报(甚至无可估量)。而且由于自己倾注了大量心血,最终获得一个出色的设计方案,成功的快感也是令人心动的。坚持****草草完工的诱惑--那样做往往得不偿失
2023-07-25 14:55:331

abstract class和interface有什么区别

含有abstract修饰符的class即为抽象类,abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class,abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现,所以,不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法,那么子类也必须定义为abstract类型。接口(interface)可以说成是抽象类的一种特例,接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型,接口中的成员变量类型默认为public static final。下面比较一下两者的语法区别:1.抽象类可以有构造方法,接口中不能有构造方法。2.抽象类中可以有普通成员变量,接口中没有普通成员变量3.抽象类中可以包含非抽象的普通方法,接口中的所有方法必须都是抽象的,不能有非抽象的普通方法。4. 抽象类中的抽象方法的访问类型可以是public,protected和(默认类型,虽然eclipse下不报错,但应该也不行),但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。5. 抽象类中可以包含静态方法,接口中不能包含静态方法6. 抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static final类型,并且默认即为public static final类型。7. 一个类可以实现多个接口,但只能继承一个抽象类。
2023-07-25 14:55:4213

Vector的父类是谁

Vector继承AbstractList类 实现List<E>, RandomAccess, Cloneable, java.io.Serializable接口
2023-07-25 14:57:063

java如何深度copy一个object?

java深复制的例子:1、创建Employer类,实现Cloneable接口:class Employer implements Cloneable{ private String username; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } @Override public Object clone() throws CloneNotSupportedException { return super.clone(); }}2、创建Employee类,实现Cloneable接口,并改写clone方法,实现深复制:class Employee implements Cloneable{ private String username; private Employer employer; public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public Employer getEmployer() { return employer; } public void setEmployer(Employer employer) { this.employer = employer; } @Override public Object clone() throws CloneNotSupportedException { //克隆Employee对象并手动的进一步克隆Employee对象中包含的Employer对象 Employee employee = (Employee)super.clone(); employee.setEmployer((Employer) employee.getEmployer().clone()); return employee; }}3、这样,在客户端拷贝的两个Employee对象的Employer就互不影响了:public static void main(String[] args) throws CloneNotSupportedException { Employer employer = new Employer(); employer.setUsername("arthinking"); Employee employee = new Employee(); employee.setUsername("Jason"); employee.setEmployer(employer); //employee2由employee深复制得到 Employee employee2 = (Employee) employee.clone(); //这样两个employee各自保存了两个employer employee2.getEmployer().setUsername("Jason"); System.out.println(employee.getEmployer().getUsername()); System.out.println(employee2.getEmployer().getUsername());}
2023-07-25 14:57:165

HashMap是什么东西

java数据结构-HashMap一直以来似乎都有一个错觉,认为map跟其他的集合类一样继承自Collection,其实不然,Map和Collection在结构层次上是没有任何关系的,通过查看源码可以发现map所有操作都是基于key-value对,而不是单独的元素。下面以HashMap为例子,深入对Map的实现机制进行了解,在这个过程中,请打开jdk源码。Hash算法HashMap使用Hash算法,所以在解剖HashMap之间,需要先简单的了解Hash算法,Hash算法一般也成为散列算法,通过散列算法将任意的值转化成固定的长度输出,该输出就是散列值,这是一种压缩映射,也就是,散列值的空间远远小于输入的值空间。简单的说,hash算法的意义在于提供了一种快速存取数据的方法,它用一种算法建立键值与真实值之间的对应关系,(每一个真实值只能有一个键值,但是一个键值可以对应多个真实值),这样可以快速在数组等里面存取数据。下面我们建立一个HashMap,然后往里面放入12对key-value,这个HashMap的默认数组长度为16,我们的key分别存放在该数组的格子中,每个格子下面存放的元素又是以链表的方式存放元素。publicstaticvoidmain(String[]args){Mapmap=newHashMap();map.put("What","chenyz");map.put("You","chenyz");map.put("Don"t","chenyz");map.put("Know","chenyz");map.put("About","chenyz");map.put("Geo","chenyz");map.put("APIs","chenyz");map.put("Can"t","chenyz");map.put("Hurt","chenyz");map.put("you","chenyz");map.put("google","chenyz");map.put("map","chenyz");map.put("hello","chenyz");}当我们新添加一个元素时,首先我们通过Hash算法计算出这个元素的Hash值的hashcode,通过这个hashcode的值,我们就可以计算出这个新元素应该存放在这个hash表的哪个格子里面,如果这个格子中已经存在元素,那么就把新的元素加入到已经存在格子元素的链表中。运行上面的程序,我们对HashMap源码进行一点修改,打印出每个key对象的hash值What-->hash值:8You-->hash值:3Don"t-->hash值:7Know-->hash值:13About-->hash值:11Geo-->hash值:12APIs-->hash值:1Can"t-->hash值:7Hurt-->hash值:1you-->hash值:10google-->hash值:3map-->hash值:8hello-->hash值:0计算出来的Hash值分别代表该key应该存放在Hash表中对应数字的格子中,如果该格子已经有元素存在,那么该key就以链表的方式依次放入格子中从上表可以看出,Hash表是线性表和链表的综合所得,根据数据结构的定义,可以得出粗劣的结论,Hash算法的存取速度要比数组差一些,但是比起单纯的链表,在查找和存取方面却要好多。如果要查找一个元素时,同样的方式,通过Hash函数计算出这个元素的Hash值hashcode,然后通过这个hashcode值,直接找到跟这个hash值相对应的线性格子,进如该格子后,对这个格子存放的链表元素逐个进行比较,直到找到对应的hash值。在简单了解完Hash算法后,我们打开HashMap源码初始化HashMap下面我们看看Mapmap=newHashMap();这段代码究竟做了什么,发生了什么数据结构的变化。HashMap中几个重要的属性transientEntry[]table;用来保存key-value的对象Entry数组,也就是Hash表transientintsize;返回HashMap的键值对个数finalfloatloadFactor;负载因子,用来决定Entry数组是否扩容的因子,HashMap默认是0.75fintthreshold;重构因子,(capacity*loadfactor)负载因子与Entry[]数组容积的乘值publicclassHashMap<K,V>extendsAbstractMap<K,V>implementsMap<K,V>,Cloneable,Serializable{intthreshold;finalfloatloadFactor;transientEntry[]table;staticfinalfloatDEFAULT_LOAD_FACTOR=0.75f;staticfinalintDEFAULT_INITIAL_CAPACITY=16;publicHashMap(intinitialCapacity,floatloadFactor){if(initialCapacity<0)thrownewIllegalArgumentException("Illegalinitialcapacity:"+initialCapacity);if(initialCapacity>MAXIMUM_CAPACITY)initialCapacity=MAXIMUM_CAPACITY;if(loadFactor<=0||Float.isNaN(loadFactor))thrownewIllegalArgumentException("Illegalloadfactor:"+loadFactor);//Findapowerof2>=initialCapacityintcapacity=1;while(capacity<initialCapacity)capacity<<=1;this.loadFactor=loadFactor;threshold=(int)(capacity*loadFactor);table=newEntry[capacity];init();}以publicHashMap(intinitialCapacity,floatloadFactor)构造函数为例,另外两个构造函数实际上也是以同种方式来构建HashMap.首先是要确定hashMap的初始化的长度,这里使用的策略是循环查出一个大于initialCapacity的2的次方的数,例如initialCapacity的值是10,那么大于10的数是2的4次方,也就是16,capacity的值被赋予了16,那么实际上table数组的长度是16,之所以采用这样的策略来构建Hash表的长度,是因为2的次方运算对于计算机来说是有相当的效率。loadFactor,被称为负载因子,HashMap的默认负载因子是0.75fthreshold,接下来是重构因子,由负载因子和容量的乘机组成,它表示当HashMap元素被存放了多少个之后,需要对HashMap进行重构。通过这一系列的计算和定义后,初始化Entry[]table;put(key,value)接下来看一对key-value是如何被存放到HashMap中:put(key,value)publicVput(Kkey,Vvalue){if(key==null)returnputForNullKey(value);inthash=hash(key.hashCode());inti=indexFor(hash,table.length);System.out.println(key+"-->hash值:"+i);//这就是刚才程序打印出来的key对应hash值for(Entry<K,V>e=table[i];e!=null;e=e.next){Objectk;if(e.hash==hash&&((k=e.key)==key||key.equals(k))){VoldValue=e.value;e.value=value;e.recordAccess(this);returnoldValue;}}modCount++;addEntry(hash,key,value,i);returnnull;}staticinthash(inth){h^=(h>>>20)^(h>>>12);returnh^(h>>>7)^(h>>>4);}staticintindexFor(inth,intlength){returnh&(length-1);}这里是整个hash的关键,请打开源码查看一步一步查看。hash(key.hashCode())计算出key的hash码//对于hash()的算法,这里有一篇分析很透彻的文章<HashMaphash方法分析>indexFor(hash,table.length)通过一个与算法计算出来,该key应在存放在Hash表的哪个格子中。for(Entry<K,V>e=table[i];e!=null;e=e.next)然后再遍历table[i]格中的链表,判断是否已经存在一样的key,如果存在一样的key值,那么就用新的value覆盖旧的value,并把旧的value值返回。addEntry(hash,key,value,i)如果经过遍历链表没有发现同样的key,那么进行addEntry函数的操作,增加当前key到hash表中的第i个格子中的链表中voidaddEntry(inthash,Kkey,Vvalue,intbucketIndex){Entry<K,V>e=table[bucketIndex];table[bucketIndex]=newEntry<K,V>(hash,key,value,e);if(size++>=threshold)resize(2*table.length);}Entry<K,V>e=table[bucketIndex];创建一个Entry对象来存放键值(ps:Entry对象是一个链表对象)table[bucketIndex]=newEntry<K,V>(hash,key,value,e);将Entry对象添加到链表中if(size++>=threshold)resize(2*table.length);最后将size进行自增,判断size值是否大于重构因子,如果大于那么就是用resize进行扩容重构。voidresize(intnewCapacity){Entry[]oldTable=table;intoldCapacity=oldTable.length;if(oldCapacity==MAXIMUM_CAPACITY){threshold=Integer.MAX_VALUE;return;}Entry[]newTable=newEntry[newCapacity];transfer(newTable);table=newTable;threshold=(int)(newCapacity*loadFactor);}这里为什么是否需要扩容重构,其实是涉及到负载因子的性能问题loadFactor负载因子上面说过loadFactor是一个hashMap的决定性属性,HashSet和HashMap的默认负载因子都是0.75,它表示,如果哈希表的容量超过3/4时,将自动成倍的增加哈希表的容量,这个值是权衡了时间和空间的成本,如果负载因子较高,虽然会减少对内存空间的需求,但也会增加查找数据的时间开销,无论是put()和get()都涉及到对数据进行查找的动作,所以负载因子是不适宜设置过高get(key)接下来看看get(key)做了什么publicVget(Objectkey){if(key==null)returngetForNullKey();inthash=hash(key.hashCode());for(Entry<K,V>e=table[indexFor(hash,table.length)];e!=null;e=e.next){Objectk;if(e.hash==hash&&((k=e.key)==key||key.equals(k)))returne.value;}returnnull;}这些动作似乎是跟put(key,value)相识,通过hash算法获取key的hash码,再通过indexFor定位出该key存在于table的哪一个下表,获取该下标然后对下标中的链表进行遍历比对,如果有符合就直接返回该key的value值。keySet()这里还涉及另一个问题,上面说了HashMap是跟set没有任何亲属关系,但map也一样实现了keySet接口,下面谱析一下keySet在hashMap中是如何实现的,这里给出部分代码,请结合源码查看publicKnext(){returnnextEntry().getKey();}finalEntry<K,V>nextEntry(){if(modCount!=expectedModCount)thrownewConcurrentModificationException();Entry<K,V>e=next;if(e==null)thrownewNoSuchElementException();if((next=e.next)==null){Entry[]t=table;while(index<t.length&&(next=t[index++])==null);}current=e;returne;}代码很简单,就是对每个格子里面的链表进行遍历,也正是这个原因,当我们依次将key值put进hashMap中,但在使用map.entrySet().iterator()进行遍历时候却不是put时候的顺序。扩容在前面说到put函数的时候,已经提过了扩容的问题if(size++>=threshold)resize(2*table.length);这里一个是否扩容的判断,当数据达到了threshold所谓的重构因子,而不是HashMap的最大容量,就进行扩容。voidresize(intnewCapacity){Entry[]oldTable=table;intoldCapacity=oldTable.length;if(oldCapacity==MAXIMUM_CAPACITY){threshold=Integer.MAX_VALUE;return;}Entry[]newTable=newEntry[newCapacity];transfer(newTable);table=newTable;threshold=(int)(newCapacity*loadFactor);}voidtransfer(Entry[]newTable){Entry[]src=table;intnewCapacity=newTable.length;for(intj=0;j<src.length;j++){Entry<K,V>e=src[j];if(e!=null){src[j]=null;do{Entry<K,V>next=e.next;inti=indexFor(e.hash,newCapacity);e.next=newTable[i];newTable[i]=e;e=next;}while(e!=null);}}}transfer方法实际上是将所有的元素重新进行一些hash,这是因为容量变化了,每个元素相对应的hash值也会不一样。使用HashMap1.不要再高并发中使用HashMap,HashMap是线程不安全,如果被多个线程共享之后,将可能发生不可预知的问题。2.如果数据大小事固定的,最好在初始化的时候就给HashMap一个合理的容量值,如果使用newHashMap()默认构造函数,重构因子的值是16*0.75=12,当HashMap的容量超过了12后,就会进行一系列的扩容运算,重建一个原来成倍的数组,并且对原来存在的元素进行重新的hash运算,如果你的数据是有成千上万的,那么你的成千上万的数据也要跟这你的扩容不断的hash,这将产生高额的内存和cpu的大量开销。当然啦,HashMap的函数还有很多,不过都是基于table的链表进行操作,当然也就是hash算法,Map&hashMap在平时我们的应用非常多,最重要的是我们要对每句代码中每块数据结构变化心中有数。上面主要是参考了jdk源码,数据结构和一些相关资料本着好记性不如烂博客的精神记录下来,希望朋友们如果发觉哪里不对请指出来,虚心请教
2023-07-25 14:57:392

Java中,复制一个对象,有什么好的方法

直接implements Cloneable然后clone();
2023-07-25 14:57:543

什么是深拷贝和浅拷贝

C++中,浅复制和深复制对于完全的值类型没有区别。如果类或结构体的实例中含有指向不同属于一个对象的其它对象的指针时,那么浅复制和深复制的行为就有差异。浅复制仅复制对象本身(其中包括是指针的成员),这样不同被复制对象的成员中的对应非空指针会指向同一对象,被成员指针引用的对象成为共享的,无法直接通过指针成员安全地删除(因为若直接删除,另外对象中的指针就会无效,而访问无效指针是危险的;除非这些指针有引用计数或者其它手段确保被指对象的所有权);而深复制在浅复制的基础上,连同指针指向的对象也一起复制,代价比较高,但是相对容易管理。Java/C#用引用类型代替指针类型,在语言的特定上下文中有特定的操作模式和约定。具体可以见LS两位提供的链接。====[原创回答团]]
2023-07-25 14:58:028

如何使Java中的InputStream的深层复制

我们知道在Java中存在这个接口Cloneable,实现该接口的类都会具备被拷贝的能力,同时拷贝是在内存中进行,在性能方面比我们直接通过new生成对象来的快
2023-07-25 14:58:302

java中一个类中为什么不能调用另一个类的clone方法?

b中没有对应的clone方法 啊!!!
2023-07-25 14:58:515

java怎么复制一个一样的对象

可以使用clone来实现,clone用于为引用类型的复制1.使用clone方法的类必须先实现Cloneable接口,不然clone方法会直接返回CloneNotSupportedException不支持克隆的异常2、实现Cloneable接口的类应该使用公共方法重写 Object.clone(它是受保护的)。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的,也无法保证它将获得成功。3、在Java.lang.Object类中克隆方法是这么定义的:protected Object clone() throws CloneNotSupportedException创建并返回此对象的一个副本。表明是一个受保护的方法,同一个包中可见。按照惯例,返回的对象应该通过调用 super.clone 获得。详见关于clone的API文档
2023-07-25 14:59:071

java 怎样复制一个类?

public class AAA{public void seta(int aa){this.a = aa;}public int geta(){return this.a;}public void setb(int bb){this.b = bb;}public int getb(){return this.b;}}public class diaoyong(int a,int b){AAA aaa = new AAA()aaa.seta(a);aaa.setb(b);....println("a : "+aaa.geta())....println("b : "+aaa.getb())}楼主是这个意思吧?
2023-07-25 14:59:162

LinkedList 是单向链表还是双向链表

JDK上面的解释:public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, SerializableList 接口的链接列表实现。实现所有可选的列表操作,并且允许所有元素(包括 null)。除了实现 List 接口外,LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。此类实现 Deque 接口,为 add、poll 提供先进先出队列操作,以及其他堆栈和双端队列操作。所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表(从靠近指定索引的一端)。
2023-07-25 14:59:261

Java中不实现Cloneable接口,直接写一个copy函数会有什么样的后果?实现一个接口的好处是什么?

* 回复内容中包含的链接未经审核,可能存在风险,暂不予完整展示! 一 我的理解1 . 感觉接口最大的作用还是实现多态。而多态让程序结构的设计更加的优雅。比如java并发中的两个重要接口Runnable和Callable 就是非常好的例子。比如我们要设计一个执行线程的容器(java中已有实现好的线程池机制),要接收一个任务做参数,我们不可能给每一个任务去设计一个方法。接口就为所有的任务类型提供了一种标准,意思是你的任务只要符合这个标准,我的程序就可以处理。---------------------------------------------------2. 于是开发者就可以自由开发了创建一个任何属于自己的任务 Runnable myTask = new MyTask();只要告诉执行器我这是一个runnable就好了,具体执行JVM去动态处理XXXExecutor.execut(myTask)。。。。。-------------------------------------------------------------------回顾这个例子,我觉得既可以说接口是一种标准,亦可以说是类抽象上的又一层抽象写到这,我觉得java爽爆了。。。二 官方----------------------------又完善了下---------------------------------------下列分别是官方和大神的讨论, 是英文的, 如果你觉得哪里读不通, 可以采纳并追加询问哈. JAVA的接口理解是非常重要的. 希望可以帮到你.3 关于接口定义(官方, 解决What的问题)What Is an Interface? (The Javau2122 Tutorials > Learning the Java Language > Object-Oriented Programming Concepts)https://docs.o****.com/javase/tutorial/java/concepts/interface.html4 关于为什么要使用接口(解决How的问题)Why do we need interfaces in Java? - Stack Overflowhttp://s***********.com/questions/3528420/why-do-we-need-interfaces-in-java
2023-07-25 14:59:331

Java怎么实现打印机监控

Java的所有类 都是从java.lang.Object类继承而来的,而Object类提供下面的方法对对象进行复制:protected Object clone()子类也可以将这个方法覆盖掉,用自己的逻辑实现自己的复制方法。可以被使用clone()方法的类都必须实现Cloneable接口,Cloneable接口只起一个作用就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone方法。
2023-07-25 14:59:412

在类中创建对象和在方法中创建对象,这两种有什么区别?

1、new  使用java的关键字new来创建对象实例。构造函数链中的所有构造函数都会被自动调用。Java代码:   CreateInstance instance = new CreateInstance ();2、clone 构造函数不被自动调用。  Java代码:    public class CreateInstance implements Cloneable{    public CreateInstance getInstance() throws CloneNotSupportedException{     return (CreateInstance) this.clone(); } }  如果需要复制上面的那个obj指向的对象实例时,调用new CreateInstance().getInstance()方法就ok了。JDK中Object# clone()方法的原型是:protected native Object clone() throws  CloneNotSupportedException; 方法修饰符是protected,而不是public。 这种访问的不可见性使得对Object#clone()方法不可见。所以,必需重写Object的clone方法后才能使用。 Java代码:    public class CreateInstance implements Cloneable{    public CreateInstance clone throws CloneNotSupportedException{     return (CreateInstance) super.clone(); } } 值得注意的是 :如果需要使用clone方法,必需实现java.lang.Cloneable接口,否则会抛出java.lang.CloneNotSupportedException。 另外clone方法所做的的操作是直接复制字段的内容,换句话说,这个操作并不管该字段对应的对象实例内容。 像这样字段对字段的拷贝(field to field copy)就成为"浅拷贝",clone方法所做的正是"浅拷贝"。3、newInstance 利用java.lang.Class类的newInstance方法,则可根据Class对象的实例,建立该Class所表示的类的对象实例。 创建CreateInstace类的对象实例可以使用下面的语句(这样需要一个已经存在的对象实例)。 CreateInstance instance = CreateInstance.class.newInstance(); 或者使用下面的语句(只需要存在相应的.class文件即可) CreateInstance instance = (CreateInstance)Class.forname("com.create.instance.CreateInstance").newInstance(); 如果包下不存在相应.class文件,则会抛出ClassNotFoundException。 注意 :newInstance创建对象实例的时候会调用无参的构造函数,所以必需确保类中有无参数的构造函数,否则将会抛出java.lang.InstantiationException异常。 无法进行实例化。
2023-07-25 14:59:515

为什么用super.clone()

这是因为Java的多态性
2023-07-25 15:00:084

什么是深拷贝和浅拷贝以及如何实现深拷贝

43.避免对象的浅拷贝拷贝是在内存中进行,不通过new对象的性能高浅拷贝:只拷贝基本类型性的成员变量(值),没有对成员对象实现拷贝(拷贝的是引用地址)(1)少量类的深拷贝:拷贝类和成员对象实现Cloneable接口并实现clone方法。(本例)(2)大量类的深拷贝:每个类是向clone方法,工作量太大了,可以使用序列化拷贝 (44例子)(3)当然除了自己实现序列化拷贝,可以直接使用Apache下common工具类SerializationUtil序列化深拷贝
2023-07-25 15:00:162

根据下面的要求编写复数类ComplexNumber

public class ComplexNumber implements Cloneable{ /** 复数的实部 */ private double realPart; /** 复数的虚部 */ private double imaginaryPart; /** 默认构造函数 */ public ComplexNumber() { this.realPart = 0.0; this.imaginaryPart = 0.0; } /** * 构造函数 * @param a 实部 * @param b 虚部 */ public ComplexNumber(double a, double b) { this.realPart = a; this.imaginaryPart = b; } /** * 复数的加法运算。 * c = a + b的运算法则是: * c.实部 = a.实部 + b.实部; c.虚部 = a.虚部 + b.虚部 * @param aComNum 加数 * @return */ public ComplexNumber add(ComplexNumber aComNum) { if (aComNum == null) { System.err.println("对象不能够为null!"); return new ComplexNumber(); } return new ComplexNumber(this.realPart + aComNum.getRealPart(), this.imaginaryPart + aComNum.getImaginaryPart()); } /** * 复数的减法运算。 * c = a - b的运算法则是: * c.实部 = a.实部 - b.实部; c.虚部 = a.虚部 - b.虚部 * @param aComNum 减数 * @return */ public ComplexNumber decrease(ComplexNumber aComNum) { if (aComNum == null) { System.err.println("对象不能够为null!"); return new ComplexNumber(); } return new ComplexNumber(this.realPart - aComNum.getRealPart(), this.imaginaryPart - aComNum.getImaginaryPart()); } /** * 复数的乘法运算。 * c = a * b的运算法则是: * c.实部 = a.实部 * b.实部 - a.虚部 * b.虚部; * c.虚部 = a.虚部 * b.实部 + a.实部 * b.虚部; * @param aComNum 乘数 * @return */ public ComplexNumber multiply(ComplexNumber aComNum) { if (aComNum == null) { System.err.println("对象不能够为null!"); return new ComplexNumber(); } double newReal = this.realPart * aComNum.realPart - this.imaginaryPart * aComNum.imaginaryPart; double newImaginary = this.realPart * aComNum.imaginaryPart + this.imaginaryPart * aComNum.realPart; ComplexNumber result = new ComplexNumber(newReal, newImaginary); return result; } /** * 复数的除法运算。 * c = a / b 的运算法则是: * c.实部 = (a.实部 * b.实部 + a.虚部 * b.虚部) / (b.实部 *b.实部 + b.虚部 * b.虚部); * c.虚部 = (a.虚部 * b.实部 - a.实部 * b.虚部) / (b.实部 * b.实部 + b.虚部 * b.虚部); * @param aComNum 除数 * @return */ public ComplexNumber divide(ComplexNumber aComNum) { if (aComNum == null) { System.err.println("对象不能够为null!"); return new ComplexNumber(); } if ((aComNum.getRealPart() == 0) && (aComNum.getImaginaryPart() == 0)) { System.err.println("除数不能够为0!"); return new ComplexNumber(); } double temp = aComNum.getRealPart() * aComNum.getRealPart() + aComNum.getImaginaryPart() * aComNum.getImaginaryPart(); double crealpart = (this.realPart * aComNum.getRealPart() + this.imaginaryPart * aComNum.getImaginaryPart()) / temp; double cimaginaryPart = (this.imaginaryPart * aComNum.getRealPart() - this.realPart * aComNum.getImaginaryPart()) / temp; return new ComplexNumber(crealpart, cimaginaryPart); } /** * 将一个复数显示为字符串 */ public String toString() { return this.realPart + " + " + this.imaginaryPart + "i"; } /** * 比较一个对象是否和这个复数对象的值相等 */ public boolean equals(Object obj) { if (obj == null) { return false; } // 首先判断a是不是一个复数对象,instanceof关键字是用来判断对象的类型。 if (obj instanceof ComplexNumber) { // 如果a是复数对象,需要将它强制类型转换成复数对象,才能调用复数类提供的方法。 ComplexNumber b = (ComplexNumber) obj; if ((this.realPart == b.getRealPart()) && (this.imaginaryPart == b.getImaginaryPart())) { return true; } else { return false; } } else { return false; } } /** * 获得该复数对象的hashcode */ public int hashCode() { // 如果两个复数对象是equals的,那么它们的hashCode也必须相同。 // 两个值相等的复数对象通过toString()方法得到的输出字符串是一样的, // 于是,可以把得到的字符串的hashCode当作复数对象的hashCode return this.toString().hashCode(); } /** * 根据现有对象克隆一个新对象 */ public Object clone() { // 如果你要使自定义的类能够被clone,就必须实现Cloneable接口并且重写它的clone()方法. // 如果你仅仅重写了clone方法而没有在类的声明中添加实现Cloneable接口,调用clone方法时将会出现 // CloneNotSupportedException异常,读者可以试试。 try { ComplexNumber newObject = (ComplexNumber) super.clone(); newObject.setRealPart(this.realPart); newObject.setImaginaryPart(this.imaginaryPart); return newObject; } catch (CloneNotSupportedException e) { // //如果没有实现Cloneable接口,抛出异常 e.printStackTrace(); return null; } } /** * @return 返回 imaginaryPart。 */ public double getImaginaryPart() { return imaginaryPart; } /** * @param imaginaryPart 要设置的 imaginaryPart。 */ public void setImaginaryPart(double imaginaryPart) { this.imaginaryPart = imaginaryPart; } /** * @return 返回 realPart。 */ public double getRealPart() { return realPart; } /** * @param realPart 要设置的 realPart。 */ public void setRealPart(double realPart) { this.realPart = realPart; } public static void main(String[] args) throws CloneNotSupportedException { ComplexNumber a = new ComplexNumber(2, 4); ComplexNumber b = new ComplexNumber(2, 4); System.out.println("ComplexNumber a: " + a.toString()); System.out.println("ComplexNumber b: " + b.toString()); System.out.println("a.euqals(b) = " + a.equals(b)); System.out.println("a.hashCode = " + a.hashCode() + "; b.hashCode = " + b.hashCode()); System.out.println("a.clone = " + a.clone().toString());// System.out.println("(a + b) = " + a.add(b).toString());// System.out.println("(a - b) = " + a.decrease(b).toString());// System.out.println("(a * b) = " + a.multiply(b).toString());// System.out.println("(a / b) = " + a.divide(b).toString());// System.out.println(a.equals(b));// ComplexNumber c = new ComplexNumber(1, 2);// ComplexNumber d = new ComplexNumber(1.00, 2.0);//// ComplexNumber e = (ComplexNumber) d.clone();// System.out.println(e.toString()); }}
2023-07-25 15:01:161

一个对象没实现Cloneable 接口,该怎么实现clone功能

因为clone声明的方法是接口所以实现接口的时候要全部实现接口所包含的全部方法这里的Cloneable接口就一个clone方法所以是这样..补充点public interface Cloneable此类实现了 Cloneable 接口,以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。 如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法,则会导致抛出 CloneNotSupportedException 异常。 按照惯例,实现此接口的类应该使用公共方法重写 Object.clone(它是受保护的)。请参阅 Object.clone(),以获得有关重写此方法的详细信息。 注意,此接口不 包含 clone 方法。因此,因为某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的,也无法保证它将获得成功。 答案补充 是啊,这个时候实现的时候是根据用户自己去写里面的代码啊接口都是里面只有函数的声明,没有函数的实现所以这里的clone方法是用户自己去写的....... 答案补充 接口就是只有函数声明,没有函数实现;为什么要用这种,是因为在编写程序的时候一个类只能继承一个类,但是可以实现N个接口
2023-07-25 15:01:481

java中常见的几种异常

java.lang.nullpointerexception 解释是"程序遇上了空指针",就是调用了未经初始化的对象或者是不存在。java.lang.classnotfoundexception 解释是"指定的类不存在",这里主要考虑一下类的名称和路径是否正确即可。java.lang.arrayindexoutofboundsexception 解释是"数组下标越界",现在程序中大多都有对数组的操作,因此在调用数组的时候一定要认真检查,看自己调用的下标是不是超出了数组的范围。FileNotFoundException 解释是“文件未找到异常”。IOException 解释是”输入输出流异常“。
2023-07-25 15:02:0112

java怎么判断异常类型

1. java.lang.nullpointerexception这个异常大家肯定都经常遇到,异常的解释是"程序遇上了空指针",简单地说就是调用了未经初始化的对象或者是不存在的对象,这个错误经常出现在创建图片,调用数组这些操作中,比如图片未经初始化,或者图片创建时的路径错误等等。对数组操作中出现空指针,很多情况下是一些刚开始学习编程的朋友常犯的错误,即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间,而初始化后的数组,其中的元素并没有实例化,依然是空的,所以还需要对每个元素都进行初始化(如果要调用的话)2. java.lang.classnotfoundexception这个异常是很多原本在jb等开发环境中开发的程序员,把jb下的程序包放在wtk下编译经常出现的问题,异常的解释是"指定的类不存在",这里主要考虑一下类的名称和路径是否正确即可,如果是在jb下做的程序包,一般都是默认加上package的,所以转到wtk下后要注意把package的路径加上。3. java.lang.arithmeticexception这个异常的解释是"数学运算异常",比如程序中出现了除以零这样的运算就会出这样的异常,对这种异常,大家就要好好检查一下自己程序中涉及到数学运算的地方,公式是不是有不妥了。4. java.lang.arrayindexoutofboundsexception这个异常相信很多朋友也经常遇到过,异常的解释是"数组下标越界",现在程序中大多都有对数组的操作,因此在调用数组的时候一定要认真检查,看自己调用的下标是不是超出了数组的范围,一般来说,显示(即直接用常数当下标)调用不太容易出这样的错,但隐式(即用变量表示下标)调用就经常出错了,还有一种情况,是程序中定义的数组的长度是通过某些特定方法决定的,不是事先声明的,这个时候,最好先查看一下数组的length,以免出现这个异常。5. java.lang.illegalargumentexception这个异常的解释是"方法的参数错误",很多j2me的类库中的方法在一些情况下都会引发这样的错误,比如音量调节方法中的音量参数如果写成负数就会出现这个异常,再比如g.setcolor(int red,int green,int blue)这个方法中的三个值,如果有超过255的也会出现这个异常,因此一旦发现这个异常,我们要做的,就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。6. java.lang.illegalaccessexception这个异常的解释是"没有访问权限",当应用程序要调用一个类,但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。其他还有很多异常,我就不一一列举了,我要说明的是,一个合格的程序员,需要对程序中常见的问题有相当的了解和相应的解决办法,否则仅仅停留在写程序而不会改程序的话,会极大影响到自己的开发的。关于异常的全部说明,在api里都可以查阅。算术异常类:ArithmeticExecption空指针异常类:NullPointerException类型强制转换异常:ClassCastException数组负下标异常:NegativeArrayException数组下标越界异常:ArrayIndexOutOfBoundsException违背安全原则异常:SecturityException文件已结束异常:EOFException文件未找到异常:FileNotFoundException字符串转换为数字异常:NumberFormatException操作数据库异常:SQLException输入输出异常:IOException方法未找到异常:NoSuchMethodExceptionjava.lang.AbstractMethodError抽象方法错误。当应用试图调用抽象方法时抛出。java.lang.AssertionError断言错。用来指示一个断言失败的情况。java.lang.ClassCircularityError类循环依赖错误。在初始化一个类时,若检测到类之间循环依赖则抛出该异常。java.lang.ClassFormatError类格式错误。当Java虚拟机试图从一个文件中读取Java类,而检测到该文件的内容不符合类的有效格式时抛出。java.lang.Error错误。是所有错误的基类,用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。java.lang.ExceptionInInitializerError初始化程序错误。当执行一个类的静态初始化程序的过程中,发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。java.lang.IllegalAccessError违法访问错误。当一个应用试图访问、修改某个类的域(Field)或者调用其方法,但是又违反域或方法的可见性声明,则抛出该异常。java.lang.IncompatibleClassChangeError不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时,抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下,容易引发该错误。java.lang.InstantiationError实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.java.lang.InternalError内部错误。用于指示Java虚拟机发生了内部错误。java.lang.LinkageError链接错误。该错误及其所有子类指示某个类依赖于另外一些类,在该类编译之后,被依赖的类改变了其类定义而没有重新编译所有的类,进而引发错误的情况。java.lang.NoClassDefFoundError未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类,而找不到该类的定义时抛出该错误。java.lang.NoSuchFieldError域不存在错误。当应用试图访问或者修改某类的某个域,而该类的定义中没有该域的定义时抛出该错误。java.lang.NoSuchMethodError方法不存在错误。当应用试图调用某类的某个方法,而该类的定义中没有该方法的定义时抛出该错误。java.lang.OutOfMemoryError内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。java.lang.StackOverflowError堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。java.lang.ThreadDeath线程结束。当调用Thread类的stop方法时抛出该错误,用于指示线程结束。java.lang.UnknownError未知错误。用于指示Java虚拟机发生了未知严重错误的情况。java.lang.UnsatisfiedLinkError未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。java.lang.UnsupportedClassVersionError不支持的类版本错误。当Java虚拟机试图从读取某个类文件,但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候,抛出该错误。java.lang.VerifyError验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。java.lang.VirtualMachineError虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。java.lang.ArithmeticException算术条件异常。譬如:整数除零等。java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。java.lang.ArrayStoreException数组存储异常。当向数组中存放非数组声明类型对象时抛出。java.lang.ClassCastException类造型异常。假设有类A和B(A不是B的父类或子类),O是A的实例,那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。java.lang.ClassNotFoundException找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。java.lang.CloneNotSupportedException不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。java.lang.EnumConstantNotPresentException枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象,但该枚举对象并不包含常量时,抛出该异常。java.lang.Exception根异常。用以描述应用程序希望捕获的情况。java.lang.IllegalAccessException违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法,而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。java.lang.IllegalMonitorStateException违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象(O)的监控器或者通知其他线程等待该对象(O)的监控器时,抛出该异常。java.lang.IllegalStateException违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态,而调用了该方法时,抛出该异常。java.lang.IllegalThreadStateException违法的线程状态异常。当县城尚未处于某个方法的合法调用状态,而调用了该方法时,抛出异常。java.lang.IndexOutOfBoundsException索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时,抛出该异常。java.lang.InstantiationException实例化异常。当试图通过newInstance()方法创建某个类的实例,而该类是一个抽象类或接口时,抛出该异常。java.lang.InterruptedException被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态,而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。java.lang.NegativeArraySizeException数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。java.lang.NoSuchFieldException属性不存在异常。当访问某个类的不存在的属性时抛出该异常。java.lang.NoSuchMethodException方法不存在异常。当访问某个类的不存在的方法时抛出该异常。java.lang.NullPointerException空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。java.lang.NumberFormatException数字格式异常。当试图将一个String转换为指定的数字类型,而该字符串确不满足数字类型要求的格式时,抛出该异常。java.lang.RuntimeException运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。java.lang.SecurityException安全异常。由安全管理器抛出,用于指示违反安全情况的异常。java.lang.StringIndexOutOfBoundsException字符串索引越界异常。当使用索引值访问某个字符串中的字符,而该索引值小于0或大于等于序列大小时,抛出该异常。java.lang.TypeNotPresentException类型不存在异常。当应用试图
2023-07-25 15:02:541

为什么不能直接调用clone方法

API文档中有这样的一段话:Object 类本身不实现接口 Cloneable,所以在类为 Object 的对象上调用 clone 方法将会导致在运行时抛出异常。
2023-07-25 15:03:023

java怎么样构造函数复制一个对象

java复制对象:一、使用clone。对象可克隆的类必须实现Cloneable接口,并且clone方法是浅克隆。二、类实现Serializable,用ObjectOutputStream、ObjectInputStream 来复制对象。三、可以直接new一个对象,赋值!
2023-07-25 15:03:102

java中的浅克隆和深克隆是什么

浅克隆就是只能在本机识别的,深克隆就是其他平台也能识别的,这个需要用到序列化
2023-07-25 15:03:214

Rectangle2D.Double做什么用的

ava.awt.geom类 Rectangle2D.Doublejava.lang.Object 继承者 java.awt.geom.RectangularShape 继承者 java.awt.geom.Rectangle2D 继承者 java.awt.geom.Rectangle2D.Double所有已实现的接口: Shape, Cloneable正在封闭类: Rectangle2Dpublic static class Rectangle2D.Doubleextends Rectangle2DDouble 类定义以 double 坐标指定的矩形。从以下版本开始: 1.2嵌套类摘要从类 java.awt.geom.Rectangle2D 继承的嵌套类/接口Rectangle2D.Double, Rectangle2D.Float字段摘要 double height 此 Rectangle2D 的高度。 double width 此 Rectangle2D 的宽度。 double x 此 Rectangle2D 的 X 坐标。 double y 此 Rectangle2D 的 Y 坐标。从类 java.awt.geom.Rectangle2D 继承的字段OUT_BOTTOM, OUT_LEFT, OUT_RIGHT, OUT_TOP构造方法摘要Rectangle2D.Double() 构造一个新 Rectangle2D,并将其初始化为:位置 (0, 0)、大小 (0, 0)。Rectangle2D.Double(double x, double y, double w, double h) 根据指定坐标构造和初始化 Rectangle2D。方法摘要 Rectangle2D createIntersection(Rectangle2D r) 返回一个新的 Rectangle2D 对象,它表示此 Rectangle2D 与指定 Rectangle2D 的交集。 Rectangle2D createUnion(Rectangle2D r) 返回一个新的 Rectangle2D 对象,它表示此 Rectangle2D 与指定 Rectangle2D 的并集。 Rectangle2D getBounds2D() 返回此 Rectangle2D 的高精度边界框。 double getHeight() 以 double 精度返回此 Rectangle2D 的高度。 double getWidth() 以 double 精度返回此 Rectangle2D 的宽度。 double getX() 以 double 精度返回此 Rectangle2D 的 X 坐标。 double getY() 以 double 精度返回此 Rectangle2D 的 Y 坐标。 boolean isEmpty() 确定此 Rectangle2D 是否为空。 int outcode(double x, double y) 确定指定 double 坐标相对于此 Rectangle2D 的位置。 void setRect(double x, double y, double w, double h) 将此 Rectangle2D 的位置和大小设置为指定的 double 值。 void setRect(Rectangle2D r) 将此 Rectangle2D 设置为与指定的 Rectangle2D 相同。 String toString() 返回此 Rectangle2D 的 String 表示形式。直接查api呀
2023-07-25 15:03:311

Java集合中List和 Map区别?

set集合中的数据没有顺序,且如果add两个一样的对象或基本类型的数据,set集合里也是只有一个,即set集合中的数据都是独一无二的;不能使用加强的for循环;list中的数据是有顺序的,可以加入多个一样的对象和基本类型的数据,可使用加强的for循环;map集合是键值对的形式进行存储,一个key,一个value。
2023-07-25 15:03:492

如何使Java中的InputStream的深层复制

我们知道在Java中存在这个接口Cloneable,实现该接口的类都会具备被拷贝的能力,同时拷贝是在内存中进行,在性能方面比我们直接通过new生成对象来的快,特别是在大对象的生成上,使得性能的提升非常明显。然而我们知道拷贝分为深拷贝和浅拷贝之分,但是浅拷贝存在对象属性拷贝不彻底问题。关于深拷贝、浅拷贝的请参考这里:渐析java的浅拷贝和深拷贝一、浅拷贝问题我们先看如下代码:[java] view plain copypublic class Person implements Cloneable{ /** 姓名 **/ private String name; /** 电子邮件 **/ private Email email; public String getName() { return name; } public void setName(String name) { this.name = name; } public Email getEmail() { return email; } public void setEmail(Email email) { this.email = email; } public Person(String name,Email email){ this.name = name; this.email = email; } public Person(String name){ this.name = name; } protected Person clone() { Person person = null; try { person = (Person) super.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return person; } } public class Client { public static void main(String[] args) { //写封邮件 Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议..."); Person person1 = new Person("张三",email); Person person2 = person1.clone(); person2.setName("李四"); Person person3 = person1.clone(); person3.setName("王五"); System.out.println(person1.getName() + "的邮件内容是:" + person1.getEmail().getContent()); System.out.println(person2.getName() + "的邮件内容是:" + person2.getEmail().getContent()); System.out.println(person3.getName() + "的邮件内容是:" + person3.getEmail().getContent()); } } -------------------- Output: 张三的邮件内容是:请与今天12:30到二会议室参加会议... 李四的邮件内容是:请与今天12:30到二会议室参加会议... 王五的邮件内容是:请与今天12:30到二会议室参加会议... 在该应用程序中,首先定义一封邮件,然后将该邮件发给张三、李四、王五三个人,由于他们是使用相同的邮件,并且仅有名字不同,所以使用张三该对象类拷贝李四、王五对象然后更改下名字即可。程序一直到这里都没有错,但是如果我们需要张三提前30分钟到,即把邮件的内容修改下:[java] view plain copypublic class Client { public static void main(String[] args) { //写封邮件 Email email = new Email("请参加会议","请与今天12:30到二会议室参加会议..."); Person person1 = new Person("张三",email); Person person2 = person1.clone(); person2.setName("李四"); Person person3 = person1.clone(); person3.setName("王五"); person1.getEmail().setContent("请与今天12:00到二会议室参加会议..."); System.out.println(person1.getName() + "的邮件内容是:" + person1.getEmail().getContent()); System.out.println(person2.getName() + "的邮件内容是:" + person2.getEmail().getContent()); System.out.println(person3.getName() + "的邮件内容是:" + person3.getEmail().getContent()); } } 在这里同样是使用张三该对象实现对李四、王五拷贝,最后将张三的邮件内容改变为:请与今天12:00到二会议室参加会议...。但是结果是:[java] view plain copy张三的邮件内容是:请与今天12:00到二会议室参加会议... 李四的邮件内容是:请与今天12:00到二会议室参加会议... 王五的邮件内容是:请与今天12:00到二会议室参加会议... 这里我们就疑惑了为什么李四和王五的邮件内容也发送了改变呢?让他们提前30分钟到人家会有意见的!其实出现问题的关键就在于clone()方法上,我们知道该clone()方法是使用Object类的clone()方法,但是该方法存在一个缺陷,它并不会将对象的所有属性全部拷贝过来,而是有选择性的拷贝,基本规则如下:1、 基本类型如果变量是基本很类型,则拷贝其值,比如int、float等。2、 对象如果变量是一个实例对象,则拷贝其地址引用,也就是说此时新对象与原来对象是公用该实例变量。3、 String字符串若变量为String字符串,则拷贝其地址引用。但是在修改时,它会从字符串池中重新生成一个新的字符串,原有紫都城对象保持不变。基于上面上面的规则,我们很容易发现问题的所在,他们三者公用一个对象,张三修改了该邮件内容,则李四和王五也会修改,所以才会出现上面的情况。对于这种情况我们还是可以解决的,只需要在clone()方法里面新建一个对象,然后张三引用该对象即可:[java] view plain copyprotected Person clone() { Person person = null; try { person = (Person) super.clone(); person.setEmail(new Email(person.getEmail().getObject(),person.getEmail().getContent())); } catch (CloneNotSupportedException e) { e.printStackTrace(); } return person; } 所以:浅拷贝只是Java提供的一种简单的拷贝机制,不便于直接使用。对于上面的解决方案还是存在一个问题,若我们系统中存在大量的对象是通过拷贝生成的,如果我们每一个类都写一个clone()方法,并将还需要进行深拷贝,新建大量的对象,这个工程是非常大的,这里我们可以利用序列化来实现对象的拷贝。二、利用序列化实现对象的拷贝如何利用序列化来完成对象的拷贝呢?在内存中通过字节流的拷贝是比较容易实现的。把母对象写入到一个字节流中,再从字节流中将其读出来,这样就可以创建一个新的对象了,并且该新对象与母对象之间并不存在引用共享的问题,真正实现对象的深拷贝。[java] view plain copypublic class CloneUtils { @SuppressWarnings("unchecked") public static <T extends Serializable> T clone(T obj){ T cloneObj = null; try { //写入字节流 ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream obs = new ObjectOutputStream(out); obs.writeObject(obj); obs.close(); //分配内存,写入原始对象,生成新对象 ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray()); ObjectInputStream ois = new ObjectInputStream(ios); //返回生成的新对象 cloneObj = (T) ois.readObject(); ois.close(); } catch (Exception e) { e.printStackTrace(); } return cloneObj; } } 使用该工具类的对象必须要实现Serializable接口,否则是没有办法实现克隆的。[html] view plain copypublic class Person implements Serializable{ private static final long serialVersionUID = 2631590509760908280L; .................. //去除clone()方法 } public class Email implements Serializable{ private static final long serialVersionUID = 1267293988171991494L; .................... } 所以使用该工具类的对象只要实现Serializable接口就可实现对象的克隆,无须继承Cloneable接口实现clone()方法。
2023-07-25 15:04:211

Object类 的Clone为什么要用protected

利用protected修饰clone方法,是为了安全考虑。Object类中的clone方法是浅拷贝,如果是对象,它拷贝的只是这个对象的一个引用,而这个引用仍然指向那个对象,当我们改变这个引用的属性时,原来对象也会跟着改变,这不是我们希望看到的,但是Object类肯定做不到深拷贝,因为它不知道你的类里有哪些引用类型,所以把修饰符定义为protected,这样想要在其他任何地方调用这个类的clone方法,这个类就必须去重写clone方法并且把修饰符改为public,并且把修饰符修改为public,这样在任何地方都可以调用这个类的clone方法了。如上图所示,类A是要被克隆的类,类B相当于要使用A的地方,如果类A不重写clone方法,在B类中是调不到clone方法的,因为A和B既不是子父类关系,也不在同一个包下,所以clone方法对B是不可见的。当类A实现Cloneable接口并且重写clone方法后,clone方法在B类中就可见了,也就是说我们在任何地方都可以克隆A了。总结:用protected修饰clone方法,主要是为了让子类去重写它,实现深拷贝,以防在其他任何地方随意调用后修改了对象的属性对原来的对象造成影响。http://blog.csdn.net/liyagangcsdn/article/details/68946795
2023-07-25 15:04:301

JAVA RuntimeException 问题

推荐的那个答案其实不精确的。首先,“RuntimeException发生后,说明代码存在BUG”这句话是没问题的,但用来说明RuntimeException却不合适,也没有意义。因为发生任何未处理的异常,都说明代码存在BUG。这句话如何理解呢,就拿ArrayIndexOutOfBoundsException来说,数组下标越界,你定义一个int is = new int[5];然后for(int index = 0;index<6;index++){int i = is[index];...}如果不看"..."中的内容,数组一定会越界,程序一定会在这里抛出异常。但如果...换成了 if(i == 4) break;那么这段代码就完全没有问题了。一般的ide,简单的代码逻辑是能分析出可能出现的情况并提示你的(但不会强制要求你改,因为语法没问题)。但编译器和ide不可能在编译时深入的去研究你的代码逻辑是否正常。而且你这段代码在语法上完全没有问题,它在编译时根本不知道这个异常是否会抛出,但是!如果下标越界那确实有问题,异常就必须要抛。所以就有人这样理解运行时异常:“RunTime:运行时,很简单,就是“运行时”异常。它表明,这个异常只有在运行的时候才能知道是否有异常,这就是运行时异常,又叫不可查异常,而编译时异常又叫可查异常!”这种说法不能算错,但也不严谨,因为很多编译时异常也是不可查的。比如你要读某一个文件123.txt,在编译时,编译器是不会去检查这个文件是否存在的(有人说,那编译时为什么不检查?你这样想:如果编译时文件存在,而且当程序还没执行到这里时,我把文件删了怎么办),这种情况下,程序也只有在运行时,才能知道文件是否存在,按上面的说法,这个异常(FileNotFoundException)也应该是运行时异常才对。但,稍微玩过java的人都知道,这个异常被强制要求处理,它是编译时异常。既然编译时异常和运行时异常都可能无法预期,那为什么还要有运行时异常和编译时异常之分呢,这个答案我找遍网络也找不到,java官方也没有详细说明,只是说运行时异常不强制要求处理,jvm会自动接管并一直向上抛出,直到栈顶或被处理。所以我自己总结了一点,我也不知道是否正确:RuntimeException,只是为了“减少代码中对异常做的处理而必须写代码”而引入的。拿一个很常见的运行时异常:nullPointException。空指针异常。这个异常发生在一个对象是null时,你对它进行了方法调用等操作。在java中,所有的Object都可以赋值为null的,如果NullPointException强制需要处理的话,那么几乎你的每一句代码都应该被try{}catch(NullpointException){}所包括,这样的java代码想想都可怕。我在一些网站上找到了这么一句话:“RuntimeException 类及其子类表示‘JVM 常用操作"引发的错误”,没错,这句话可能正说明了重点,正是因为这些异常发生在“JVM常用操作”中,也就是说这些异常随处都可能发生,而你不可能在代码的所有地方都try{}catch(RuntimeException){},所以为了简化代码,JVM对这些异常进行了默认处理:“抛出”。归根结底,运行时异常就是为了减少try{}catch(){}或throws 这类代码而引入的。纯手打,完全个人见解,欢迎讨论。
2023-07-25 15:04:394

在java中 clone为什么要用super.clone()方法 这里为什么要用super不是this

非常简单的道理,clone方法是重写的基类Object中的方法,所以通过super.clone()就可以指向它的内存引用复制出一个新的对象。至于为什么不用this.clone().在实现了cloneable接口重写了Clone方法后,在这个clone方法体中如果调用this.clone()就是调用自身的这个方法,陷入递归调用中从而形成死循环抛异常,所以不能使用this.clone()
2023-07-25 15:04:533

在java中常出现的异常和解决方法?

1. java.lang.nullpointerexception 这个异常大家肯定都经常遇到,异常的解释是"程序遇上了空指针",简单地说就是调用了未经初始化的对象或者是不存在的对象,这个错误经常出现在创建图片,调用数组这些操作中,比如图片未经初始化,或者图片创建时的路径错误等等。对数组操作中出现空指针,很多情况下是一些刚开始学习编程的朋友常犯的错误,即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间,而初始化后的数组,其中的元素并没有实例化,依然是空的,所以还需要对每个元素都进行初始化(如果要调用的话) 2. java.lang.classnotfoundexception 这个异常是很多原本在jb等开发环境中开发的程序员,把jb下的程序包放在wtk下编译经常出现的问题,异常的解释是"指定的类不存在",这里主要考虑一下类的名称和路径是否正确即可,如果是在jb下做的程序包,一般都是默认加上package的,所以转到wtk下后要注意把package的路径加上。 3. java.lang.arithmeticexception 这个异常的解释是"数学运算异常",比如程序中出现了除以零这样的运算就会出这样的异常,对这种异常,大家就要好好检查一下自己程序中涉及到数学运算的地方,公式是不是有不妥了。 4. java.lang.arrayindexoutofboundsexception 这个异常相信很多朋友也经常遇到过,异常的解释是"数组下标越界",现在程序中大多都有对数组的操作,因此在调用数组的时候一定要认真检查,看自己调用的下标是不是超出了数组的范围,一般来说,显示(即直接用常数当下标)调用不太容易出这样的错,但隐式(即用变量表示下标)调用就经常出错了,还有一种情况,是程序中定义的数组的长度是通过某些特定方法决定的,不是事先声明的,这个时候,最好先查看一下数组的length,以免出现这个异常。 5. java.lang.illegalargumentexception 这个异常的解释是"方法的参数错误",很多j2me的类库中的方法在一些情况下都会引发这样的错误,比如音量调节方法中的音量参数如果写成负数就会出现这个异常,再比如g.setcolor(int red,int green,int blue)这个方法中的三个值,如果有超过255的也会出现这个异常,因此一旦发现这个异常,我们要做的,就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。 6. java.lang.illegalaccessexception 这个异常的解释是"没有访问权限",当应用程序要调用一个类,但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。 其他还有很多异常,我就不一一列举了,我要说明的是,一个合格的程序员,需要对程序中常见的问题有相当的了解和相应的解决办法,否则仅仅停留在写程序而不会改程序的话,会极大影响到自己的开发的。关于异常的全部说明,在api里都可以查阅。算术异常类:ArithmeticExecption空指针异常类:NullPointerException类型强制转换异常:ClassCastException数组负下标异常:NegativeArrayException数组下标越界异常:ArrayIndexOutOfBoundsException违背安全原则异常:SecturityException文件已结束异常:EOFException文件未找到异常:FileNotFoundException字符串转换为数字异常:NumberFormatException操作数据库异常:SQLException输入输出异常:IOException方法未找到异常:NoSuchMethodExceptionjava.lang.AbstractMethodError抽象方法错误。当应用试图调用抽象方法时抛出。java.lang.AssertionError断言错。用来指示一个断言失败的情况。java.lang.ClassCircularityError类循环依赖错误。在初始化一个类时,若检测到类之间循环依赖则抛出该异常。java.lang.ClassFormatError类格式错误。当Java虚拟机试图从一个文件中读取Java类,而检测到该文件的内容不符合类的有效格式时抛出。java.lang.Error错误。是所有错误的基类,用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。java.lang.ExceptionInInitializerError初始化程序错误。当执行一个类的静态初始化程序的过程中,发生了异常时抛出。静态初始化程序是指直接包含于类中的static语句段。java.lang.IllegalAccessError违法访问错误。当一个应用试图访问、修改某个类的域(Field)或者调用其方法,但是又违反域或方法的可见性声明,则抛出该异常。java.lang.IncompatibleClassChangeError不兼容的类变化错误。当正在执行的方法所依赖的类定义发生了不兼容的改变时,抛出该异常。一般在修改了应用中的某些类的声明定义而没有对整个应用重新编译而直接运行的情况下,容易引发该错误。java.lang.InstantiationError实例化错误。当一个应用试图通过Java的new操作符构造一个抽象类或者接口时抛出该异常.java.lang.InternalError内部错误。用于指示Java虚拟机发生了内部错误。java.lang.LinkageError链接错误。该错误及其所有子类指示某个类依赖于另外一些类,在该类编译之后,被依赖的类改变了其类定义而没有重新编译所有的类,进而引发错误的情况。java.lang.NoClassDefFoundError未找到类定义错误。当Java虚拟机或者类装载器试图实例化某个类,而找不到该类的定义时抛出该错误。java.lang.NoSuchFieldError域不存在错误。当应用试图访问或者修改某类的某个域,而该类的定义中没有该域的定义时抛出该错误。java.lang.NoSuchMethodError方法不存在错误。当应用试图调用某类的某个方法,而该类的定义中没有该方法的定义时抛出该错误。java.lang.OutOfMemoryError内存不足错误。当可用内存不足以让Java虚拟机分配给一个对象时抛出该错误。java.lang.StackOverflowError堆栈溢出错误。当一个应用递归调用的层次太深而导致堆栈溢出时抛出该错误。java.lang.ThreadDeath线程结束。当调用Thread类的stop方法时抛出该错误,用于指示线程结束。java.lang.UnknownError未知错误。用于指示Java虚拟机发生了未知严重错误的情况。java.lang.UnsatisfiedLinkError未满足的链接错误。当Java虚拟机未找到某个类的声明为native方法的本机语言定义时抛出。java.lang.UnsupportedClassVersionError不支持的类版本错误。当Java虚拟机试图从读取某个类文件,但是发现该文件的主、次版本号不被当前Java虚拟机支持的时候,抛出该错误。java.lang.VerifyError验证错误。当验证器检测到某个类文件中存在内部不兼容或者安全问题时抛出该错误。java.lang.VirtualMachineError虚拟机错误。用于指示虚拟机被破坏或者继续执行操作所需的资源不足的情况。java.lang.ArithmeticException算术条件异常。譬如:整数除零等。java.lang.ArrayIndexOutOfBoundsException数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。java.lang.ArrayStoreException数组存储异常。当向数组中存放非数组声明类型对象时抛出。java.lang.ClassCastException类造型异常。假设有类A和B(A不是B的父类或子类),O是A的实例,那么当强制将O构造为类B的实例时抛出该异常。该异常经常被称为强制类型转换异常。java.lang.ClassNotFoundException找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。java.lang.CloneNotSupportedException不支持克隆异常。当没有实现Cloneable接口或者不支持克隆方法时,调用其clone()方法则抛出该异常。java.lang.EnumConstantNotPresentException枚举常量不存在异常。当应用试图通过名称和枚举类型访问一个枚举对象,但该枚举对象并不包含常量时,抛出该异常。java.lang.Exception根异常。用以描述应用程序希望捕获的情况。java.lang.IllegalAccessException违法的访问异常。当应用试图通过反射方式创建某个类的实例、访问该类属性、调用该类方法,而当时又无法访问类的、属性的、方法的或构造方法的定义时抛出该异常。java.lang.IllegalMonitorStateException违法的监控状态异常。当某个线程试图等待一个自己并不拥有的对象(O)的监控器或者通知其他线程等待该对象(O)的监控器时,抛出该异常。java.lang.IllegalStateException违法的状态异常。当在Java环境和应用尚未处于某个方法的合法调用状态,而调用了该方法时,抛出该异常。java.lang.IllegalThreadStateException违法的线程状态异常。当县城尚未处于某个方法的合法调用状态,而调用了该方法时,抛出异常。java.lang.IndexOutOfBoundsException索引越界异常。当访问某个序列的索引值小于0或大于等于序列大小时,抛出该异常。java.lang.InstantiationException实例化异常。当试图通过newInstance()方法创建某个类的实例,而该类是一个抽象类或接口时,抛出该异常。java.lang.InterruptedException被中止异常。当某个线程处于长时间的等待、休眠或其他暂停状态,而此时其他的线程通过Thread的interrupt方法终止该线程时抛出该异常。java.lang.NegativeArraySizeException数组大小为负值异常。当使用负数大小值创建数组时抛出该异常。java.lang.NoSuchFieldException属性不存在异常。当访问某个类的不存在的属性时抛出该异常。java.lang.NoSuchMethodException方法不存在异常。当访问某个类的不存在的方法时抛出该异常。java.lang.NullPointerException空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。java.lang.NumberFormatException数字格式异常。当试图将一个String转换为指定的数字类型,而该字符串确不满足数字类型要求的格式时,抛出该异常。java.lang.RuntimeException运行时异常。是所有Java虚拟机正常操作期间可以被抛出的异常的父类。java.lang.SecurityException安全异常。由安全管理器抛出,用于指示违反安全情况的异常。java.lang.StringIndexOutOfBoundsException字符串索引越界异常。当使用索引值访问某个字符串中的字符,而该索引值小于0或大于等于序列大小时,抛出该异常。java.lang.TypeNotPresentException类型不存在异常。当应用试图
2023-07-25 15:05:061

java的linkedList怎么没有isEmpty方法

有呀,其实你可以敲一下代码就知道。
2023-07-25 15:05:141

在java中 clone为什么要用super.clone()方法?

1.Object中的clone执行的时候使用了RTTI(run-time type identification)的机制,动态得找到目前正在调用clone方法的那个reference,根据它的大小申请内存空间,然后进行bitwise的复制,将该对象的内存空间完全复制到新的空间中去,从而达到shallowcopy的目的。 x0dx0a 所以你调用super.clone() 得到的是当前调用类的副本,而不是父类的副本。根本没有必用调用this.clone();x0dx0a2.要让实例调用clone方法就需要让此类实现Cloneable接口,API里面还有句话是:如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone 方法,则会导致抛出 CloneNotSupportedException 异常,这便是“合法”的含义。 但请注意,Cloneable接口只是个标签接口,不含任何需要实现的方法,就像Serializable接口一样。x0dx0ax0dx0a总之,一般如果你的子类没有特殊需要而重写clone()方法就直接用super.clone() 就行了。
2023-07-25 15:05:511

怎么样分辨eclipse控制台的信息哪些是错误的?

一般都是出现异常之类
2023-07-25 15:06:024

我想要复制ResultSet的对象 怎么弄?

不知道,clone 行吗?
2023-07-25 15:06:209