oracle绑定变量的java 代码如下：
String v_id = 'xxxxx';
//嵌入绑定变量
String v_sql = 'select name from table_a where id = ? ';
stmt = con.prepareStatement( v_sql );
stmt.setString(1, v_id ); //为绑定变量赋值
stmt.executeQuery();
&&&回复&&&：
北京盛拓优讯信息技术有限公司. 版权所有 京ICP备号 北京市公安局海淀分局网监中心备案编号：10
广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员博客分类：
在使用SNMP4J时，我想指定创建的客户端使用的本地IP和端口，因为在Socket时这是可以的，但是发现无法实现
因为SNMP4J底层的通信是使用NIO实现的，而NIO编程时貌似就不能显示的指定
例如在SNMP4J的DefaultTcpTransportMapping类里面，当作为客户端需要发送消息时，程序首先判断是否创建了这个客户端，如果没有在创建时看到这样的代码：
SocketChannel sc =
sc = SocketChannel.open();
sc.configureBlocking(false);
sc.connect(new InetSocketAddress(((TcpAddress) address).getInetAddress(),((TcpAddress) address).getPort()));
s = sc.socket();
entry = new SocketEntry((TcpAddress) address, s);
entry.addMessage(message);
sockets.put(address, entry);
synchronized (pending) {
pending.add(entry);
selector.wakeup();
logger.debug("Trying to connect to " + address);
} catch (IOException iox) {
logger.error(iox);
即使在SocketChannel中，他的Socket变量定义也是不能修改的：
* Retrieves a socket associated with this channel.
* &p& The returned object will not declare any public methods that are not
* declared in the {@link java.net.Socket} class.
A socket associated with this channel
public abstract Socket socket();
所以我直接判定Java NIO中，客户端是无法指定自己的IP和端口的！
那么有人在想为什么需要指定自己的IP和端口？具体需求我就不再说了，在计算机上虽然只有一块网卡，但是我们可以使用兼容的IP：
由于我的服务端程序以客户端IP来判断信息来源，现在我需要在我的电脑上做测试程序，需要同时邦定两个IP地址进行消息发送。
此时我就可以在高级设置里面设置兼容IP就可以，但是现在程序却无法选择。
在Socket里面可以这样写：
package com.xidian.nms.
import java.net.InetSocketA
import java.net.ServerS
import java.net.S
import java.net.SocketA
public class SocketServer {
public static void main(String[] args) throws Exception {
// 创建非邦定式连接对象
ServerSocket ss = new ServerSocket();
// 需要邦定的本地IP和地址
SocketAddress address = new InetSocketAddress("192.168.0.109", 2330);
// 将连接对象邦定到地址
ss.bind(address);
System.out.println("服务已经启动");
while (true) {
// 接收请求
Socket socketClient = ss.accept();
// 客户端IP
String ip = socketClient.getInetAddress().getHostAddress();
//　客户端端口
int port = socketClient.getPort();
System.out.println("服务端收到请求：" + ip + "/" + port);
服务端很简单，你可以一行代码搞定，也可以显示的指定IP、端口，然后进行显示的服务连接操作：
package com.xidian.nms.
import java.net.InetA
import java.net.InetSocketA
import java.net.S
import java.net.SocketA
public class SocketClient {
public static void main(String[] args)
throws Exception{
Socket socket = new Socket();
// 需要邦定的本地IP
InetAddress iaddThis = InetAddress.getByName("192.168.1.109");
// 需要邦定的本地地址
SocketAddress saddThis = new InetSocketAddress(iaddThis,2331);
socket.bind(saddThis);
// 连接的远程服务地址
InetAddress iaddRe = InetAddress.getByName("192.168.0.109");
SocketAddress saddRe = new InetSocketAddress(iaddRe,2330);
// 显示连接
socket.connect(saddRe);
Socket socket = new Socket("192.168.0.109", 2330);
注释掉的内容是一行搞定连接的方式。
当然这是我发现的一个问题，不知道如何解决，希望对NIO了解的人指点一下。
自建博客地址： ，内容与ITEYE同步！
&&&&&&&&&&&&&&& SocketChannel channel = SocketChannel.open();
Socket socket = channel.socket();
socket.bind(new InetSocketAddress("192.168.1.100", 999));
socket.connect(new InetSocketAddress("www.baidu.com", 80));
System.out.println(socket.getLocalAddress());
System.out.println(socket.getLocalPort());
channel.close();
你是想要这样的结果吗
谢谢提醒：
经过测试，如果想要修改所邦定的IP和显示再次进行连接操作，需要把设置NIO同步的代码放到后面：
sc = SocketChannel.open();
s = sc.socket();
s.bind(new InetSocketAddress("192.168.0.109", 999));
s.connect(new InetSocketAddress(((TcpAddress) address).getInetAddress(),((TcpAddress) address).getPort()));
sc.configureBlocking(false);
entry = new SocketEntry((TcpAddress) address, s);
entry.addMessage(message);
sockets.put(address, entry);
synchronized (pending) {
pending.add(entry);
selector.wakeup();
logger.debug("Trying to connect to " + address);
} catch (IOException iox) {
logger.error(iox);
否则会报错：
Exception in thread "main" java.nio.channels.IllegalBlockingModeException
at sun.nio.ch.SocketAdaptor.connect(SocketAdaptor.java:76)
at sun.nio.ch.SocketAdaptor.connect(SocketAdaptor.java:65)
at org.snmp4j.transport.DefaultTcpTransportMapping$ServerThread.sendMessage(DefaultTcpTransportMapping.java:503)
at org.snmp4j.transport.DefaultTcpTransportMapping.sendMessage(DefaultTcpTransportMapping.java:183)
at org.snmp4j.MessageDispatcherImpl.sendMessage(MessageDispatcherImpl.java:214)
at org.snmp4j.MessageDispatcherImpl.sendPdu(MessageDispatcherImpl.java:475)
at org.snmp4j.Snmp.sendMessage(Snmp.java:1110)
at org.snmp4j.Snmp.send(Snmp.java:914)
at org.snmp4j.Snmp.send(Snmp.java:894)
at org.snmp4j.Snmp.send(Snmp.java:859)
at com.xidian.nms.snmp.Snmp4jGet.sendPDU(Snmp4jGet.java:59)
at com.xidian.nms.snmp.Snmp4jGet.main(Snmp4jGet.java:38)
cuisuqiang
浏览: 3273223 次
来自: 北京
浏览量：3048890
你这应该只使用于windows系统吧？linux系统怎么转换？ ...
貌似少了一个java文件哈 ...
&div class=&quote_title ...
这个字段用法是如果相互之类超过多少时间没有数据交互，才抛出的正 ...
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
看Core Java的疑惑：编译器在编译的时候已经分析了方法的名称和参数，找到要调用的方法，为什么虚拟机在运行时还要再找一次？
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
java动态绑定过程,假设定义了一个Animal，一个cat,cat重写了eat方法
class CrazyZoo
public void main()
Animal animal = new Cat();
animal.eat();
这里的animal外观类型是Animal，对象实例其实是Cat，animal.eat()方法最终会正确的调用Cat的eat()方法多态过程大概是这样的：1、在Crazy这个类的常量池中查找eat方法，jvm发现是调用了Animal（外观类型）的eat方法2、去Animal的方法表中找到eat方法，找到之后记下eat方法在方法表中的偏移量3、根据实例对象（也就是堆上的cat对象）找到cat的方法表，因为在子类和父类的方法中同样的方法偏移量是一样的，根据之前得到的eat方法的偏移量，执行cat的eat方法。
同步到新浪微博
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。详解Java多态对象的类型转换与动态绑定
转载 &更新时间：日 18:28:57 & 投稿：goldensun
这篇文章主要介绍了详解Java多态对象的类型转换与动态绑定,是Java入门学习中的基础知识,需要的朋友可以参考下
Java多态对象的类型转换
这里所说的对象类型转换，是指存在继承关系的对象，不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时，java 运行时将抛出 java.lang.ClassCastException 异常。
在继承链中，我们将子类向父类转换称为“向上转型”，将父类向子类转换称为“向下转型”。
很多时候，我们会将变量定义为父类的类型，却引用子类的对象，这个过程就是向上转型。程序运行时通过动态绑定来实现对子类方法的调用，也就是多态性。
然而有些时候为了完成某些父类没有的功能，我们需要将向上转型后的子类对象再转成子类，调用子类的方法，这就是向下转型。
注意：不能直接将父类的对象强制转换为子类类型，只能将向上转型后的子类对象再次转换为子类类型。也就是说，子类对象必须向上转型后，才能再向下转型。请看下面的代码：
public class Demo {
public static void main(String args[]) {
SuperClass superObj = new SuperClass();
SonClass sonObj = new SonClass();
// 下面的代码运行时会抛出异常，不能将父类对象直接转换为子类类型
// SonClass sonObj2 = (SonClass)superO
// 先向上转型，再向下转型
superObj = sonO
SonClass sonObj1 = (SonClass)superO
class SuperClass{ }
class SonClass extends SuperClass{ }
将第7行的注释去掉，运行时会抛出异常，但是编译可以通过。
因为向下转型存在风险，所以在接收到父类的一个引用时，请务必使用 instanceof 运算符来判断该对象是否是你所要的子类，请看下面的代码：
public class Demo {
public static void main(String args[]) {
SuperClass superObj = new SuperClass();
SonClass sonObj = new SonClass();
// superObj 不是 SonClass 类的实例
if(superObj instanceof SonClass){
SonClass sonObj1 = (SonClass)superO
System.out.println("①不能转换");
superObj = sonO
// superObj 是 SonClass 类的实例
if(superObj instanceof SonClass){
SonClass sonObj2 = (SonClass)superO
System.out.println("②不能转换");
class SuperClass{ }
class SonClass extends SuperClass{ }
运行结果：
①不能转换
总结：对象的类型转换在程序运行时检查，向上转型会自动进行，向下转型的对象必须是当前引用类型的子类。
Java多态和动态绑定
在Java中，父类的变量可以引用父类的实例，也可以引用子类的实例。
请读者先看一段代码：
public class Demo {
public static void main(String[] args){
Animal obj = new Animal();
obj.cry();
obj = new Cat();
obj.cry();
obj = new Dog();
obj.cry();
class Animal{
// 动物的叫声
public void cry(){
System.out.println("不知道怎么叫");
class Cat extends Animal{
// 猫的叫声
public void cry(){
System.out.println("喵喵~");
class Dog extends Animal{
// 狗的叫声
public void cry(){
System.out.println("汪汪~");
运行结果：
不知道怎么叫
上面的代码，定义了三个类，分别是 Animal、Cat 和 Dog，Cat 和 Dog 类都继承自 Animal 类。obj 变量的类型为 Animal，它既可以指向 Animal 类的实例，也可以指向 Cat 和 Dog 类的实例，这是正确的。也就是说，父类的变量可以引用父类的实例，也可以引用子类的实例。注意反过来是错误的，因为所有的猫都是动物，但不是所有的动物都是猫。
可以看出，obj 既可以是人类，也可以是猫、狗，它有不同的表现形式，这就被称为多态。多态是指一个事物有不同的表现形式或形态。
再比如“人类”，也有很多不同的表达或实现，TA 可以是司机、教师、医生等，你憎恨自己的时候会说“下辈子重新做人”，那么你下辈子成为司机、教师、医生都可以，我们就说“人类”具备了多态性。
多态存在的三个必要条件：要有继承、要有重写、父类变量引用子类对象。
当使用多态方式调用方法时：
首先检查父类中是否有该方法，如果没有，则编译错误；如果有，则检查子类是否覆盖了该方法。
如果子类覆盖了该方法，就调用子类的方法，否则调用父类方法。
从上面的例子可以看出，多态的一个好处是：当子类比较多时，也不需要定义多个变量，可以只定义一个父类类型的变量来引用不同子类的实例。请再看下面的一个例子：
public class Demo {
public static void main(String[] args){
// 借助多态，主人可以给很多动物喂食
Master ma = new Master();
ma.feed(new Animal(), new Food());
ma.feed(new Cat(), new Fish());
ma.feed(new Dog(), new Bone());
// Animal类及其子类
class Animal{
public void eat(Food f){
System.out.println("我是一个小动物，正在吃" + f.getFood());
class Cat extends Animal{
public void eat(Food f){
System.out.println("我是一只小猫咪，正在吃" + f.getFood());
class Dog extends Animal{
public void eat(Food f){
System.out.println("我是一只狗狗，正在吃" + f.getFood());
// Food及其子类
class Food{
public String getFood(){
return "事物";
class Fish extends Food{
public String getFood(){
return "鱼";
class Bone extends Food{
public String getFood(){
return "骨头";
// Master类
class Master{
public void feed(Animal an, Food f){
an.eat(f);
运行结果：
我是一个小动物，正在吃事物
我是一只小猫咪，正在吃鱼
我是一只狗狗，正在吃骨头
Master 类的 feed 方法有两个参数，分别是 Animal 类型和 Food 类型，因为是父类，所以可以将子类的实例传递给它，这样 Master 类就不需要多个方法来给不同的动物喂食。
为了理解多态的本质，下面讲一下Java调用方法的详细流程。
1) 编译器查看对象的声明类型和方法名。
假设调用 obj.func(param)，obj 为 Cat 类的对象。需要注意的是，有可能存在多个名字为func但参数签名不一样的方法。例如，可能存在方法 func(int) 和 func(String)。编译器将会一一列举所有 Cat 类中名为func的方法和其父类 Animal 中访问属性为 public 且名为func的方法。
这样，编译器就获得了所有可能被调用的候选方法列表。
2) 接下来，编泽器将检查调用方法时提供的参数签名。
如果在所有名为func的方法中存在一个与提供的参数签名完全匹配的方法，那么就选择这个方法。这个过程被称为重载解析(overloading resolution)。例如，如果调用 func("hello")，编译器会选择 func(String)，而不是 func(int)。由于自动类型转换的存在，例如 int 可以转换为 double，如果没有找到与调用方法参数签名相同的方法，就进行类型转换后再继续查找，如果最终没有匹配的类型或者有多个方法与之匹配，那么编译错误。
这样，编译器就获得了需要调用的方法名字和参数签名。
3) 如果方法的修饰符是private、static、final（static和final将在后续讲解），或者是构造方法，那么编译器将可以准确地知道应该调用哪个方法，我们将这种调用方式 称为静态绑定(static binding)。
与此对应的是，调用的方法依赖于对象的实际类型， 并在运行时实现动态绑。例如调用 func("hello")，编泽器将采用动态绑定的方式生成一条调用 func(String) 的指令。
4)当程序运行，并且釆用动态绑定调用方法时，JVM一定会调用与 obj 所引用对象的实际类型最合适的那个类的方法。我们已经假设 obj 的实际类型是 Cat，它是 Animal 的子类，如果 Cat 中定义了 func(String)，就调用它，否则将在 Animal 类及其父类中寻找。
每次调用方法都要进行搜索，时间开销相当大，因此，JVM预先为每个类创建了一个方法表(method lable)，其中列出了所有方法的名称、参数签名和所属的类。这样一来，在真正调用方法的时候，虚拟机仅查找这个表就行了。在上面的例子中，JVM 搜索 Cat 类的方法表，以便寻找与调用 func("hello") 相匹配的方法。这个方法既有可能是 Cat.func(String)，也有可能是 Animal.func(String)。注意，如果调用super.func("hello")，编译器将对父类的方法表迸行搜索。
假设 Animal 类包含cry()、getName()、getAge() 三个方法，那么它的方法表如下：
cry() -& Animal.cry()
getName() -& Animal.getName()
getAge() -& Animal.getAge()
实际上，Animal 也有默认的父类 Object（后续会讲解），会继承 Object 的方法，所以上面列举的方法并不完整。
假设 Cat 类覆盖了 Animal 类中的 cry() 方法，并且新增了一个方法 climbTree()，那么它的参数列表为：
cry() -& Cat.cry()
getName() -& Animal.getName()
getAge() -& Animal.getAge()
climbTree() -& Cat.climbTree()
在运行的时候，调用 obj.cry() 方法的过程如下：
JVM 首先访问 obj 的实际类型的方法表，可能是 Animal 类的方法表，也可能是 Cat 类及其子类的方法表。
JVM 在方法表中搜索与 cry() 匹配的方法，找到后，就知道它属于哪个类了。
JVM 调用该方法。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具Java中的静态绑定和动态绑定 - 简书
Java中的静态绑定和动态绑定
先来看上的一个问题：
import java.util.*;
import java.lang.*;
import java.io.*;
int x = 5;
class B extends A
int x = 6;
class SubCovariantTest extends CovariantTest
public B getObject()
System.out.println("sub getobj");
return new B();
class CovariantTest
public A getObject()
System.out.println("ct getobj");
return new A();
public static void main (String[] args) throws java.lang.Exception
CovariantTest c1 = new SubCovariantTest();
System.out.println(c1.getObject().x);
当我们执行CovariantTest中的main()方法时，输出结果会是什么？
sub getobj
这不科学！既然c1.getObject()执行的是SubCovariantTest中的getObject()方法，那么应该返回的是B对象，所以应该输出6才对啊。
这个解释听上去很有道理，但忽略了Java中的静态绑定和动态绑定的知识。
静态绑定 vs 动态绑定
绑定：绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。
静态绑定：程序运行前方法已被绑定。即Java中编译期进行的绑定。
动态绑定：程序运行时根据具体对象的类型进行绑定。
Java中程序分为编译和解释两个阶段。
也就是说，Java文件被编译成class文件时，已经对其中的方法和域根据类信息进行了一次绑定（静态绑定）。
而运行时方法又会根据运行时对象信息进行另外一次绑定（动态绑定），也就说我们常说的多态
值得注意的是：Java中private,final,static方法以及域都是静态绑定，这也是Java中域不能被重写只能被隐藏的原因。
进一步理解两种绑定
什么？你还是不明白这两种绑定！没关系，我们来点更详细的Demo
int x = 5;
public void doSomething() {
System.out.println("A.doSomething()");
class B extends A
int x = 6;
public void doSomething() {
System.out.println("B.doSomething()");
public class Main {
public static void main(String args[]) {
A a=new B();
System.out.println(a.x);
a.doSomething();
B.doSomething()
结果在意料当中，我们来看下反编译Main.class文件后的信息：
//javap -c Main
Compiled from "Main.java"
public class test.Main {
public test.Main();
0: aload_0
1: invokespecial #1
// Method java/lang/Object."&init&":()V
public static void main(java.lang.String[]);
// class test/B
4: invokespecial #3
// Method test/B."&init&":()V
7: astore_1
8: getstatic
// Field java/lang/System.out:Ljava/io/PrintS
11: aload_1
12: getfield
// Field test/A.x:I
15: invokevirtual #6
// Method java/io/PrintStream.println:(I)V
18: aload_1
19: invokevirtual #7
// Method test/A.doSomething:()V
22: return
通过12：和19：后的注释我们可以知道，编译后的class文件中，域x和方法doSomething都是和A类绑定在了一起。而在程序执行时，doSomething方法会再根据运行的对象类型进行第二次的动态绑定，从执行了B类中的方法。
回到最开始问题。
我们反编译下CovariantTest.class文件：
//javap -c CovariantTest
Compiled from "CovariantTest.java"
public class test.CovariantTest {
public test.CovariantTest();
0: aload_0
1: invokespecial #1
// Method java/lang/Object."&init&":()V
public test.A getObject();
// class test/A
4: invokespecial #3
// Method test/A."&init&":()V
7: areturn
public static void main(java.lang.String[]);
// class test/SubCovariantTest
4: invokespecial #5
// Method test/SubCovariantTest."&init&":()V
7: astore_1
8: getstatic
// Field java/lang/System.out:Ljava/io/PrintS
11: aload_1
12: invokevirtual #7
// Method getObject:()Ltest/A;
15: getfield
// Field test/A.x:I
18: invokevirtual #9
// Method java/io/PrintStream.println:(I)V
21: return
从12:和15:可以看出，在编译期，c1跟类CovariantTest绑定在一起，所以c1.getObject()编译后认为是类A，c1.getObject().x编译后便成为了A.x。
又因为Java中域是静态绑定的，所以程序运行时便不会根据运行时对象类型来确定，所有最后输出了5
两种绑定各自的优缺点
静态绑定能够让我们在编译时就发现代码的许多错误，而且也提高了程序的运行效率。动态绑定的好处在于牺牲了运行效率但实现了多态
这里引用 中的一段话来总结：
java因为什么要对属性要采取静态的绑定方法。这是因为静态绑定是有很多的好处，它可以让我们在编译期就发现程序中的错误，而不是在运行期。这样就可以提高程序的运行效率！而对方法采取动态绑定是为了实现多态，多态是java的一大特色。多态也是面向对象的关键技术之一，所以java是以效率为代价来实现多态这是很值得的。
最后的啰嗦
这个问题我起初在CSDN上提问：，感谢
的回答。虽然当时还是有些不理解。过了段时间开始有点明白，所以写了这篇博客作总结。水平有限，仅供参考。
关于动态绑定更详细的实现机制可以看
Java 基础思维导图，让 Java 不再难懂 - 工具资源 - 掘金思维导图的好处 最近看了一些文章的思维导图，发现思维导图真是个强大的工具。了解了思维导图的作用之后，觉得把它运用到java上应该是个不错的想法，这样回顾知识点的时候一目了然，快速知道自己的短板。 思维导图...
1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语法，集合的语法，io的语法，虚拟机方面的语法。 1、一个&.java&源文件中是否可以包括多个类（不是内部类）？有什么限制？ 可以有多个类，但只能有一个publ...
1.import static是Java 5增加的功能,就是将Import类中的静态方法，可以作为本类的静态方法来用。 2.String和StringBuffer他们都可以存储和操作字符串，即包含多个字符的字符串数据。 String类是字符串常量，是不可更改的常量。而Str...
用两张图告诉你，为什么你的 App 会卡顿? - Android - 掘金Cover 有什么料？ 从这篇文章中你能获得这些料： 知道setContentView()之后发生了什么？ ... Android 获取 View 宽高的常用正确方式，避免为零 - 掘金相信有很多朋友...
前言 不知道大家有没有这样一种感觉，程序员的数量井喷了。可能是因为互联网火了，也可能是各家培训机构为我们拉来了大量的同行，更有可能是各行各业都不景气了，而互联网（在这前一段时间中）真是红遍了大江南北，烧红了整片天，所以到处都是我们的同行，所以竞争更加激烈了，那么我们就更得稳...
一，看似我从垃圾桶旁捡回一盆被遗弃的月季花，其实我捡回了自己曾丢失过的一个灵魂...... 去年也是这个时候，邻居老周把一盆长满了米虫的月季花给扔到小区的垃圾桶旁边。随后，我又把它捡回来放到我家后花园。 这已经是我的老毛病了，邻居们都知道。每当邻居们的花草要扔掉前，总是先跟...
第一章 我们有什么机会？ 我的名字叫做Efrat。我习惯将我父亲的稿子大声读给他听，他声称我的评论，甚至我的身体语言，帮助他观察到他的观点哪里不很清晰。 有一次我问他，“为什么是我？” “因为，不同于其他许多人，你不会欺骗自己装作你对组织机构的一切都很懂，更不用说人类的行为...
我不是独生子女。小时候，父母在外打工。我留守在了外婆，外公身边。与父母并不亲近。读小学的时候，外公去世，让我更加的依赖外婆。再到后面，母亲带着弟弟回来。我们之间的距离真的很远，我始终记得有一次她代替外婆帮我洗澡。无所适从的我直接把洗发露当成沐浴露擦在了身上，我记得她无语的表...
拷贝一个女友，是深拷贝，还是浅拷贝好？？？ 一、浅拷贝与深拷贝 浅拷贝：内存地址的拷贝，目标对象和源对象指向同一内存空间。深拷贝：拷贝整个对象内存到另一块内存中。 二、copy与mutableCopy copy：拷贝返回一个不可变对象。mutableCopy：拷贝返回一个可...
都说谁的青春不迷惘，迷惘或许不过是想的太多而做的太少。行动起来你会发现没有那么多闲暇时间胡思乱想。 刚刚在朋友圈看到一篇原创文字，标题是《25岁的北漂白领小王觉得自己生活得很庸俗》。因着25岁、北漂、白领几个感同身受的因素点开读了一下。看到了境遇相同却又不同心情的一群北漂人...}