-
Notifications
You must be signed in to change notification settings - Fork 0
/
atom.xml
401 lines (268 loc) · 45.1 KB
/
atom.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Liam的博客</title>
<subtitle>卢少的小生活</subtitle>
<link href="/atom.xml" rel="self"/>
<link href="http://yoursite.com/"/>
<updated>2019-01-26T07:36:38.316Z</updated>
<id>http://yoursite.com/</id>
<author>
<name>Liam</name>
</author>
<generator uri="http://hexo.io/">Hexo</generator>
<entry>
<title>内存泄漏。</title>
<link href="http://yoursite.com/2019/01/26/%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F/"/>
<id>http://yoursite.com/2019/01/26/内存泄漏/</id>
<published>2019-01-26T07:03:14.000Z</published>
<updated>2019-01-26T07:36:38.316Z</updated>
<content type="html"><![CDATA[<p>（百度百科）内存泄漏（Memory Leak）是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。<br><a id="more"></a></p><p>一般说内存泄漏原因存在两种情况，一个是堆中分配的内存，在没有将其释放掉的时候，就将所有能访问这块内存的方式都删掉；另一种情况则是在内存对象已经不需要的时候，还任然保留着这块内存和他的访问方式（引用）。</p><p>在java中，由于java已经存在较好的垃圾回收机制，所以第一种情况已经得到了较好的解决，java中的内存泄漏，主要是指第二种情况。</p><p>下面给出了一个简单的内存泄漏的例子。在这个例子中，我们循环申请Object对象，并将所有申请的对象放入一个List中，如果我们仅仅是放引用本身，那么List任然引用该对象，所以这个对象对GC来说是不可能回收的。代码如下所示:</p><pre><code>List list = new ArrayList(10);for(int i = 1;i < 100;i++){ Object o = new Object(); lsit.add(o); o = null;}</code></pre><p>此时，所有Object对象都没有被释放，因为变量list引用这些对象。</p>]]></content>
<summary type="html">
<p>（百度百科）内存泄漏（Memory Leak）是指程序中己动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。<br>
</summary>
<category term="java" scheme="http://yoursite.com/tags/java/"/>
<category term="基础知识" scheme="http://yoursite.com/tags/%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86/"/>
</entry>
<entry>
<title>Java集合中的删除和修改方法的具体实现</title>
<link href="http://yoursite.com/2018/08/04/Java%E9%9B%86%E5%90%88%E4%B8%AD%E7%9A%84%E5%88%A0%E9%99%A4%E5%92%8C%E4%BF%AE%E6%94%B9%E6%96%B9%E6%B3%95%E7%9A%84%E5%85%B7%E4%BD%93%E5%AE%9E%E7%8E%B0/"/>
<id>http://yoursite.com/2018/08/04/Java集合中的删除和修改方法的具体实现/</id>
<published>2018-08-04T01:09:25.000Z</published>
<updated>2018-08-04T06:16:00.473Z</updated>
<content type="html"><![CDATA[<p>Java中的集合是我们经常使用的Java工具类，Collection接口还有俩个子类。一个是List，一个是Set</p><p>1.List特点：有序的，元素可重复<br>2.Set特点：无序的，元素不可重复</p><p>在Java的API中，Collection接口一共要求实现以下方法。</p><pre><code> boolean add(E e) 将指定的元素添加到此列表的尾部。 void add(int index, E element) 将指定的元素插入此列表中的指定位置。 boolean addAll(Collection<? extends E> c) 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。 boolean addAll(int index, Collection<? extends E> c) 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。 void clear() 移除此列表中的所有元素。 Object clone() 返回此 ArrayList 实例的浅表副本。 boolean contains(Object o) 如果此列表中包含指定的元素，则返回 true。 void ensureCapacity(int minCapacity) 如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 E get(int index) 返回此列表中指定位置上的元素。 int indexOf(Object o) 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。 boolean isEmpty() 如果此列表中没有元素，则返回 true int lastIndexOf(Object o) 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。 E remove(int index) 移除此列表中指定位置上的元素。 boolean remove(Object o) 移除此列表中首次出现的指定元素（如果存在）。 protected void removeRange(int fromIndex, int toIndex) 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 E set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。 int size() 返回此列表中的元素数。 Object[] toArray() 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。 <T> T[] toArray(T[] a) 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。 void trimToSize() 将此 ArrayList 实例的容量调整为列表的当前大小。 </code></pre><a id="more"></a><p>我们知道，在集合中我们可以保存基本的数据类型和对象引用。而所有的相关操作都基本在collection的方法当中实现了。然而我思考了一下，在我们的平常使用的过程中，对于添加和查询操作都不需要知道集合中具体保存的元素是什么，而删除和查询就必须要知道我们的需要修改和删除的元素的信息，并进行比较。首先，元素的比较有很多的方法。对于基本的数据类型，我们只要用“==”号来判断我们的两个数据是否相同。而对于引用的数据类型，变量保存的是数据的地址，所以不能使用“==”来判断。而需要使用equals方法来进行判断才能成功。</p><hr><p>于是我尝试查看了一个继承了Collection的类——ArrayList。<br>查看了他的具体源码</p><pre><code>public boolean remove(Object o) { if (o == null) { for (int index = 0; index < size; index++) if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; }</code></pre><p>通过这个remove方法，可以看到，这个果然是通过使用remove方法来查看其两个对象是否相等。用于查询的indexOF方法的源代码也是用equals：</p><pre><code>public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) return i; } return -1;}</code></pre><p>但是，在实际使用中我发现一个问题。如下：</p><hr><p>首先，先创建一个新的类，命名为Person，该类一共就三个属性。一个是int类型的号码，一个是String类型的名字，一个int类型的名字。</p><pre><code>class Person{ int id; String name; int age; public Person(int id,String name, int age) { this.id = id; this.name = name; this.age = age; }}</code></pre><p>接下来，我给这个类的每一个属性附上具体的值</p><pre><code>CCollection<Person> c = new ArrayList<Person>();c.add(new Person(101,"李四", 8));c.add(new Person(100,"张三", 20));System.out.println(c.size());</code></pre><p>可以看见控制台输出“2”.所以说明这两个对象都加入到了集合中。我尝试删除了一个，和第一个人属性完全一样的对象。</p><pre><code>Collection<Person> c = new ArrayList<Person>();Iterator it = c.iterator();c.add(new Person(101,"李四", 8));c.add(new Person(100,"张三", 20));Person p = new Person(101,"李四", 8);c.remove(p);System.out.println(c.size());</code></pre><p>结果输出还是“2”，说明没有删除，其实也是意料之中，因为在collection看来，这是两个完全不同的属性，在堆中的地址也完全不一样。所以判断时就不会判断为相同的情况。</p><p>但是，如果我想要他产出我所指定是属性呢，总不能每建立一个属性就找个变量来保存地址吧，那这样集合也失去了他本身的意义了。所以想到一个方式，重写equals方法。因为equals方法是继承自Object的方法，所以在平时使用的时候未必能满足所有自定义类的要求。于是我重写了equals方法之后再次试验。</p><hr><pre><code>class Person{ int id; String name; int age; public Person(int id,String name, int age) { this.id = id; this.name = name; this.age = age; } /* * 两个人身份证和名字相同，就视为同一个人，重写equals方法 * * */ public boolean equals(Object obj) { Person p = (Person)obj; System.out.println(name+"和"+p.name+":在比较"); return (this.id == p.id&&this.name.equals(p.name)); }}</code></pre><p>通过重写后的类，在次执行上面的测试代码，就可以达到想要的值了。所以，以后我们在使用collection保存想要的应用时也要记得在自定义编写类里面重写equals方法来方便我们的基本操作。</p><hr><p>以上就是我对于collection接口中删除和修改方法具体的实现的一些个人总结</p>]]></content>
<summary type="html">
<p>Java中的集合是我们经常使用的Java工具类，Collection接口还有俩个子类。一个是List，一个是Set</p>
<p>1.List特点：有序的，元素可重复<br>2.Set特点：无序的，元素不可重复</p>
<p>在Java的API中，Collection接口一共要求实现以下方法。</p>
<pre><code> boolean add(E e)
将指定的元素添加到此列表的尾部。
void add(int index, E element)
将指定的元素插入此列表中的指定位置。
boolean addAll(Collection&lt;? extends E&gt; c)
按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。
boolean addAll(int index, Collection&lt;? extends E&gt; c)
从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。
void clear()
移除此列表中的所有元素。
Object clone()
返回此 ArrayList 实例的浅表副本。
boolean contains(Object o)
如果此列表中包含指定的元素，则返回 true。
void ensureCapacity(int minCapacity)
如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。
E get(int index)
返回此列表中指定位置上的元素。
int indexOf(Object o)
返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。
boolean isEmpty()
如果此列表中没有元素，则返回 true
int lastIndexOf(Object o)
返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
E remove(int index)
移除此列表中指定位置上的元素。
boolean remove(Object o)
移除此列表中首次出现的指定元素（如果存在）。
protected void removeRange(int fromIndex, int toIndex)
移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
E set(int index, E element)
用指定的元素替代此列表中指定位置上的元素。
int size()
返回此列表中的元素数。
Object[] toArray()
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。
&lt;T&gt; T[]
toArray(T[] a)
按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。
void trimToSize()
将此 ArrayList 实例的容量调整为列表的当前大小。
</code></pre>
</summary>
<category term="Java" scheme="http://yoursite.com/tags/Java/"/>
<category term="Java源码" scheme="http://yoursite.com/tags/Java%E6%BA%90%E7%A0%81/"/>
<category term="集合" scheme="http://yoursite.com/tags/%E9%9B%86%E5%90%88/"/>
</entry>
<entry>
<title>浅谈JVM内存结构一</title>
<link href="http://yoursite.com/2018/07/18/%E6%B5%85%E8%B0%88JVM%E5%86%85%E5%AD%98%E7%BB%93%E6%9E%84%E4%B8%80/"/>
<id>http://yoursite.com/2018/07/18/浅谈JVM内存结构一/</id>
<published>2018-07-17T20:06:28.000Z</published>
<updated>2018-07-18T16:34:42.764Z</updated>
<content type="html"><![CDATA[<p>众所周知，Java是一款可以跨平台的编程语言，无论是在Windows，MacOS上，还是安卓手机，苹果手机，哪怕是最老版的塞班手机上都可以运行。拥有这么好的跨平台性，主要还是靠的一手好虚拟机。</p><hr><p>JVM（Java Virtual Machine），全称Java虚拟机。是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。—————-上面是百度的解释，hhhhh。</p><p>下面是JVM的基本机构：</p><p><img src="/assets/img/img6-1.jpg" alt="image"></p><p>java在运行程序时，需要在内存中开辟一部分空间，而这部分空间就是来运行JVM，JVM拿到空间之后就对内存空间进行了功能的划分，以保证java虚拟机有足够的运行效率。</p><hr><p>具体划分为下面五个内存空间：</p><ul><li>栈：存放局部变量</li><li>堆：存放所有new出来的东西</li><li>方法区：被虚拟机加载的类信息、常量、静态常量等。</li><li>程序计数器(和系统相关)</li><li>本地方法栈</li></ul><a id="more"></a><p>程序计数器：</p><p> 程序计数器（Program Counter Register）是JVM中一块较小的内存区域，保存着当前线程执行的虚拟机字节码指令的内存地址。Java多线程的实现，其实是通过线程间的轮流切换并分配处理器执行时间的方式来实现的，在任何时刻，处理器都只会执行一个线程中的指令。在多线程场景下，为了保证线程切换回来后，还能恢复到原先状态，找到原先执行的指令，所以每个线程都会设立一个程序计数器，并且各个线程之间不会互相影响，程序计数器为”线程私有”的内存区域。</p><p> 如果当前线程正在执行Java方法，则程序计数器保存的是虚拟机字节码的内存地址，如果正在执行的是Native方法（非Java方法，JVM底层有许多非Java编写的函数实现），计数器则为空。程序计数器是唯一一个在Java规范中没有规定任何OutOfMemory场景的区域。</p><p>虚拟机栈：</p><p> 虚拟机栈（Java Virtual Machine Stacks）和线程是紧密联系的，每创建一个线程时就会对应创建一个Java栈，所以Java栈也是”线程私有”的内存区域，这个栈中又会对应包含多个栈帧，每调用一个方法时就会往栈中创建并压入一个栈帧，栈帧是用来存储方法数据和部分过程结果的数据结构，每一个方法从调用到最终返回结果的过程，就对应一个栈帧从入栈到出栈的过程。</p><p> 虚拟机栈是一个后入先出的数据结构，线程运行过程中，只有一个栈帧是处于活跃状态的，被称为”当前活动帧栈”，当前活动帧栈始终是虚拟机栈的栈顶元素。</p><p>本地方法栈：</p><p> 本地方法栈（Native Method Stack）和虚拟机栈的作用相似，不过虚拟机栈是为Java方法服务的，而本地方法栈是为Native方法服务的。</p><p>方法区：</p><p> 方法区（Method Area）是用于存储类结构信息的地方，包括常量池、静态变量、构造函数等类型信息，类型信息是由类加载器在类加载时从类文件中提取出来的。</p><p> 方法区同样存在垃圾收集，因为用户通过自定义加载器加载的一些类同样会成为垃圾，JVM会回收一个未被引用类所占的空间，以使方法区的空间达到最小。</p><p> 方法区中还存在着常量池，常量池包含着一些常量和符号引用（加载类的连接阶段中的解析过程会将符号引用转换为直接引用）。</p><p> 方法区是线程共享的。</p><p>堆：</p><p> 堆（heap）是存储java实例或者对象的地方，是GC的主要区域，同样是线程共享的内存区域。</p><hr><p>总的来说啊，对于JVM的内存结构，主要简单理解以下几点：</p><p>1、所有线程共享的内存数据区：方法区，堆。而虚拟机栈，本地方法栈和程序计数器都是线程私有的。</p><p>2、存放于栈中的东西如下：</p><p> 2.1 每个线程包含一个栈区,栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)。对象都存放在堆区中。</p><p> 2.2 每个栈中的数据(基础数据类型和对象引用)都是私有的，其他栈不能访问。</p><p> 2.3 方法的形式参数，方法调用完后从栈空间回收</p><p> 2.4 引用对象的地址，引用完后，栈空间地址立即被回收，堆空间等待GC</p><p>3、存放于堆中的东西如下：</p><p> 3.1 存储的全部是对象，每个对象包含一个与之对应的class信息 </p><p> 3.2 Jvm只有一个堆区（heap）被所有线程共享，堆区中不存放基本类型和对象引用，只存放对象本身</p><p>4、存放于方法区中的东西如下：</p><p> 4.1 存放线程所执行的字节码指令</p><p> 4.2 跟堆一样.被所有线程共享.方法区包含：所有的class和static变量</p><p> 4.3 常量池位于方法区中，见如下图示说明</p><p><img src="/assets/img/img6-2.png" alt="image"></p><hr>]]></content>
<summary type="html">
<p>众所周知，Java是一款可以跨平台的编程语言，无论是在Windows，MacOS上，还是安卓手机，苹果手机，哪怕是最老版的塞班手机上都可以运行。拥有这么好的跨平台性，主要还是靠的一手好虚拟机。</p>
<hr>
<p>JVM（Java Virtual Machine），全称Java虚拟机。是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。—————-上面是百度的解释，hhhhh。</p>
<p>下面是JVM的基本机构：</p>
<p><img src="/assets/img/img6-1.jpg" alt="image"></p>
<p>java在运行程序时，需要在内存中开辟一部分空间，而这部分空间就是来运行JVM，JVM拿到空间之后就对内存空间进行了功能的划分，以保证java虚拟机有足够的运行效率。</p>
<hr>
<p>具体划分为下面五个内存空间：</p>
<ul>
<li>栈：存放局部变量</li>
<li>堆：存放所有new出来的东西</li>
<li>方法区：被虚拟机加载的类信息、常量、静态常量等。</li>
<li>程序计数器(和系统相关)</li>
<li>本地方法栈</li>
</ul>
</summary>
<category term="Java" scheme="http://yoursite.com/tags/Java/"/>
<category term="基础知识" scheme="http://yoursite.com/tags/%E5%9F%BA%E7%A1%80%E7%9F%A5%E8%AF%86/"/>
<category term="虚拟机" scheme="http://yoursite.com/tags/%E8%99%9A%E6%8B%9F%E6%9C%BA/"/>
</entry>
<entry>
<title>Java的static的概念与使用</title>
<link href="http://yoursite.com/2018/07/08/Java%E7%9A%84static%E7%9A%84%E6%A6%82%E5%BF%B5%E4%B8%8E%E4%BD%BF%E7%94%A8/"/>
<id>http://yoursite.com/2018/07/08/Java的static的概念与使用/</id>
<published>2018-07-07T20:29:48.000Z</published>
<updated>2018-07-18T16:33:45.539Z</updated>
<content type="html"><![CDATA[<p>static——静态修饰符，一般用于OOP编程时对类里的变量和方法修饰。而修饰后的所有变量和方法属于该类，所以修饰后的变量又叫做类变量。<br>static修饰后的类变量和方法，在运行时主要是保存在虚拟机内存的方法区（method）中。所以，在加载类时，方法和变量一同被加载。（关于这部分，细看“浅谈JVM内存结构”）所以，不需要创建对象就可以直接对类中static所修饰的方法进行直接调用。例如下代码：</p><pre><code>public class Car { //常量必需要初始值【组件属性】 public static final String COLOR="RED"; //用static修饰的[所有]对象共享 static String brand="BMW"; //非静态的变量 String type="4S"; public static String getBrand(){ //静态的方法可以访问静态的变量 //静态的方法不可以直接访问非静态的变量【非静态的变量需要创建对象后才能使用】 return brand; //Car car=new Car(); //return car.type; } public String getType(){ return type; }}public class Test { public static void main(String[] args) { Car car=new Car(); //System.out.println(car.COLOR); System.out.println(car.brand); //用静态修饰的变量可以通过类直接访问 System.out.println(Car.brand); //非静态的变量需要创建对象后再使用 System.out.println(car.type); //静态方法可以直接使用 Car.getBrand(); //非静态的方法必须要创建实例后才能使用 car.getType(); }}</code></pre><a id="more"></a><p>在Test类中的main方法里可以直接调用Car类中的static变量和方法，不需要创建新的对象。对于没有用static修饰的变量和方法来说就必须要创建的新的对象之后才能被调用。</p><hr><p>含有static修饰的变量和方法的类的所创建的新的对象本身没有实际的static对象，只有一个地址用于引导到类中变量所保存到地址，所以说，但通过对象修改static的变量时，所有的该类所创建的对象的对应变量值都会被修改，如下代码（还是用上述的Car类）：</p><pre><code>public class Test { public static void main(String[] args) { //创建两个不同的对象 Car car=new Car(); Car car2=new Car(); //输出两个对象的brand变量 System.out.println(car.brand); System.out.println(car2.brand); //修改其中一个变量的值 car.brand = "奔驰"; //再次输出输出两个对象的brand变量 System.out.println(car.brand); System.out.println(car2.brand); }}</code></pre><p>结果如下图：</p><hr><p><img src="/assets/img/img5-1.png" alt="image"></p><hr><p>综上所述，我们可以理解static在实际使用时，基本上是配黑常量修饰词（final）和成员变量修饰词（public）一起使用，从而定义一些不需要修改而且随时可以取值调用的变量和方法。例如Math类中的PI和E：</p><hr><p><img src="/assets/img/img5-2.png" alt="image"></p><hr><p>以上就是我的对于static修饰符的使用和概念的理解。</p>]]></content>
<summary type="html">
<p>static——静态修饰符，一般用于OOP编程时对类里的变量和方法修饰。而修饰后的所有变量和方法属于该类，所以修饰后的变量又叫做类变量。<br>static修饰后的类变量和方法，在运行时主要是保存在虚拟机内存的方法区（method）中。所以，在加载类时，方法和变量一同被加载。（关于这部分，细看“浅谈JVM内存结构”）所以，不需要创建对象就可以直接对类中static所修饰的方法进行直接调用。例如下代码：</p>
<pre><code>public class Car {
//常量必需要初始值【组件属性】
public static final String COLOR=&quot;RED&quot;;
//用static修饰的[所有]对象共享
static String brand=&quot;BMW&quot;;
//非静态的变量
String type=&quot;4S&quot;;
public static String getBrand(){
//静态的方法可以访问静态的变量
//静态的方法不可以直接访问非静态的变量【非静态的变量需要创建对象后才能使用】
return brand;
//Car car=new Car();
//return car.type;
}
public String getType(){
return type;
}
}
public class Test {
public static void main(String[] args) {
Car car=new Car();
//System.out.println(car.COLOR);
System.out.println(car.brand);
//用静态修饰的变量可以通过类直接访问
System.out.println(Car.brand);
//非静态的变量需要创建对象后再使用
System.out.println(car.type);
//静态方法可以直接使用
Car.getBrand();
//非静态的方法必须要创建实例后才能使用
car.getType();
}
}
</code></pre>
</summary>
<category term="Java" scheme="http://yoursite.com/tags/Java/"/>
<category term="基本知识" scheme="http://yoursite.com/tags/%E5%9F%BA%E6%9C%AC%E7%9F%A5%E8%AF%86/"/>
<category term="面向对象" scheme="http://yoursite.com/tags/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/"/>
</entry>
<entry>
<title>世界杯——别了梅罗。</title>
<link href="http://yoursite.com/2018/07/02/%E4%B8%96%E7%95%8C%E6%9D%AF%E6%A2%85%E7%BD%97%E5%87%BA%E5%B1%80/"/>
<id>http://yoursite.com/2018/07/02/世界杯梅罗出局/</id>
<published>2018-07-02T15:11:14.000Z</published>
<updated>2018-07-18T16:34:53.726Z</updated>
<content type="html"><![CDATA[<p><img src="/assets/img/img4-1.jpg" alt="image"></p><hr><p>2018年世界杯小组赛已经结束了，作为一个完完全全的业余球迷，也就每四年看看世界杯了。但是确实很喜欢C罗和梅西。2006年他们第一次参加世界杯时，我还是个小学生（尴尬）。但是从2010年世界杯开始就慢慢的开始关注他们，虽然可能在欧冠，他们的能力有更加好的发挥空间。但是不知道为什么，还是很喜欢看世界杯上的比赛。</p><a id="more"></a><p>梅西给我印象最深的还是2014年的世界杯，那时候的梅西在欧冠期间发挥也十分一般，十分的压抑。但是在世界杯第一场小组赛上一球完美的死角射球让他找回了自己，接下来的比赛让我看到了一个正真的梅西，一个正真的阿根廷的皇牌球员。</p><p>而C罗在往届世界杯上，都只有一个进球。但是在这届世界杯上，尤其是与西班牙的第一场比赛，真是让人感觉到C罗的个人能力，凭借着自己的能力一度让葡萄牙冲出了小组赛。实在是强大。在最后一场对阵乌拉圭的比赛中，C罗也是尽力争取这每一球，最后激动地吃了黄牌，看见C罗对这场比赛胜利的渴望，十分心疼了。</p><p>这届世界杯听说阿根廷内部有很大的矛盾，导致球队内部混乱。其实我作为完完全全的伪球迷并不在乎，也不关注这些。喜欢看到的仅仅是球员为了国家的荣誉拼尽了自己的全力。这份血性是真的看得十分的让人热血沸腾。</p><p>比赛结束后，看到梅西和C罗抬头仰望天空的时候，真是十分心疼了。最后，我想说中国队如果真的有希望能进世界杯的话，真的不一定要取得很好的名次才能证明自己，只要能提出血性，国人一定也会为之自豪的。</p><hr><p>以上皆是一个十分业余球迷的看世界杯的感受，请真球迷别看也别喷。</p>]]></content>
<summary type="html">
<p><img src="/assets/img/img4-1.jpg" alt="image"></p>
<hr>
<p>2018年世界杯小组赛已经结束了，作为一个完完全全的业余球迷，也就每四年看看世界杯了。但是确实很喜欢C罗和梅西。2006年他们第一次参加世界杯时，我还是个小学生（尴尬）。但是从2010年世界杯开始就慢慢的开始关注他们，虽然可能在欧冠，他们的能力有更加好的发挥空间。但是不知道为什么，还是很喜欢看世界杯上的比赛。</p>
</summary>
<category term="个人兴趣" scheme="http://yoursite.com/tags/%E4%B8%AA%E4%BA%BA%E5%85%B4%E8%B6%A3/"/>
</entry>
<entry>
<title>关于Java方法重载原理</title>
<link href="http://yoursite.com/2018/06/30/%E5%85%B3%E4%BA%8EJava%E6%96%B9%E6%B3%95%E9%87%8D%E8%BD%BD%E5%8E%9F%E7%90%86/"/>
<id>http://yoursite.com/2018/06/30/关于Java方法重载原理/</id>
<published>2018-06-29T20:43:04.000Z</published>
<updated>2018-07-18T16:34:20.727Z</updated>
<content type="html"><![CDATA[<p>在Java面向对象编程中，有关于方法的最经典的设计就是方法重载，方法重载在很大程度上减少了代码命名时的麻烦。减少了代码名字的重复出现，又方便了通过不同的参数来调用不同的函数。给面相对象的多态性提供了良好的基础。</p><p>那么，java中的方法是如何实现所谓的重载的呢，计算机又是如何判断调用哪个函数的呢。</p><hr><p>首先我们先要了解一个概念，就是<strong>方法签名</strong>，方法签名是唯一识别方法的方式。只有方法签名系统才能区分重载方法之间的去别。那么方法签名是由什么构成的呢。方法签名包括：返回参数类型，方法名以及形参的个数或类型。但是决定方法名不同的是方法名以及方法的形参或者类型的不同。</p><p>多说无益,写一段代码大家就清楚了</p><pre><code>public class TestMethod5 { public static void test1(int a,int b){ } public static void test1(int a){ } public static int test1(int c,double a){ return 1; } public static void main(String[] args) { //应用 jvm自动根据 变量的类型来匹配寻找合适的方法 System.out.println(max(1,2L)); } public static int max(int a,int b){ System.out.println("int max"); return a>b?a:b; } public static long max(long a,long b){ System.out.println("long max"); return a>b?a:b; }}</code></pre><a id="more"></a><p>上面就是一个十分简易的方法重载的例子，接下来让我们找到这个类所生成的class文件的样子。</p><p><img src="/assets/img/img7-1.png" alt="image"></p><p><img src="/assets/img/img7-1.png" alt="image"></p><p>从上述图片可以看出，每一个重载方法在class文件中名字都产生了变化。使得方法之前有了区别。这样调用时就能更加的明确</p><hr><p>以上就是我对于方法重载的原理的理解</p><hr>]]></content>
<summary type="html">
<p>在Java面向对象编程中，有关于方法的最经典的设计就是方法重载，方法重载在很大程度上减少了代码命名时的麻烦。减少了代码名字的重复出现，又方便了通过不同的参数来调用不同的函数。给面相对象的多态性提供了良好的基础。</p>
<p>那么，java中的方法是如何实现所谓的重载的呢，计算机又是如何判断调用哪个函数的呢。</p>
<hr>
<p>首先我们先要了解一个概念，就是<strong>方法签名</strong>，方法签名是唯一识别方法的方式。只有方法签名系统才能区分重载方法之间的去别。那么方法签名是由什么构成的呢。方法签名包括：返回参数类型，方法名以及形参的个数或类型。但是决定方法名不同的是方法名以及方法的形参或者类型的不同。</p>
<p>多说无益,写一段代码大家就清楚了</p>
<pre><code>public class TestMethod5 {
public static void test1(int a,int b){
}
public static void test1(int a){
}
public static int test1(int c,double a){
return 1;
}
public static void main(String[] args) {
//应用 jvm自动根据 变量的类型来匹配寻找合适的方法
System.out.println(max(1,2L));
}
public static int max(int a,int b){
System.out.println(&quot;int max&quot;);
return a&gt;b?a:b;
}
public static long max(long a,long b){
System.out.println(&quot;long max&quot;);
return a&gt;b?a:b;
}
}
</code></pre>
</summary>
<category term="Java" scheme="http://yoursite.com/tags/Java/"/>
<category term="基本知识" scheme="http://yoursite.com/tags/%E5%9F%BA%E6%9C%AC%E7%9F%A5%E8%AF%86/"/>
<category term="面向对象" scheme="http://yoursite.com/tags/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/"/>
</entry>
<entry>
<title>Java debug的使用（中文版eclipse）</title>
<link href="http://yoursite.com/2018/06/29/Java-debug%E7%9A%84%E4%BD%BF%E7%94%A8%EF%BC%88%E4%B8%AD%E6%96%87%E7%89%88eclipse%EF%BC%89/"/>
<id>http://yoursite.com/2018/06/29/Java-debug的使用（中文版eclipse）/</id>
<published>2018-06-28T19:21:19.000Z</published>
<updated>2018-06-28T19:46:02.694Z</updated>
<content type="html"><![CDATA[<p>在编写语言的过程中，我们往往会产生很多的错误。在现在的高级语言中和良好的编译器，许多的语法语义的错误都能被计算机快速查出来并提示位置。于是乎我们不必要花时间去查找程序的一些基本的错误。但是，涉及到逻辑错误时，计算机往往无法纠正，所以我们需要人工去寻找我们的错误，于是就有了debug的存在。今天我先总结一下自己在使用Java的中文版eclipse时，进行debug的步骤。</p><hr><h2 id="步骤"><a href="#步骤" class="headerlink" title="步骤"></a>步骤</h2><p>先设置断点<br><img src="/assets/img/img3-1.png" alt="image"></p><p>点击调试运行<br><img src="/assets/img/img3-2.png" alt="image"></p><p>弹出窗口，点击确定<br><img src="/assets/img/img3-3.png" alt="image"></p><p>Debug界面介绍<br><img src="/assets/img/img3-4.png" alt="image"></p><p>Debug与开发界面切换<br><img src="/assets/img/img3-5.png" alt="image"></p><hr><h2 id="Debug快捷键"><a href="#Debug快捷键" class="headerlink" title="Debug快捷键"></a>Debug快捷键</h2><p>F5:进入方法调试，代码界面跳转到方法中去<br>F6:逐行运行，一行行的运行代码<br>F7:跳出方法<br>F8:继续执行，直至结束当前程序或者找到下一断点</p><hr><p>以上就是我对与Debug步骤的总结</p>]]></content>
<summary type="html">
<p>在编写语言的过程中，我们往往会产生很多的错误。在现在的高级语言中和良好的编译器，许多的语法语义的错误都能被计算机快速查出来并提示位置。于是乎我们不必要花时间去查找程序的一些基本的错误。但是，涉及到逻辑错误时，计算机往往无法纠正，所以我们需要人工去寻找我们的错误，于是就有了d
</summary>
<category term="Java" scheme="http://yoursite.com/tags/Java/"/>
<category term="基本知识" scheme="http://yoursite.com/tags/%E5%9F%BA%E6%9C%AC%E7%9F%A5%E8%AF%86/"/>
<category term="eclipse" scheme="http://yoursite.com/tags/eclipse/"/>
<category term="Debug" scheme="http://yoursite.com/tags/Debug/"/>
</entry>
<entry>
<title>JDK相关知识</title>
<link href="http://yoursite.com/2018/06/28/JDK%E7%9B%B8%E5%85%B3%E7%9F%A5%E8%AF%86/"/>
<id>http://yoursite.com/2018/06/28/JDK相关知识/</id>
<published>2018-06-27T18:12:35.000Z</published>
<updated>2018-07-17T23:33:15.368Z</updated>
<content type="html"><![CDATA[<h1 id="JDK"><a href="#JDK" class="headerlink" title="JDK"></a>JDK</h1><p>JDK全称为JavaDevelopmenttoolKit(Java开发工具包),相当于Java的函数库,其作用主要是为当前平台提供一个编译和运行环境，是Java程序作为跨平台语言的一个关键点。</p><h2 id="JDK目录介绍"><a href="#JDK目录介绍" class="headerlink" title="JDK目录介绍"></a>JDK目录介绍</h2><h3 id="Bin"><a href="#Bin" class="headerlink" title="- Bin:"></a>- Bin:</h3><p>-工具 window系统是exe文件<br>-Javac 编译工具<br>-Java 启动jvm运行class文件</p><h3 id="DB"><a href="#DB" class="headerlink" title="- DB:"></a>- DB:</h3><ul><li>数据管理开发包<h3 id="Include"><a href="#Include" class="headerlink" title="- Include:"></a>- Include:</h3></li><li>*.h文件 java运行的底层是用c实现的,无论是什么系统还是不同的设备，都是由C语言书写的底层。<h3 id="Jre"><a href="#Jre" class="headerlink" title="- Jre:"></a>- Jre:</h3></li><li>java runtime environment java运行环境 调试时需要运行环境 <h3 id="Lib"><a href="#Lib" class="headerlink" title="- Lib:"></a>- Lib:</h3></li><li>运行需要的库 以及调试jvm的工具。 <h3 id="src-zip"><a href="#src-zip" class="headerlink" title="- src.zip:"></a>- src.zip:</h3></li><li>java的源代码,Java开发中调用的所有方法的源代码保存的地方。</li></ul><h2 id="JRE"><a href="#JRE" class="headerlink" title="JRE"></a>JRE</h2><p>全称为Java Runtime Environment(Java运行环境)，在Java项目中，与JDK文件在同一目录下的单独的jre目录用于部署项目时使用</p><h2 id="JVM"><a href="#JVM" class="headerlink" title="JVM"></a>JVM</h2><p>全称Java Virtual Machine(Java虚拟机)，当Java程序需要运行时，Java在内存中开辟一个新的区域用于运行Java虚拟机。所以JVM是一个动态概念 由jre创建并存在于内存当中 jdk jre属于静态的概念【硬盘中的一个文件】</p><hr><h2 id="以上就是JDK的一些基本的目录结构和基本作用"><a href="#以上就是JDK的一些基本的目录结构和基本作用" class="headerlink" title="以上就是JDK的一些基本的目录结构和基本作用"></a>以上就是JDK的一些基本的目录结构和基本作用</h2>]]></content>
<summary type="html">
<h1 id="JDK"><a href="#JDK" class="headerlink" title="JDK"></a>JDK</h1><p>JDK全称为JavaDevelopmenttoolKit(Java开发工具包),相当于Java的函数库,其作用主要是为当前平台提供一
</summary>
<category term="Java" scheme="http://yoursite.com/tags/Java/"/>
<category term="基本知识" scheme="http://yoursite.com/tags/%E5%9F%BA%E6%9C%AC%E7%9F%A5%E8%AF%86/"/>
</entry>
<entry>
<title>Python批量修改文件名脚本</title>
<link href="http://yoursite.com/2018/06/02/Python%E6%89%B9%E9%87%8F%E4%BF%AE%E6%94%B9%E6%96%87%E4%BB%B6%E5%90%8D%E8%84%9A%E6%9C%AC/"/>
<id>http://yoursite.com/2018/06/02/Python批量修改文件名脚本/</id>
<published>2018-06-01T20:29:48.000Z</published>
<updated>2018-07-17T23:19:24.480Z</updated>
<content type="html"><![CDATA[<p>第一次的博客，这两天再用专门的音乐播放器听歌，但是这个英语播放器不能下载歌曲，只能通过其他软件来获取无损音乐，然后在放置在这个音乐播放器上听取，但是由于播放器的文件读取格式和下载音乐的播放器的下载的歌曲格式不一样。所以在获取歌词和海报时会有很多不便，现在就是需要把本地音乐的格式更改一下，把歌手名字放在音乐名字后面。就像下面我给的具体测试一样。但是又不想用手一个个该，不然可太蠢了啊。所以决定用python写个小脚本，来处理这些文件。本人此时还是个大学生，也是第一次写博客，往大家多多照顾。下面贴图和代码</p><hr><pre><code>import os;count=0;def rename(): path='music/'; filelist = os.listdir(path) for files in filelist: Olddir = os.path.join(path,files); if os.path.isdir(Olddir): continue; filename = os.path.splitext(files)[0]; filetype = os.path.splitext(files)[1]; print filename; if filename.find('-')>=0: Newdir=os.path.join(path,filename.split('-')[1]+'-'+filename.split('-')[0]+filetype); if not os.path.isfile(Newdir): os.rename(Olddir,Newdir);rename();</code></pre><hr><p><img src="/assets/img/img1-1.jpg" alt="image"><br><img src="/assets/img/img1-2.jpg" alt="image"></p><hr>]]></content>
<summary type="html">
<p>第一次的博客，这两天再用专门的音乐播放器听歌，但是这个英语播放器不能下载歌曲，只能通过其他软件来获取无损音乐，然后在放置在这个音乐播放器上听取，但是由于播放器的文件读取格式和下载音乐的播放器的下载的歌曲格式不一样。所以在获取歌词和海报时会有很多不便，现在就是需要把本地音乐的
</summary>
<category term="Python" scheme="http://yoursite.com/tags/Python/"/>
<category term="程序猿" scheme="http://yoursite.com/tags/%E7%A8%8B%E5%BA%8F%E7%8C%BF/"/>
<category term="脚本" scheme="http://yoursite.com/tags/%E8%84%9A%E6%9C%AC/"/>
<category term="程序与生活" scheme="http://yoursite.com/tags/%E7%A8%8B%E5%BA%8F%E4%B8%8E%E7%94%9F%E6%B4%BB/"/>
</entry>
<entry>
<title>Hello World</title>
<link href="http://yoursite.com/2018/06/01/hello-world/"/>
<id>http://yoursite.com/2018/06/01/hello-world/</id>
<published>2018-05-31T20:29:48.000Z</published>
<updated>2018-08-04T06:20:11.730Z</updated>
<content type="html"><![CDATA[<p>Welcome to <a href="https://hexo.io/" target="_blank" rel="noopener">Hexo</a>! This is your very first post. Check <a href="https://hexo.io/docs/" target="_blank" rel="noopener">documentation</a> for more info. If you get any problems when using Hexo, you can find the answer in <a href="https://hexo.io/docs/troubleshooting.html" target="_blank" rel="noopener">troubleshooting</a> or you can ask me on <a href="https://github.com/hexojs/hexo/issues" target="_blank" rel="noopener">GitHub</a>.</p><h2 id="Quick-Start"><a href="#Quick-Start" class="headerlink" title="Quick Start"></a>Quick Start</h2><h3 id="Create-a-new-post"><a href="#Create-a-new-post" class="headerlink" title="Create a new post"></a>Create a new post</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo new <span class="string">"My New Post"</span></span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/writing.html" target="_blank" rel="noopener">Writing</a></p><h3 id="Run-server"><a href="#Run-server" class="headerlink" title="Run server"></a>Run server</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo server</span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/server.html" target="_blank" rel="noopener">Server</a></p><h3 id="Generate-static-files"><a href="#Generate-static-files" class="headerlink" title="Generate static files"></a>Generate static files</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo generate</span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/generating.html" target="_blank" rel="noopener">Generating</a></p><h3 id="Deploy-to-remote-sites"><a href="#Deploy-to-remote-sites" class="headerlink" title="Deploy to remote sites"></a>Deploy to remote sites</h3><figure class="highlight bash"><table><tr><td class="gutter"><pre><span class="line">1</span><br></pre></td><td class="code"><pre><span class="line">$ hexo deploy</span><br></pre></td></tr></table></figure><p>More info: <a href="https://hexo.io/docs/deployment.html" target="_blank" rel="noopener">Deployment</a></p>]]></content>
<summary type="html">
<p>Welcome to <a href="https://hexo.io/" target="_blank" rel="noopener">Hexo</a>! This is your very first post. Check <a href="https://hexo.
</summary>
</entry>
</feed>