新人自我总结基本语法接口 数据库入门 swing界面（未完待续）

第一阶段总结 基本语法结构， swing界面，数据库

时间就是过得如此的块，眨眼学习java就快两个月了，虽然进展缓慢，但是我一直在努力的学习，因为努力的孩子才能有饭吃，才能给自己的家人带去更美更好的生活。每当想起年迈的父母，便感觉无穷的力量推着我向前走着，继续努力着。

这一周在做一个项目，名字叫做宿管系统，简单来说就是通过读取数据库中的表中的数据通过jdbc接口在java程序中进行增删改查操作，最后通过swing界面显示出来，这就是第一阶段所有所学的内容了。不复杂，只是入门，如果有时间，下次我就写一下我这个界面的的过程，虽然不期待有人能看见，如果有人感兴趣，也可以咨询我

然后就下来是这将近两个月的总结，记笔记的软件我上次已经向大家介绍过了，挺好用的。
0.java入门宗旨 万物皆为对象，对象皆有为，不嫌麻烦大，皆可随意穿

标题0.java入门宗旨

万物皆为对象，对象皆有为，不嫌麻烦大，皆可随意穿

标题1.java基础

1命令规则
1字母，数字,_,$组成 2数字不能为开头，不能单独出现 3.不能是关键字 4.驼峰式命名 5.多个单词用下划线隔开
类名首字母大写 方法和属性名首字母小写，包名全部小写

2.内存的分区管理
1.stack（栈） 局部变量 2.heap(堆)new出来的东西 3.data segment(静态区，数据区)静态，常量 4.code segment (代码区)
.
3.if else if else if else
1.可以有多个else if 可以没有else 必须有if 2.可以省略花括弧，不过只能有一行

4.时间
1.System.currentTimeMills()；获取当前时间，返回以毫秒为单位的时间，用long接收，两次获取，可获取代码运行时间
2.util.Date常用来进行转换，simpleformat ;sql.Date 数据库的类型和String三者相互之间的转换; calender常用来计算输出
3… thread.sleep(xx)当前线程停止xx毫秒的时间，还没有学多线程

5.next()方法
1.会把空格当成回车，例如Scanner

标题2.数据类型 以及关键字

1.数据类型基础

基本数据的的包装类（主要用途基本类型与String类型之间的相互转换）
Integer-int Character-char Double-double Float-float Short-short Byte-byte Boolean-boolean Long-long 基本数据包装类的作用，就是用来进行数据类型的转换，例如Double.parseDouble() 或者Dolube.valueOf();

这个文本编辑好难用，字体设置，图片设置都没有，就拿这张图片的大小来说，找了半天都没有找到如何缩小，也有可能是我无知

	2.数值型中的整型（byte short int long 分别是 1248个字节 一个字节是8位）

默认的整型为int，而且byte 和short 变量 相加会默认为int,例byte3=btye1+byte2;会报错，无法判断是否超出界面，默认int.如果是byte3=123+2;能判断的这种，就不会报错；
long和float和decimal使用都需要在末尾添加相应的标识符，L F，M

	3.数值型中的浮点型（ float double decimal 分别是4 8 16个字节）
默认的浮点型为double,浮点型有个严重的问题，就是计算数据的时候计算不精确，哪怕只是0.1+0.1计算出来的结果都不是准确的，原因不必深究，结论很重要，所以少用浮点数进行计算。
解决办法：利用BigDecimal进行计算 ,自行验证
								```
								BigDecimal a=new BigDecimal(""+0.1);
								BigDecimal b=new BigDecimal(""+0.1);
								BigDecimal c=a.add(b);
								System.out.println(c);
								```

	4.字符型（char 是2 个字节）

注意String不是基本数据类型，String和char之间有着很紧密的联系，简单来说String就是char[]数组

	5.布尔类型、

字节数不确定，有的说是一个字节，有的说不确定，所以我也不知道有多少个字节，不过大多数说得是不确定字节

6.String 和 Math（字符串类 和 数学方法类）

