<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[James____Gosling的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/James____Gosling</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; James____Gosling]]></copyright><item><title><![CDATA[哈希表讲解]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/119320666</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/119320666</guid><author>James____Gosling</author><pubDate>Thu, 19 Aug 2021 15:06:27 +0800</pubDate><description><![CDATA[问题
有一个公司，当有新的员工来报道时，要求将该员工的信息加入（id,性别，年龄，住址……），当输入该员工id时，要求查找到该员工的所有信息。
要求：不使用数据库，尽量节省内存，速度越快越好==&gt;哈希表。
哈希表的基本介绍
哈希表是根据关键码值而直接进行访问的数据结构。

...]]></description><category></category></item><item><title><![CDATA[Collection总结]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/119056069</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/119056069</guid><author>James____Gosling</author><pubDate>Thu, 19 Aug 2021 15:06:10 +0800</pubDate><description><![CDATA[Collection :
List:有序且重复。
ArrayList:底层时数组，查询快，增删慢，线程不安全，所以效率高。
Vector:底层数据结构是数组，查询快，增删慢，线程安全，所以效率低。
LinkedList:底层是链表，增删快，查询慢，线程安全，所以效率高。
Set:无序且位置。
HashSet:底层是哈希表，他的底层依赖于hashCode和equals方法来实现元素唯一。
LinkedHashSet:底层是链表和哈希表，哈希表保证元素唯一，链表保证元素有序。
TreeSet：底层是红黑树，它的]]></description><category></category></item><item><title><![CDATA[树的常用术语]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/119326655</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/119326655</guid><author>James____Gosling</author><pubDate>Thu, 19 Aug 2021 15:05:47 +0800</pubDate><description><![CDATA[二叉树
1）树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
2）二叉树的子节点分为左节点和右节点。
3）如果该二叉树的所有叶子节点都在最后一层，而且节点总数=2^n-1，n为层数，则我们称为满二叉树。
4）如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边是连续的，倒数第二层的叶子节点在右边连续，我们称为完全二叉树。


...]]></description><category></category></item><item><title><![CDATA[二叉树的前序中序后序遍历]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/119326966</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/119326966</guid><author>James____Gosling</author><pubDate>Thu, 19 Aug 2021 15:05:32 +0800</pubDate><description><![CDATA[概念
前序遍历：先输出父节点，再遍历左子树和右子树
中序遍历：先遍历左子树，再输出父节点，再遍历右子树。
后序遍历：先遍历左子树，在遍历右子树，最后输出父节点。
小结：看输出父节点的顺序。
前序遍历
1、先输出当前节点（初始的时候是root节点）
2、然后如果左子节点不为空，则递归继续前序遍历。
3、如果右子节点不为空，则递归继续前序遍历。
中序遍历
1、如果当前节点的左子节点不为空，则递归中序遍历。
2、输出当前节点
3、如果当前节点的右子节点不为空，则递归进行中序遍历。
后序遍历
1、如果当前节点的左子]]></description><category></category></item><item><title><![CDATA[线索化二叉树]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/119342453</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/119342453</guid><author>James____Gosling</author><pubDate>Thu, 19 Aug 2021 15:05:15 +0800</pubDate><description><![CDATA[线索化二叉树基本介绍
1）n个节点的二叉链表中含有n+	1  公式2n-(n-1)=n+1个空指针域，利用二叉树链表中的空指针域，存放指向该节点某种遍历次序下的前驱和后续节点的指针。
2）这种加上了线索的二叉链表陈为线索链表，相应的二叉树称为线索二叉树，根据线索性质不同，线索二叉树分为前序线索二叉树、中序线索二叉树、后续线索二叉树。
3）一个节点的前一个节点，称为前驱节点
4）一个节点的后一个接待你，称为后续节点
案例

说明：当线索化二叉树后，Node节点的属性left和right，有如下情况：
1）le]]></description><category></category></item><item><title><![CDATA[JVM详解]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118093706</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118093706</guid><author>James____Gosling</author><pubDate>Thu, 19 Aug 2021 15:04:59 +0800</pubDate><description><![CDATA[JVM探究
1、请你谈谈你对JVM的理解？Java–&gt;class—&gt;jvm
1、JVM的位置
2、JVM的体系结构
3、类加载器
4、双亲委派机制
5、沙箱安全机制
6、Native
7、PC寄存器
8、方法区
9、栈
10、三种JVM
11、堆
12、新生区
13、永久区
14、堆内存调优
15、GC（垃圾回收器）
1、常用算法
16、JMM
17、总结
1、JVM位置
jvm就像一个软件
Java程序都是跑在JVM上面的，JVM是用C写的。JVM就是一个环境，

3、类加载器
作用：加载cl]]></description><category></category></item><item><title><![CDATA[泛型的使用]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/119039991</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/119039991</guid><author>James____Gosling</author><pubDate>Thu, 05 Aug 2021 14:29:39 +0800</pubDate><description><![CDATA[由于添加元素的集合的不确定，我可以添加任意类型的元素，那么在遍历的时候可能会出现问题。
我们之前学习过的数组，就可以声明一种类型，使得在添加数据时，数据类型不匹配的情况下，就会出现异常。
那么集合中有没有这样的方法呢?
有的，泛型。
泛型的概述
泛型是一种特殊的类型，可以理解为参数化类型，也就是可以把类型像参数一样传递。
泛型的格式：
&lt;泛型类型&gt;
泛型的用处
一般多用于集合。
泛型的好处
1、提高了程序的安全性，
2、将原本运行时期的错误在编译时期就暴露了出来。
3、省去了强制类型转换的麻烦。]]></description><category></category></item><item><title><![CDATA[集合之Collection！！！]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118990955</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118990955</guid><author>James____Gosling</author><pubDate>Thu, 05 Aug 2021 14:28:41 +0800</pubDate><description><![CDATA[集合的出现
我们面向对象语言都是以对象的形式出现的，所以为了对多个对象进行操作，Java就提供了集合类。
集合和数组的区别
长度不同
数组：长度固定
集合：长度不固定
内容不同
数组：存储的相同数据类型
集合：可以存储不同数据类型
类型不同
数组：可以存储基本数据类型和引用类型
集合：只能存储引用类型。
集合的特点
集合只用于存储对象，它的长度是可变的，并且可以存储不同类型的对象。
集合继承体系

...]]></description><category></category></item><item><title><![CDATA[内部类详解！！！]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118978006</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118978006</guid><author>James____Gosling</author><pubDate>Thu, 05 Aug 2021 14:28:23 +0800</pubDate><description><![CDATA[概述：
把类定义在其他类的内部，这个类就称为内部类。
面试题

package org.wdzl.unit04;

/**
 * 1、内部类与外部类不是继承关系
 * 2、通过外部类名限定this
 *     格式：外部类.this.num；
 */
public class Test {
    public static void main(String[] args) {
        Outer4.Inner4 oi = new Outer4().new Inner4();
        oi]]></description><category></category></item><item><title><![CDATA[返回值类型为引用类型详解]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118976614</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118976614</guid><author>James____Gosling</author><pubDate>Thu, 05 Aug 2021 14:28:08 +0800</pubDate><description><![CDATA[抽象类作为返回值
package org.wdzl.unit04;

/**
 * 返回值类型：
 *     类：返回该类的对象
 *     抽象类：返回该抽象类子类的对象
 *     接口：
 */
public class ArgsDemo2_2 {
    public static void main(String[] args) {
        PersonDemo2 personDemo2= new PersonDemo2();
        Person2 person = per]]></description><category></category></item><item><title><![CDATA[参数为引用数据类型详解]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118976191</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118976191</guid><author>James____Gosling</author><pubDate>Thu, 05 Aug 2021 14:27:43 +0800</pubDate><description><![CDATA[类作为参数时
类：在调用方法时，传入相应类的对象（匿名类）
package org.wdzl.unit04;

/**
 * 形式参数是引用数据类型问题
 *     1、类：在调用方法时，传入相应类的对象（匿名类）
 *     2、抽象类
 *     3、接口
 */
public class ArgsDemo {
    public static void main(String[] args) {
        StudentDemo studentDemo = new StudentDemo]]></description><category></category></item><item><title><![CDATA[Java基础知识点---抽象类讲解！！！]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118973831</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118973831</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:21:51 +0800</pubDate><description><![CDATA[抽象类
抽象类的概述
用来描述抽象概念的类，叫做抽象类，抽象类中的方法不一定要实现具体的功能。
特点
1、被abstract关键字修饰
2、抽象类中不一定有抽象方法，但是有抽象方法的类一定要被定义为抽象类。
3、抽象类有构造方法，但是不能被创建对象，构造方法是供子类去调用的。
4、抽象类可以被标准类继承，也可以被抽象类继承。但是标准类必须重写抽象类中的抽象方法，但抽象类就不需要了。
package org.wdzl.unit04;

/**
 * 抽象类：
 *   概述：用来描述抽象概念的类叫做抽象类，抽]]></description><category></category></item><item><title><![CDATA[static详解]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/117410727</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/117410727</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:21:01 +0800</pubDate><description><![CDATA[1、静态方法不可以调用非静态方法，只能调用静态的。
2、非静态方法可以调用非静态方法和静态方法。
静态导入包：


]]></description><category></category></item><item><title><![CDATA[炒鸡讲解笔记之IO流]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/117369730</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/117369730</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:20:47 +0800</pubDate><description><![CDATA[File类
1、1 File类概述
文件和目录路径名的抽象表示形式。
对File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径而已。
File类可以新建，删除，重命名文件和目录，但是File不能访问文件内容本省。如果需要访问内容本身需要输入/输出流。
File对象可以作为参数传递给流的构造函数

案例：
public class fileDemo {
    public static void main(String[] args) {
        File file = new File("]]></description><category></category></item><item><title><![CDATA[a++与++a]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/117369102</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/117369102</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:20:31 +0800</pubDate><description><![CDATA[代码：
public class Demo {
    public static void main(String[] args) {
        int a =3;
        int b=a++;
        int c=++a;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}


这串代码就相当于：
package com.superp]]></description><category></category></item><item><title><![CDATA[Super]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/117368763</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/117368763</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:20:15 +0800</pubDate><description><![CDATA[super注意点：
1、super调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中！
3、super和this总不能同时调用构造方法！
Vs this：
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有基础也可以使用
super：只能在继承条件下才可以使用
构造方法
this()：本类的构造
super（）：父类的构造

...]]></description><category></category></item><item><title><![CDATA[Java基础知识----继承！！！]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118942001</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118942001</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:19:11 +0800</pubDate><description><![CDATA[1、继承
继承概念的引入：
/**
* 学生类
*/
public class Student{
//成员变量
  String name;
  int age;

 //get和set方法
 
 //构造方法
 public Student(){
 }
 //成员方法
 public void eat(){}
 public void sleep(){}  
}

/**
* 教师类
*/
public class Teacher{
 //成员变量
 String name;
 int age;
 //g]]></description><category></category></item><item><title><![CDATA[Java炒鸡重要知识点：多态！！！]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118963861</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118963861</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:18:47 +0800</pubDate><description><![CDATA[多态的概述：
多态：同一操作（方法）作用于不同对象，可以产生不同的执行结果。

多态的前提和体现
！有继承关系
！有方法的重写
！父类的引用指向子类的对象，简单来记就是“父父new子”
package org.wdzl.unit03;

/**
 * 同一操作作用于不同的对象，可以产生不同的执行结果
 *     举例：
 *        父类： 宠物：叫的这个方法
 *        子类：  猫：叫（）……喵喵喵
 *               狗：叫（）……汪汪汪
 *     多态的前提：
 *]]></description><category></category></item><item><title><![CDATA[Java炒鸡重要知识点---final关键字]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118963744</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118963744</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:18:27 +0800</pubDate><description><![CDATA[final关键字
final关键字概述：
final关键字：最终的，可以修饰类，方法，变量
** final修饰方法时不能被重写！！！**
package org.wdzl.unit03;

/**
 * final关键字：最终的
 *    可以修饰类，方法，变量
 */
public class FinalDemo {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
 ]]></description><category></category></item><item><title><![CDATA[java基础知识---封装！！！]]></title><link>https://blog.youkuaiyun.com/James____Gosling/article/details/118929943</link><guid>https://blog.youkuaiyun.com/James____Gosling/article/details/118929943</guid><author>James____Gosling</author><pubDate>Wed, 04 Aug 2021 16:18:09 +0800</pubDate><description><![CDATA[封装
**封装概述：**隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
package org.wdzl.unit02;

public class Student {
    String name;
    private int age;
    public void setAge(int age1){
        if (age1 &gt; 0 ){
            age=age1;
        }else {
            System.out.println(]]></description><category></category></item></channel></rss>