<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[change__12的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/change__12</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; change__12]]></copyright><item><title><![CDATA[2021.11.30，内容:题目]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121644832</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121644832</guid><author>change__12</author><pubDate>Tue, 30 Nov 2021 22:49:17 +0800</pubDate><description><![CDATA[public class Test {
public static void main(String [] args){
System.out.println(new B().getValue());
}
static class A{
protected int value;
public A(int v) {
setValue(v);
}
public void setValue(int value){
this.value = value;
}
public int getValue(){
try{
]]></description><category></category></item><item><title><![CDATA[2021.11.29，内容:字节码。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121621340</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121621340</guid><author>change__12</author><pubDate>Mon, 29 Nov 2021 22:24:54 +0800</pubDate><description><![CDATA[之所以被称之为字节码，是因为字节码文件由十六进制值组成，而 JVM 以两个十六进制值为一组，即以字节为单位进行读取。在 Java 中一般是用 javac 命令编译源代码为字节码文件，一个.java 文件从编译到运行的示例如下图所示。
图1 Java运行示意图
对于开发人员，了解字节码可以更准确、直观地理解 Java 语言中更深层次的东西，比如通过字节码，可以很直观地看到 Volatile 关键字如何在字节码上生效。另外，字节码增强技术在 Spring AOP、各种 ORM 框架、热部署中的应用屡见不鲜，深入]]></description><category></category></item><item><title><![CDATA[2021.11.28，内容:switch]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121599364</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121599364</guid><author>change__12</author><pubDate>Sun, 28 Nov 2021 22:27:09 +0800</pubDate><description><![CDATA[switch可以看作是一种选择语句。它的作用是根据表达式的值，从一系列代码中选择一段去执行。其格式如下：
switch(selector){
case value1:
statement; break;
case value2:
statement; break;
case value3:
statement; break;
default:
statement;
}
其中selector指的是一个参数，或是一个表达式，或是一个方法。

...]]></description><category></category></item><item><title><![CDATA[2021.11.28，内容:执行效率]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121585997</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121585997</guid><author>change__12</author><pubDate>Sun, 28 Nov 2021 00:08:48 +0800</pubDate><description><![CDATA[执行效率关乎程序好坏，执行效率好的程序运行效率快，那么String、StringBuffer、 StringBuilder那个最快呢。
在这三者中 String执行效率是最慢的，StringBuffer执行效率差别不大，但是StringBuilder最快但是StringBuilder是非线性安全。
比较： StringBuilder &gt; StringBuffer &gt; String
总结：
1.如果操作少量数据 —用String
2.单线程操作字符串缓存区下操作数据—用StringBuilder
]]></description><category></category></item><item><title><![CDATA[2021.11.26，内容:方法的重写]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121573275</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121573275</guid><author>change__12</author><pubDate>Sat, 27 Nov 2021 10:14:50 +0800</pubDate><description><![CDATA[子类从父类继承的某个实例方法无法满足子类的功能需要时，需要在子类中对该实例方法进行重新实现，这样的过程称为重写，也叫做覆写、覆盖。
方法重写的前提：继承，子类的修饰符大于等于父类，方法名、参数列表、返回值类型必须相同

...]]></description><category></category></item><item><title><![CDATA[2021.11.25，内容:lnstanceof。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121550355</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121550355</guid><author>change__12</author><pubDate>Thu, 25 Nov 2021 23:39:42 +0800</pubDate><description><![CDATA[Instanceof关键字的作用是返回一个布尔值，告诉我们一个对象是不是某个特定类的一个实例。例如:
if(x instanceof Dog){
}
即在判断x对象是不是Dog类的一个实例。
Instanceof关键字是RTTI，动态类型判断技术的其中一种表现形式。关于RTTI的更多内容，请参考这篇博客:[java] 反射和多态实现原理详解以及对比.

...]]></description><category></category></item><item><title><![CDATA[2021.11.25 内容:修饰变量。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121528112</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121528112</guid><author>change__12</author><pubDate>Thu, 25 Nov 2021 00:02:08 +0800</pubDate><description><![CDATA[final顾名思义是最终的意思，他修饰变量意味着这个变量的值不能再更改。一个即是static又是final的常量会占据一段不能改变的内存空间。对于这样的常量，我们的命名规范是约定俗成的大写字母加下划线，如下：
private static final int TEST_FINAL = 1;
在修饰引用变量的时候，这个值是指的其引用不变，但引用的对象的内容是可变的。而在修饰基本变量如int时，则意味着这个基本类型的值不能改变。值得注意的是,final在修饰String类的对象时，其值和修饰基本变量类型是一样不]]></description><category></category></item><item><title><![CDATA[2021.11.23，内容:题目。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121505659</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121505659</guid><author>change__12</author><pubDate>Tue, 23 Nov 2021 23:36:14 +0800</pubDate><description><![CDATA[/**

Created by zmt on 2016/12/22.
*/
public class Test {
public static void main(String [] args){
System.out.println(new B().getValue());
}
static class A{
protected int value;
public A(int v) {
setValue(v);
}
public void setValue(int value){
this.value =]]></description><category></category></item><item><title><![CDATA[2021.11.22，内容:泛型。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121482938</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121482938</guid><author>change__12</author><pubDate>Mon, 22 Nov 2021 22:54:08 +0800</pubDate><description><![CDATA[public class Table {
}
public class Room {
}
public class House {
}
public class Particle&lt;POSITION, MOMENTUM&gt; {
}
public class Main {
public static void main(String[] args) {
List tableList = new ArrayList();
Map&lt;Room, Table&gt; maps = new HashMap]]></description><category></category></item><item><title><![CDATA[2021.11.21，内容:创建线程的方式]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121462654</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121462654</guid><author>change__12</author><pubDate>Sun, 21 Nov 2021 23:20:52 +0800</pubDate><description><![CDATA[继承Thread类
实现Runnable接口
实现Callable接口（ JDK1.5&gt;= ）
线程池方式创建
采用继承Thread类的方式创建线程的优缺点
Thread代码解析：Thread 类本质上是实现了 Runnable 接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过 Thread 类的 start()实例方法。start()方法是一个 native 方法，它将启动一个新线
程，并执行 run()方法（单独执行run方法不会创建新线程，只会在当前线程执行run方法）。

...]]></description><category></category></item><item><title><![CDATA[2021.11.20，内容:结束程序。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121446403</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121446403</guid><author>change__12</author><pubDate>Sat, 20 Nov 2021 21:54:15 +0800</pubDate><description><![CDATA[1.&nbsp;main方法返回
2.&nbsp;异常交给虚拟机处理
异常包含了“异常名称，异常出错的数值，异常发生的代码位置”，程序的调用堆栈信息…如此多的信息，程序将这些信息封装成了一个“异常”对象，将该异常对象抛回给调用者。
手动抛出异常
格式：throw new 异常对象（…）；
运行时异常的处理方案：
1.&nbsp;不处理，异常最终会抛给虚拟机，程序提前终止
2.&nbsp;捕获处理 try-catch
合并唯一：如RuntimeException或者统一Exception
开发中常用后者。

]]></description><category></category></item><item><title><![CDATA[2021.11.19，内容:对数据进行变换。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121432926</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121432926</guid><author>change__12</author><pubDate>Fri, 19 Nov 2021 23:20:16 +0800</pubDate><description><![CDATA[int a  = 3,b = 5;–&gt;b = 3,a = 5;
        a = a + b; a = 8;

        b = a - b; b = 3;

        a = a - b; a = 5;

        a = a ^ b;//

        b = a ^ b;//b = a ^ b ^ b = a

        a = a ^ b;//a = a ^ b 


]]></description><category></category></item><item><title><![CDATA[2021.11.18，内容:水仙花。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121411843</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121411843</guid><author>change__12</author><pubDate>Thu, 18 Nov 2021 22:26:03 +0800</pubDate><description><![CDATA[package com.baidu.Demo;
public class ForDemo {
public static void main(String[] args) {
int x,y,z,num=0;
for(int i=1;i&lt;999;i++){
x=i/100;
y=i/10%10;
z=i%10;
if(i==(xxx)+(yyy)+(zzz)) {
System.out.println(+i);
}
}
}
}

]]></description><category></category></item><item><title><![CDATA[2021.11.17，内容:资源池。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121390606</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121390606</guid><author>change__12</author><pubDate>Wed, 17 Nov 2021 23:29:05 +0800</pubDate><description><![CDATA[资源池不仅仅是在java当中存在的概念，在软件世界里也是广泛应用的一个东西。
我们非常常见的资源池有：
数据库连接池
web容器中的线程池
web容器中的request,response对象池
使用资源池的原因和好处大致是相似的。无外乎创建关闭维护每一个资源是比较耗费成本的。因此我们可以维护一定数量的资源，来寻求一个效率上的平衡。
资源池引入的目的:提高性能
资源池运作机制：由资源池管理器提供一定数目的目标资源，当有请求该资源时，资源池分配给一个，然后给该资源标识为忙，&nbsp;&nbsp;&nbsp; ]]></description><category></category></item><item><title><![CDATA[2021.11.16，内容:多态的引入]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121367947</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121367947</guid><author>change__12</author><pubDate>Tue, 16 Nov 2021 23:19:28 +0800</pubDate><description><![CDATA[定义：父类的引用指向子类的对象；
多态的第一种使用场景：方法的参数设计上，如果设计一个方法，尽量将方法的参数设计为“父类类型”，因为父类类型的参数可以接收所有其“子类对象”。
多态的第二种使用场景：创建子类对象，使用父类引用接收，提升代码的维护性。
程序中为何使用向下转型：
为了使用子类的特有的“属性和行为”。Instanceof实例对象类型判断。

...]]></description><category></category></item><item><title><![CDATA[2021.11.15，内容:new关键字的作用。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121344922</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121344922</guid><author>change__12</author><pubDate>Mon, 15 Nov 2021 22:12:01 +0800</pubDate><description><![CDATA[a.&nbsp;在堆区开辟空间
b.&nbsp;给开辟空间的属性进行默认初始化
c.&nbsp;返回堆区开辟空间的首地址
对于重写Object中的方法
a.&nbsp;重写equals目的：自定义子类对象的判断规则。
b.&nbsp;重写toString目的：自定义对象的输出数据
补充：对象都应该根据判断数据内容来判断，为什么Object类不知道这么一个简单的原理呢？
Object类根本不知道子类的具体数据，无法做出数据的判断

...]]></description><category></category></item><item><title><![CDATA[2021.11.14，内容:多态的引入。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121324748</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121324748</guid><author>change__12</author><pubDate>Sun, 14 Nov 2021 22:09:45 +0800</pubDate><description><![CDATA[定义：父类的引用指向子类的对象；
多态的第一种使用场景：方法的参数设计上，如果设计一个方法，尽量将方法的参数设计为“父类类型”，因为父类类型的参数可以接收所有其“子类对象”。
多态的第二种使用场景：创建子类对象，使用父类引用接收，提升代码的维护性。
程序中为何使用向下转型：
为了使用子类的特有的“属性和行为”。Instanceof实例对象类型判断。

final关键字：final最终化，不可再次更改的含义。
final修饰方法的作用：允许子类使用，但是不允许子类重写
Final修饰类：被final修饰的类不]]></description><category></category></item><item><title><![CDATA[2021.11.13，内容:抽象类。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121312071</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121312071</guid><author>change__12</author><pubDate>Sat, 13 Nov 2021 23:20:32 +0800</pubDate><description><![CDATA[（1）.&nbsp;可以定义抽象方法
（2） 也可以定义非抽象方法（拥有方法体的方法）
（3）.&nbsp;当然也可以定义属性
（4） 抽象类也是类，所有也拥有构造方法
描述：
1）.&nbsp;没有方法体的方法必须定义为“抽象方法”。抽象方法使用abstract关键字修饰
2）.&nbsp;拥有抽象方法的类，必须被定义“抽象类”
3）.&nbsp;不能实例化抽象类的对象
4）.&nbsp;子类要new对象的话，那就必须实现父类的所有抽象方法
5）.&nbsp;抽象创建对象？抽象类中的抽象方法，缺少方法体，]]></description><category></category></item><item><title><![CDATA[2021.11.12，内容:内部类引入]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121297683</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121297683</guid><author>change__12</author><pubDate>Fri, 12 Nov 2021 22:49:52 +0800</pubDate><description><![CDATA[特点：
（1）.&nbsp;在成员内部类中可以访问外部类的所有成员（人与心脏）
（2）.&nbsp;成员内部类中的方法也可以调用外部类的方法
（3）.&nbsp;成员内部类中不可以声明静态变量，静态方法。因为成员变量是属于对象的，静态与对象无关。
（4）.&nbsp;外部类中可以用内部类声明成员属性，作为外部类的成员。也可以在方法中创建内部类对象，调用内部类的方法。
成员内部类，会随着对象的创建而加载。
静态内部类：会随着外部类的加载而加载

...]]></description><category></category></item><item><title><![CDATA[2021.11.11，内容:intero方法。]]></title><link>https://blog.youkuaiyun.com/change__12/article/details/121278209</link><guid>https://blog.youkuaiyun.com/change__12/article/details/121278209</guid><author>change__12</author><pubDate>Thu, 11 Nov 2021 22:41:56 +0800</pubDate><description><![CDATA[jdk6中：
将这个字符串常量池尝试放入字符串常量池。
如果常量池中有，则不会方法。返回已有的常量池中对象的地址；
如果没有，会把此对象复制一份，放入串池，并返回串池中的对象地址；
jdk7中：
将这个字符串常量池尝试放入字符串常量池。
如果常量池中有，并不会放入。返回已有的常量池中的对象的地址；
如果没有，会把对象的引用地址复制一份，放入常量池，并返回常量池中的引用地址；

...]]></description><category></category></item></channel></rss>