里面有很多方法和属性进行运算，取值。实在太多，请自行API查询，不强求记住，最起码知道有哪些方法，需要用的时候再百度。比如查询字符串是否出现了某个字符，查询长度，分隔字符串，取子字符串，确定某个字符位置。。。math求最大最小，求平均，求随机数，求圆周，求面积，求幂，求次方。。。。。

.==恒等于比较的是地址，当new 一个String 在赋值的话，保存的地址是两个，在堆中，此时是false.
如果已知赋值如：String a=“aa”;这样的赋值为字面量赋值，其保存的数值存在于静态区，为同一个地址，故此时返回为true.

Object类的equals实际就是==，String 类中的equals重写过，所以比较的是值。
…equals();字符串是否相等，忽略大小写Ignore
…compartTo();字符串之间相差多少。“adc”和“abc”相差2，反过来相差-2，一个一个比较。直到比较到不同的那个数字或者字母为止，后面的就不管了。

.常用的命令，toCharArray(); charAt(int index);indexOf(子字符串，从指定的下标开始)；lastIndexOf(子，指定的下标反向搜索)substring();截取目标段的字符串，replace(“1”,“0”)将全部1替换为0；spilt(",")将某段用什么逗号分隔，数组的形式接收，startsWith(),endsWith判断是否以规定的字符串开始或结束，repalceAll（“window(?=98)”,“mac”);
toLowerCase(),toUpperCase()将英文字母转换为全部大写或者小写。

