<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[sunethan的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/sunethan</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; sunethan]]></copyright><item><title><![CDATA[Java笔记-注解]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108894305</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108894305</guid><author>sunethan</author><pubDate>Tue, 20 Oct 2020 10:10:40 +0800</pubDate><description><![CDATA[注解（Annotation)：
注解是对程序的注释信息。
一种引用数据类型，编译后的文件是xx.class文件
写法：
修饰符列表 @interface 注解类型名{
}
注解使用：
1.语法格式：@注解类型名
2.注解可以出现在类上，属性上，方法上，变量上等，也可以出现在注解上。默认情况下，注解可以出现在任意位置。
JDK自带注解：
@Override:
标识性注解，给编译器作参考的，表示方法重写了。
源码：
public @interface Override {
}
只能出现在方法上，是给编译器参考的]]></description><category></category></item><item><title><![CDATA[数据库-mysql基本知识-2]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108996813</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108996813</guid><author>sunethan</author><pubDate>Sat, 10 Oct 2020 15:09:28 +0800</pubDate><description><![CDATA[数据库-mysql基本知识-2
关于表的别名：
例如：
 select e.ename,d.dname from emp e,dept d;

表起别名的好处：1.执行效率高。2.可读性好。
如何避免笛卡尔积现象：
添加条件进行过滤。
提示：避免笛卡尔积现象，但是不会减少记录的匹配次数。只是显示了有效记录而已。
连接查询：
内连接：
如A和B表进行连接，AB两张表没有主副之分，两张表是平等的。
等值连接：
连接条件的关系是等量关系。
语法：
   ...
     表A
   join
     表B
  ]]></description><category></category></item><item><title><![CDATA[数据库-mysql基本知识-1]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108996639</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108996639</guid><author>sunethan</author><pubDate>Sat, 10 Oct 2020 14:40:24 +0800</pubDate><description><![CDATA[数据库基本知识-1
sql,DB,DBMS分别是什么？他们的关系。
DB：DataBase(数据库，数据库实际上在硬盘上以文件的形式存在）
DBMS：DataBase Management System（数据库管理系统，常见的有Mysql，Oracle，DB2 Sybase SqlServer…)
SQL：结构化查询语言，是一门标准通用的语言，标准sql适用于所有的数据库产品。sql语句在执行时，内部也会先由DBMS进行编译，然后再执行sql。
DBMS负责执行sql语句，通过执行sql语句来操作DB当中的]]></description><category></category></item><item><title><![CDATA[Java笔记-反射]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108894200</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108894200</guid><author>sunethan</author><pubDate>Thu, 01 Oct 2020 12:07:50 +0800</pubDate><description><![CDATA[反射：
通过java语言的反射机制可以操作字节码文件。
在java.lang.reflect.*;的包下。
反射机制重要的类：
java.lang.Class;  //代表整个字节码文件
java.lang.reflect.Method;  //代表字节码中的方法字节码
java.lang.reflect.Constructor;   //代表字节码中的构造方法字节码
java.lang.Field;  //代表字节码中的属性字节码。类中的成员变量，包括静态变量、实例变量。
java.lang.Class：]]></description><category></category></item><item><title><![CDATA[Java笔记-多线程]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108865006</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108865006</guid><author>sunethan</author><pubDate>Tue, 29 Sep 2020 12:07:43 +0800</pubDate><description><![CDATA[多线程：

进程是一个应用程序。
线程是一个进程中的执行场景/执行单元
一个进程可以启动多个线程。

例如：在DOS命令窗口输入一个java hello，会启动JVM，JVM再启动一个主线程调用main方法，
同时再启动一个垃圾回收器来看护，java程序至少有两个线程并发，一个是垃圾回收线程，一个是执行main方法的主线程。

进程A和进程B的内存独立不共享。
线程A和线程B的方法区和堆内存共享，但内存独立，一个线程一个栈，栈与栈之间互不干扰。
多线程并发可以提高效率，java中的多线程机制是为了提高程序的]]></description><category></category></item><item><title><![CDATA[Java笔记-IO流]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108864175</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108864175</guid><author>sunethan</author><pubDate>Tue, 29 Sep 2020 11:14:19 +0800</pubDate><description><![CDATA[IO流:
文件的输入和输出，通过IO完成文件的读写。（以内存作为参照来看）
输入流（InputStream）、读（read）：文件输入到内存当中。
输出流（OutputStream）、写（write）：内存输出的文件中。
可按照多种方式分类：
1.按照流的方向进行分类，以内存作为参照物。输入流、输出流。
2.按照读取的数据方式不同进行分类，一次读取一个字节byte（字节流），等同于一次读取8个二进制位，这种流是万能的，什么都可以读取。
一次读取一个字符（字符流），这种流为了读取普通文本文件而存在，只能读取纯]]></description><category></category></item><item><title><![CDATA[Java笔记-Map集合]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108862864</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108862864</guid><author>sunethan</author><pubDate>Tue, 29 Sep 2020 10:47:54 +0800</pubDate><description><![CDATA[Map集合
Map集合以key和value的这种键值对的方式存储元素。
key的特点：无序不可重复的，存储元素的特点和Set相同。
Map的子类：
HashMap：底层是哈希表数据结构，是非线程安全的
Hashtable：底层也是哈希表数据结构，是线程安全的，所有方法带有synchronized，效率较低，使用较少，因为已经有更好的解决方案。
SortedMap：存储元素的特点：无序不可重复，放在SortedMap的元素，会自动按照大小来排序。
SortedMap的子类：
TreeMap：底层的数据结构是个]]></description><category></category></item><item><title><![CDATA[java笔记-List集合]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108725737</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108725737</guid><author>sunethan</author><pubDate>Tue, 22 Sep 2020 10:54:46 +0800</pubDate><description><![CDATA[List集合：
集合在java中本身就是一个容器，一个对象，存储的是引用，不能存基本数据类型。
java中每一个不同的集合，底层对应不同的数据结构，往不同的集合中存储元素等于将数据放在不同的数据结构中。
注意：放在集合中的元素都要重写equals方法。
所有的集合类和集合接口都在java.util包下
java中集合分为两种：
1.单个方式存储元素：
这一类的超级父接口是java.util.collection
2.以键值对的方式存储元素：
这一类的超级父接口是java.util.map
collectio]]></description><category></category></item><item><title><![CDATA[java笔记-异常]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108725247</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108725247</guid><author>sunethan</author><pubDate>Tue, 22 Sep 2020 10:20:13 +0800</pubDate><description><![CDATA[异常
java提供了异常处理机制，JVM将new的异常信息抛出，打印信息到控制台中。
1.异常在java中以类的形式存在，每一个异常类都可以创建异常对象。
2.不管是错误还是异常都是可抛出的。
3.所有的错误只要发生，就会终止程序，退出JVM。
4.所有的RuntimeException及其子类都属于运行时异常，可以不处理。
5.所有ExceptionSubClass及其子类都是编译时异常，必须要处理。
注意：所有的异常都是在运行阶段发生的，编译阶段异常不发生。编译时异常必须要在编译阶段处理好，不然编译器报]]></description><category></category></item><item><title><![CDATA[java笔记-八种包装类、日期、随机数、枚举]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108565999</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108565999</guid><author>sunethan</author><pubDate>Sun, 13 Sep 2020 18:53:33 +0800</pubDate><description><![CDATA[八种包装类
八种包装类都是引用数据类型，父类是Object。




基本数据类型
包装类型




byte
java.lang.Byte


short
java.lang.Short


int
java.lang.Integer


long
java.lang.Long


float
java.lang.Float


double
java.lang.Double


boolean
java.lang.Boolean


char
java.lang.Character


基本数据类型可以]]></description><category></category></item><item><title><![CDATA[java笔记-String]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108557334</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108557334</guid><author>sunethan</author><pubDate>Sun, 13 Sep 2020 00:34:44 +0800</pubDate><description><![CDATA[基础知识

String属于引用数据类型，不属于基本数据类型。
随便用双引号括起来的都是String对象，String对象是final修饰的，不可以改变。
字符串直接存储在方法区的字符串常量池中，因为字符串在实际开发中使用太频繁，为了提高执行效率。

注意：垃圾回收器不会释放常量池的东西。
String常用的构造方法：
String s = new String("");
String s = "";   //最常用
String s = new String(char数组);
String s = new]]></description><category></category></item><item><title><![CDATA[java笔记-数组]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108557146</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108557146</guid><author>sunethan</author><pubDate>Sat, 12 Sep 2020 23:57:10 +0800</pubDate><description><![CDATA[基本知识:

数组是一种引用类型，不属于基本数据类型，数组的父类是Object类。
数组实际上是个容器，可以容纳多个元素
数组可以存放基本类型数据，也可以存放引用类型的数据
数组是引用类型，故存放在堆当中。
如果数组存储的是“java对象”，那么是存储对象的“内存地址”。
数组一旦创建，数组长度不可变。
所有数组对象都有length属性，用来存放数组的长度。
java数组中的元素类型统一。
数组中的元素内存地址是连续的。
数组第一个元素的内存地址，是整个数组的内存地址。
数组的每个元素都有下标，最后一个元素]]></description><category></category></item><item><title><![CDATA[java笔记-匿名内部类]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108539313</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108539313</guid><author>sunethan</author><pubDate>Fri, 11 Sep 2020 17:56:54 +0800</pubDate><description><![CDATA[匿名内部类：
内部类：在类的内部又定义了一个新的类，被称为内部类。

静态内部类：类似于静态变量
实例内部类：类似于实例变量
局部内部类：类似于局部变量

class example {
   static class Inner1{
   }//静态内部类
   
   class Inner2{
   }//实例内部类
   
   public void do(){
	   class Inner3{
	   }//局部内部类
   }
}

注：使用内部类编写的代码可读性太差。
匿名内部类是局部内部]]></description><category></category></item><item><title><![CDATA[java笔记-Object类]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108537704</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108537704</guid><author>sunethan</author><pubDate>Fri, 11 Sep 2020 16:54:47 +0800</pubDate><description><![CDATA[1.protected Object clone()
protected native Object clone() throws CloneNotSupportedException;

https://blog.youkuaiyun.com/qq_38962004/article/details/79721230    讲解深克隆和浅克隆
2.int hashCode()
public native int hashCode();

java对象的内存地址，经过哈希算法，得出一个值。
3.boolean equal]]></description><category></category></item><item><title><![CDATA[java笔记-package、import、访问控制权限]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108524456</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108524456</guid><author>sunethan</author><pubDate>Thu, 10 Sep 2020 22:50:35 +0800</pubDate><description><![CDATA[1.package

package是java包机制，包机制的作用是为了方便程序的管理，不同功能的类分别存放在不同的包下。
用法：package后面加包名，package com.sun.javalearn.packageAndImport;

package com.sun.javalearn.packageAndImport;
public class HelloWorld{
  public static void main(String[] args){
    System.out.println]]></description><category></category></item><item><title><![CDATA[java笔记-抽象类、接口]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108521383</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108521383</guid><author>sunethan</author><pubDate>Thu, 10 Sep 2020 19:52:29 +0800</pubDate><description><![CDATA[1.抽象类
语法：
[修饰符列表] abstract class 类名{
方法体；
}


说明：类与类之间有共同特征，将这些具有共同特征的类再进一步抽象形成了抽象类，由于类本身是不存在的，所以抽象类无法创建对象。
抽象类属于引用数据类型。
抽象类无法被实例化，无法创建对象，只能继承。
final和abstract不能连用，对立的。
抽象类有构造方法，其构造方法是给子类使用的。
抽象类不一定有抽象方法，抽象方法一定要出现在抽象类中。
一个非抽象的类继承抽象类，必须将抽象类的抽象方法实现了，否则编译器报错。
]]></description><category></category></item><item><title><![CDATA[java笔记-this、final]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108456460</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108456460</guid><author>sunethan</author><pubDate>Mon, 07 Sep 2020 22:08:40 +0800</pubDate><description><![CDATA[java笔记-this、final
1.this关键字

super能出现在实例方法和构造方法中。
super的语法是：“super.”和“super（）”
super不能出现在静态方法中。
super.大部分情况下是可以省略的。
super（）表示通过子类的构造方法去调用父类的构造方法
super（）只能出现在构造方法的第一行，通过当前的构造方法去调用父类的构造方法。
目的是：创建子类对象的时候，先初始化父类特征。
当一个构造方法的第一行既没有this（），也没有super（）的话，默认会有一个super]]></description><category></category></item><item><title><![CDATA[多态语法]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108437160</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108437160</guid><author>sunethan</author><pubDate>Sun, 06 Sep 2020 21:35:53 +0800</pubDate><description><![CDATA[多态基础语法：

向上转型：子类型–&gt;父类型（类似于自动类型转换）
向下转型：子类型&lt;–父类型（类似于强制类型转换） 如果想调用子类中特有的方法，就要用到向下转型
向下转型用到强制类型转换符，可能会引起类型转换异常（java.lang.ClassCastException），所以必须先用instanceof判断
注：无论是向上转型还是向下转型，两种类型都要有继承的关系

instanceof：

可以在运行阶段动态判断引用指向的对象的类型。
语法： 引用 instanceof 类型
返回值为tr]]></description><category></category></item><item><title><![CDATA[面向对象三大特性：封装、继承、多态]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108434716</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108434716</guid><author>sunethan</author><pubDate>Sun, 06 Sep 2020 21:13:40 +0800</pubDate><description><![CDATA[面向对象三大特性：封装、继承、多态
1.封装
封装的好处：

封装可以隐藏实现的细节，封装内部可以很复杂，对外提供简单的操作入口，使得使用者可以不关心内部实现原理，可以实现简单运用
封装之后才会形成真正的独立体
封装之后，以后的程序可以重复使用，可在许多场合下使用。
封装之后，字段和实现细节被隐藏，不允许外部直接访问，事物的安全性得到提高。

属性私有化（private），通过get和set方法（非静态方法）得到和修改属性。

2.继承
class A {}
class B extends A{}
B类继承]]></description><category></category></item><item><title><![CDATA[Java笔记-构造函数、static、代码块、this、JVM]]></title><link>https://blog.youkuaiyun.com/sunethan/article/details/108428245</link><guid>https://blog.youkuaiyun.com/sunethan/article/details/108428245</guid><author>sunethan</author><pubDate>Sun, 06 Sep 2020 10:04:30 +0800</pubDate><description><![CDATA[Java笔记-构造函数、static、代码块、this、JVM

日常学习笔记

1.构造方法

构造方法又称为构造函数、构造器、Constructor
构造方法的语法结构：
{修饰符列表} 构造方法名（形式参数）{
构造方法体；
}
与普通方法不同，其无需指定返回值类型，但返回的是本身类的类型。
构造方法的方法名必须和类名保持一致。
当一个类中没有定义任何构造方法，系统默认提供一个无参数的构造方法，这个构造方法称为缺省构造器
当一个类显示的定义一个构造方法，系统不再提供这个类的缺省构造器。建议开发过程中手]]></description><category></category></item></channel></rss>