.面试题，String的对象是不可变的：：请问String a=“a”;String b=“b”;String c=“a”+“b”,一共生成多少个对象，答、4个。两个字符串相加会产生一个匿名对象，在赋值给指定对象。
如果超多的字符串相加，则使用StringBuffer(线程安全)，StringBuilder(线程不安全，可能会几个人同时操作,速度更快，）,两个都不会产生多个对象，都是在原来的字符串上进行改变。
补充：String a=“a”+“b”+"c"这种拼接，jVM会默认为StringBuffer对象的拼接，此时速度差不多，StringBuffer有两个方法，一个append末尾添加，一个insert指定位置添加

根据用户输入的字符串日期，计算天数 String – Date 用getTime()方法，进行运算。

public long toDate(String firstString, String secondString) {	// 计算两个日期相隔的天数
			Date d1=new Date();
			Date d2=new Date();
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//格式有严格要求----
			try {
				 d1 = sdf.parse(firstString);
				 d2= sdf.parse(secondString);//如果需要date转字符串，则使用format()方法
			} catch (Exception e) {
				// 日期型字符串格式错误
				System.out.println("日期型字符串格式错误");
			}
			long diff=d2.getTime()-d1.getTime();//*******结果是以毫秒为单位
			long Day =diff/(1000*3600*24);
			return Day;
		}

7.Pattern正则表达式

1.正则表达式主要的作用是判断指定的字符串是否如符合某种设定的规则，主要用的两个方法1.find()2**.matches**(str)

2.matches()的用法

//三个步骤 1.编译Pattern 注意不是new而是静态方法 类名Pattern.compile   放入规则。2.匹配字符串 Matcher 类用 对象名pattern.matcher得到的 放入字符串。最后使用 匹配的方法 对象名m.matches和find
//1.编译规则
String rex="";//先编规则，这里没写
Pattern pattern = Pattern.compile(regex);
//2.用规则匹配字符串
Matcher m=pattern.matcher(str);
boollean flag = m.matches//或者m.find()	;
 //难点在于如何设置规则，
//[a-zA-z0-9]{x}--只出现字母数字x个
//[a-z]{4}--只出现小写字母4个
//邮箱验证
String regex=[a-zA-Z]{1,}@[a-zA-Z0-9]{1,}\\.[a-zA-Z]{2,3}
//简写模式,需要写两个斜杠，因为特殊意义
//\w---[a-zA-Z0-9_] \W 除了这些
//\d---[0-9]	\D（大写都是相反）
//\s---空白字符
//\b---边界 [a-z]er\\b
//*{0，}；+{1，}，？{0,1}最多出现一次
//^以什么开头在[^]里面则表示意义和原来相反。$以什么结尾，个数也要算，不只是内容。 常用在find()
str="A11z111"
regex="^[A-Z]\\w{2,5}$"
//上面用find方法时匹配失败的，看似只定义了两个字符，其实已经固定死了。

//. 任意字符 如果你想单独使用.注意转义    
//|或者
//..还有很多简写，自行百度
//验证130 131 132 133 171 172 173 177 185 186开头的电话号码
//[1(3[0-3]|7[1237]|8[56])\\d{8}];

//贪婪匹配
//只替换windows98，windowsxp,替换成linuxxp,linux98
replaceAll("windows(?=98)","linux");
//反过来
replaceAll("(?<=windows)(98|xp),"Mac");

	7.位运算符和转义符
位运算符

~ & | << >>很多主要用于二进制的运算操作，新手了解一下，知道有哪些作用就好
转义符\
"普通的双引号 '普通单引号 \n换行 \t空格 \ 斜杠 @写在 开头，后面所有的转义符都失效， 转义符常用在String类型，正则表达式中

8.static 关键字

当有很多个对象都拥有同样的一个属性，可用static提出这个相同的属性，单独放在数据区。被static修饰后：

1.修饰后的成员变量只有一份。

2.多了一种访问方式，除了对象的调用，还可以被类名调用（类名.成员变量）

3.随着类的加载而加载

4.优先于对象存在，被所有对象共享

5.静态方法只能访问静态变量，不能访问非静态变量，同时不能出现this,super关键字。因为非静态存在于对象中，静态成员优先于对象存在。

6.static只能修饰成员变量以及方法，不能修饰局部变量

存放位置：1.类变量随着类的加载而存在于data区，实例变量存在于对象中，对象存在堆内存中

7.静态块和静态属性是同时执行的，按你排列的顺序依次执行，没有先后。

9.this关键字

this相当于当前对象的引用。

this 不能放入有主函数里面的类中。

谁调用方法，在方法的作用域内，可以填写this来代表当前对象。

10.return关键字

1.在有返回类型中用，起到停止并返回的作用。此时无法单独用 必须带返回值
如果返回时一个void,则可以只当做停止功能，也就是单独用不带返回值 只能放在if里面 .停止当前所在的方法。

2.如果需要返回多个值，可以使用返回数组的方法

11.final修饰符

1.final修饰类，方法，变量；（安全问题）

2.被final修饰后，类不可以被继承，方法不可以被重写，变量不能再赋值，此时就叫常量

3.常量的命名规范，全部大写，多个单词则用下划线隔开

12.abstract修饰符

修饰类或者方法，不能修饰变量abstract void aa();

1.当多个类存在相同的功能，但主体不同时，向上抽取功能的定义但是不抽取主体

2.抽象类和方法必须被abstract修饰，抽象方法只能在抽象类中

3.抽象类不能被创建对象，因为调用抽象类方法没有意义

4.抽象类中的方法要被使用，只能通过子类重写调用

5.抽象类中可以定义不抽象的方法，我们有时需要此类不能被new关键字创建对象时，可以用abstract修饰

6.子类只重写一部分抽象方法，则子类也是抽象类

7.抽象类不能被final修饰，不能被继承。抽象方法不能被private和static修饰，前者不能被继承重写和后者直接调用没有意义。不能被final修饰，不能重写

13.访问修饰符

修饰符 同一个类 同一个包 子类 不同包

1.public 1 1 1 1

2.protected 1 1 1（内部才行，对象不行） 0

3.默认访问 1 1 0 0

4.private 1 0 0 0

类只能被public 或者 默认访问符 修饰。一个记事本中定义多个类，只能出现一个public修饰的类，此类为主函数所在类。注意默认访问符是没有相应的关键字的，就是不填，有很多教材会写成default是不正确的。

14.数组（特点：定长！）

		一维数组

1.默认值：int 0 double 0.0 boolean false char ASCI表0的值 String null

2.数组的插入：建立一个新的数组

3.数组之间不能直接复制，如int nums2=nums1

如果这样做，nums2与nums1是存放的地址是一样的，内容也一样，修改其中一个，另一个也会相应的改变。和基本类型传递不同，数值传递的是内容。数组传递的是地址。

4.拷贝，Arrays.copyOf(原数组，新数组长度)。

	二维数组

1.int [ ][ ] aa = new int [3][4]；

第一个括弧代表横坐标，第二个代表纵坐标。

2.纵坐标的长度：int[1].length,初始化器，可以使纵坐标的长度不同或者int [][] nums=new int[3][];不规定纵坐标长度。同时使用的时需要声明，nums[0] = new int[2];此时就能用nums[0][0]，或者将nums[0]等于一个新的数组

3.循环打印；两个for循环。

	对象数组

默认值为null,只能放对象，且是你规定那个类的对象，拥有的属性就是该类的属性。

15.集合（重点中的重点！！！工作中主要用的是集合而不是数组，特点啥都能放且能放在一起）

关系表（map没有继承collection这个类，下图有误Map使用的是键值对映射）

0.错题

0.1.list.contains(stu.id);

错误点list里面放的Student，我却拿Student的属性去和Student比较，自然返回为false

0.2.对象传递引用类型数据的特点！！！！

错误点：将集合中的对象return取出来传递出去，用其他的引用接收他，更改新的引用的内容，则集合中的内容也改变了，因为只有一个对象。如果new一个新的对象出来，将他的值改为原本要传出去的值的内容，这样的话，就再是同一个对象了，切记！！

0.3.Arrays和Collections分别是两个工具类

1.添加add默认添加末尾，如果加上 下标和值则是插入到指定位置的，替换set 删除remove输出的是int类型，则默认是下标，如果删除整型的内容，需要传入一个对象如remove(new Integer(2))且只删除第一个匹配的。 长度size 遍历输出时，使用get（i）取出 返回下标IndexOf()没有返回-1（contains返回boolean），集合转数组.toArray(new 一个类型)，无参默认返回Object…dengdeng（中间有一个重要的点，如何删除集合中特定的数字！！）

2.<泛型> 添加对象时，循环输出得到的对象类型为Object类，我们需要强转才能使用它的方法，这样太麻烦，于是在ArrayList<类名>，这样只能插入相应的类，不能插入其他，包括整型数字。泛型（E就是一个替代符，意思是元素，K-key V-Value T-type，还有向上（<? super Teahcer>)、向下限定（直接继承）,注意不能new E。
还有一个集合Vector，和ArrayList一模一样，但是效率比Array要差很多，唯一的优点就是考虑了线程安全。但是Collections有方法可以把不安全的转为安全的，所以已经不用这个集合了

3.new集合时，常用向上转型List 后面跟子类对象 删除和插入多就用LinkedList()(底层是双向循环链表：就是在对象的尾部添加下一个对象的地址，对象的头部添加上一个对象的地址，循环头尾对象相互添加了地址),查找多就用ArrayList()（底层是数组）;用的多都是ArrayList(); 因为数组的插入需要重新建一个数组，但是有下标查询方便，而双向列表插入就比数组快多了，但是查询不方便

4.List插入的是有顺序的 区别HashSet插入式1.无序的，2.没有下标，只能有foreach和迭代遍历输出，且3.没有重复值，重复值会自动覆盖，4只能有一个null，因为foreach遍历会报空指针错误。
这里检测的重复值是通过一定的算法，将对象分成几个组，然后添加元素的时候只在相应的组内循环查找，这样大大的减少了循环的次数。每一个对象都有他对应的hashcode值.可以重写hashCode方法，让你需要的某个属性一样hashCode就一样，但是hashCode一样不代表地址也一样，他只为set集合服务。

5.TreeSet(有顺序)放入的类 必须要实现了Compareable这个接口，且会自行比较,循环时自己就调用了。重写compareTo(Student o)方法

6.集合排序：Collections.sort(list,compartor);

if(this.getScore()>o.getScore){
    return 1;
}
else if(this.getScore()>o.getScore){
    return -1;
}
else{
    return 0;
}//写成这样便会自行升序排序。不用调用，不用管原理

2.或者使用专门的类来排序，跟Collections是一样的实现Comparetor接口

3.两个接口comparable 和comparetor的区别
comparable排序方法需要传入的类自带排序的compareTo方法，例如String类就继承了
comparetor接口则是在使用collections.sort方法时，单独传入一个comparetor的对象，表示按照这个方法排序
他们内部实现的方法都是代码是一样的，都是返回1，-1,0.

7.map类HashMap TreeMap(实现comparable)（没有继承Collection 其实现的方式和List set 完全不同，特点键值对）
添加put 特点（键值对，没有下标，无序的，可以取键,可以把list放入map中）给出传入的对象赋予名字，本身并没有迭代的方法，但是可以entrySet的方法(直接把键和值封装到一个Set里面)，entry就是map里面的就是一个内部类，存放的键和值。

Set\<Map.Entry\<String,Teacher>> sset=map.entrySet();
Iterator\<Map.Entry\<String,Teacher>>  its=sset.iterator();
while(its.hasNext()){
​	Map.Entry\<String,Teacher> entry=its.next();
​	String str=entry.getKey();
​	Teacher teacher =entry.getValue();
​	System.out.println(str+" "+teacher);
}

//前面的String叫做键，就是后面对象的名字
Map<String,student>=new HashMap<String,student>();
map.put("谢娜"，s1);
Student s=map.get("谢娜");//得到是s1
//注意键的实现就是HashSet,是一个无序的内容，如果有重复的键，则会覆盖。可以为null.
//循环时，循环键，
Set<String> keys=map.keySet();
for(String ss: keys){}
//循环时，循环内容,list才有下标，父类没有。
Collection<Student> stus=map.values();
for(Student stu:stus){}

15.IO流（用完了就要关闭）

0.错误
1.第一步首先就要将所有的项目都设置成UTF-8格式！！！相当于统一文字格式，避免出现乱码问题，所有的字符都是3个字节
2.切记关闭流！！

1.File类（不能获得内容，只有路径和名字）** exists(存在否) creatNewFile(创建，try catch，如果没有后缀名，也能创建) mkdirs(创建文件夹) isDirectory(是文件夹否) getName(名字) getAbsolutePath(得到绝对路径，从根路径开始的) getPath（得到路径，输入为相对路径时，返回的路径就是构造器输入的内容而不是绝对） getParent(名字在哪个文件夹里) getParentFile(文件夹)delete(删除文件夹时必须是空的) .list(文件夹里所有的东西，FilenameFileter(接口) 实现内部方法，返回数组。)

**2.InputStream(输入字节流接口)：**子类是FileInputStream();关闭流close（先判断不是空的情况下防止空指针）read()一滴一滴的流（一个字节一个字节的传送）

//放外面，否则Finally中无法使用
InputStream is=null;
try {
 	is=new FileInputStream();//路径   
    int n=0
    while((n=isread())!=-1){//只能一个一个读，返回的为读取字节的大小，读完了就返回-1，注意每次调用都会读取一次包括判断，所以只能调用一次，用数据接收他。
       char c  = (char)n;
    }//
}catch(){
}
finally{
    try{
    if(is!=null){//先判断，否则会出现空指针
        is.close;    
    }catch(){}

    }
}
//一个一个字节读太麻烦可以使用read带byte数组的重载，注意返回的是每次读取的长度，需要把这个数组转换成相应的String类型在进行打印。
//注意：每次读取都会覆盖数组的内容，如果最后一次读取未满，则上一次数组的内容会保留到这次所以应该指定返回的长度，读取了多少长度就返回多少长度
byte bs[]=new byte [10];
//定义的长度为双数不能为单数。
int n=is.read(bs);
//没读完就返回数组长度，如果没有了则返回-1，以数组为单位的。
String str=new String(bs,0,n);

3.OutputStream(输出字节流接口)，用法和InputStream一样能自己创建文件，不能自己创建文件夹，上层路径要正确。 用的是子类，
write();
String str=“dsafdas”;
byte[] bs=str.getBytes();
//长度为双数，汉字两个字节
os.write(bs，0,10)；注意:可以同时读然后写，就是相当于复制粘贴，
//作业拷贝图片 为什么图片内存会变大？
//中文乱码问题GBK(中国字符编码) Unicode(国际字符编码) UTF-8(网络运输3个字节，可变)
乱码的问题，因为传输过程中每个国家运用字符编码不同，导致计算机无法识别。数据库和运输都应该设置成UTF-8. windows系统工程默认的汉字是Unicode和GBK。设置在右键最后一个，且应该先改，否则没有用。改成UTF-8后，字节数组的长度应大一点，否则不能被3整除，容易乱码。

4.字符流(Reader，Writer用法和上面两个相似)用于纯文字，无法用于图片和电影之类的，上面的读取使用的是字节流****
字节流可以转换成字符流，转换流InputStreamReader不可逆。=-
Reader r=new FileReader();
r.read()//无参一个字符一个字符的去读，没有返回-1;
char cs[] =new char[10];
r.read(cs)//返回的是char数组.

5.BufferedInputStream，BufferedOutputStream（处理流一定要关,就是在上面的代码中添加一个对象就可。加快读取的速度，只关外面的处理流即可）,并不能直接读取，传入的参数是流,或者处理流。
BufferedReader BufferedWriter(可以直接读取一整行readLine，返回String，但是写入的时候需要手动添加\r\n)所以常用来读！！！

6.PrintWriter(打印流，也是一个处理流),和BufferedOutputStream一样的操作，一定要关，否则无法打印，优点，不需要手动添加、\r\n，用来写！！！组合套餐。使用的方法为Println()自动换行, print和write都是不自动换行的。为了写入更快，里面加一个BufferedWriter
！！！！注意！！！处理流一定要关掉，否则会不打印或者写不进去。

7.inputStream in=System.in标准流 注意:标准流最后面有一个\n，读取的时候是把这个读了。*如何退出如果输入某个字符串就退出，如何去掉换行，使用str.trim()去掉了前后的空格和换行的字符串。

8.如何在已有文件的后面添加内容，默认为覆盖。在路径后面设置true,不添加默认false

//常用的几个流的类。
InputStream最顶层 FileInputStream;				InputStream---			FilterInputStream--BufferedInputStream；
OutputStream最顶层 FileOutputStream;			OutputStream--- 			FilterOutputStream--BufferedOutputStream；
				 
Reader最顶层		FileReader				Reader--		FilterReader	--BufferedReader
Writer最顶层		FileWriter						Writer--			FilterWriter	--BufferedWriter
																		  								--PrintWriter

				
System.in		System.out

InputStreamReader

16.try ,catch，finally异常处理()

1.受检时异常，大概率发生的异常，程序在编译时会提示错误，必须要用try catch围起来
2.运行时异常 ，小概率发生，不会提示错误，只能发生错误时，进行调试
3.try catch catch，可以捕获多个异常。try catch finally ，try和catch中如果有返回，则先返回，再运行finally中的语句。子类的异常应该写在父类的异常写在上面，要不然子类的异常进不去。就进去父类的异常里面了
4.抛出异常，在方法名字后面添加throws 异常1，异常2，通常抛到最上级，最最最开始调用的那里，一般为主函数，主函数还不能解决的就抛向虚拟机JVM，一般写在方法名后面throws。
如果写在catch里面就应该写throw e,没有s,抛了之后，方法名后面也应该抛出throws 异常。
5.打印详细的异常e.printStackTrace();自己调试用的，测试上线后，会把错误记录在日志文件中，log4j这个类。
6.自己构造一个异常的类，构建一个类，继承Exception，然后调用父类的构造器，快捷键，完成了。然后在需要强调的地方使用throw new clothException.

本次总结就先到这吧，东西太多了，毕竟学了两个月，从小白到入门也是不容易了，借着机会温习了一次，虽然有很多东西都知道，毕竟很简单，但是最终还是收获了一些东西，不过我的笔记肯定不是很详细，有很多细节的东西并没有写出来，不过我也不在意，因为我记录的特别是重点的都标注了，普通人就应该有点普通人的学法。强者直接无视好吧