java入门学习笔记总结

switch 使用要注意的问题
1.case 列出的常量不能相同
2.case和default顺序可以互换不影响结果
3.switch智能匹配byte,short,int,char,(jdk1.5)enum,
(jdk1.7)String。


day1
第一章
并行一处理完成一个任务，快速的切换到下一个任务
java为什么是垮平台的。
*jvm的不跨平台性决定了java的跨平台性。*
并发特性
JVM java虚拟机 虚拟机就是jre


JIT用来保证循环体内容的 （防止内存溢出）


java的构成：
jdk + jdk构成
jdk:java Development Kit java开发组件
jre: java Runtime Environment java运行环境
jdk包含jre如果只是需要运行java程序那只需要安装jre就可以了，但是如果需要编写java程序就必须安装jdk。
jdk文件目录：
bin：存放了一些可执行文件（负责运行java文件的可执行文件就在其中）
db：存放和数据库相关的文件。
incloude:存放了一些C语言的头文件
lib：存放第三方jar包。
src压缩放的是java的源码
如何运行一个java文件
编译
javac 文件名 .java
2运行
java 文件名


控制台定位盘符
盘符号： 例如：d；


定位文件夹
cd 文件夹名 例如 cd java
后退 
cd..
一个java文件里面可以有多个类
但是，只能有一个用public修饰的类
用public修饰的类名必须保证和文件名一致
clscmd中清屏
public ：访问修饰符
public 访问权限最大。
类名：要求 1.不能以数字开头， 
   2.最好不用汉字，不用拼音。
   3.首字母要大写。
   4.可以用下划线和美元符开头。
public static void main(String[] args){
//主函数程序的入口
System.out.println()
//打印输出 去掉ln是在一行上打印
}
注释：单行注释 //
多行注释 /**/
文档注释 /**
...
*/ 文档注释可以通过javadoc指令
导出


第二章
变量：
数据在内存中存储空间的表示，堆 栈 
堆的特点：存储的数据量大，但是速度慢。
栈的特点： 数据量小，但是速度较快。
如何去声明一个变量？
数据类型 + 变量名 = 值。
数据类型：
总体分为两种 基本数据类型   （八大基本数据类型）
引用数据类型: 类 接口 数组 null
boolean 布尔型 取值为ture false 或 1，0；
short 短整型  long  长整型 long 声明的值要在后面加上大写的L byte 字节型 char字符型 声明值需要使用单引号
*int 整形范围要背面试会用  -2的31次方~2的31次方-1
double 双精度浮点数 取值范围大
float  单精度浮点 声明要在后面加上小写的f
float 吧32位分成了三部分 ， *第一部分是符号位
第二部分是整数位，第三部分是小数位。*
小数类型所以建议使用double
变量名：
要求和类名相似，不能使用关键字（51个）， 建议使用驼峰命名法,第一个单词首字母小写，之后单词首字母大写。
char firstName ="张"。
基本属类型都放在栈里面
数据类型转换:
1.自动类型转换（隐式转换）
2.强制类型转换（显示转换）
1.取值范围大的转向取值范围小的，需要强制转换的
2.取值范围小的转向取值范围大的，自动转换。


显示转换例子
double = 1.5;
int num2 = (int) num;
最后得到num2为1
所以说 显示转换会损失精度




第二天
转义符  /t 制表符 /r 换行
交换变量的方法 1，引入第三方变量
int num1 = 10; int num2 = 20; int num3 =0;
num3 =num1; num1 = num2; num2 = num3;
2.第二种方法
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
运算符 
算数运算符 
+ - * / %  ++ --
+：除了可已经I系那个见运算以外，还可以用来变量与字符串之间的连接。
任意数据类型和字符串连接都会变成字符串
/不计算小数点，取整运算。
%取余运算只去余数
++自增运算  --自减运算
num ++ 与 ++num 区别 前者是先执行代码，在运算， 后者是先运算在执行代码。
有意思的案例：
int j = 5;
int k = 6;
int num =  ++j + --k + k++  - j--;
System.out .println(num);
=代表的是赋值 Int num = 5
== 判断值是否相等
!=不等于
关系运算符 结果是布尔类型的
逻辑运算符
逻辑运算符操作的全都是布尔类型
！!条件  条件为真结果为假
条件为假结果为真
^异或  条件1^条件2
一真一假结果为真
&&短路与  条件1&&条件2 两个条件都是真，结果就是真。如果第一个为假，就不判断第二个。
||短路或  条件1||条件2 两个条件有一个为真，结果就为真。如果第一个为真，就不用判断第二个。
& | 与，或：使用方法和前两者一样 他俩的第一个条件为真，依然也会判断第二个。


第四章
if（条件）{
//条件为真时执行...
}else{
//条件不为真时执行...
}
if（条件）{
}else if（条件2）{


}else(条件3){
}
if的代码如果只有一行时可以省略掉花括号。（但是不建议这么写）


switch case
switch（表达式、一般来说都是变量名）{
case 值1:
如果值为1 就执行的代码;
break;
case 值2：
如果值为2就执行的代码;
break;
default:
如果都不满足上边的条件
就执行的代码。
}
常量是不变的量 变量是变化的量。
表达式可以为 byte char short int 
1.5可以使用枚举 1.7可以使用字符串。
swich case 判断是整值
if和switch何以替换么？
if做区间判断和等值判断
switch只能做等值判断，所以只要能用swicth的肯定可以用
if能用if的不一定能用switch


第三天 2017、7、28
位运算
8421 
2《《3 = 2*2的三次方
2》》1 = 2* 1的次方
位运算符常用的是左移右移。
.equals检测双方的字符串
如果这两字符串有常量的话，尽量
吧常量卸载字符串1的位置。


第五章：循环
while循环  for循环
这里的条件不能想for一样写出来。
while语法
while(条件) {
要循环的代码
}
1.循环变量 2.循环条件 3.循环体。
遇到死运行crtl+c可以退出来。
如何避免死循环，每次循环之后，更新循环变量的值。
do-while循环 先执行，后判断。
do{
  循环体
}while(循环条件)


for循环
for（循环变量；循环条件；每次循环后更新的值）{
循环体
}
for和while循环的区别
for循环循环次数一般来说是确定的
while是不确定的
所以说当循环次说确定的时候使用 for
否则就用while
多重循环：主要是指for的多重循环。外层执行一次，
内层必须全部执行完毕，外层再执行第二次。




day4 2017/7/31
impor java.util.*;
导入所有的java.util.*包。
System.exit(0)退出java程序


数组
堆当中存储一个地址
栈当中存储内容


1、数组的数据类型相同
2、内存地址连续
数组的声明
数据类型 [] 数组名 = {值1，值2};
数据类型 [] 数组名 = new 数据类型[长度];
数据类型 [] 数组名 = new 数据类型[]{值};
3第三种就是第一种的简写
方括号里绝不可以有值
数组一旦声明，长度就不能改变了
数组如果只声明长度，那么数组类型对应第二章的表的表，引用数据类型都为null




如何操作数组？使用下标去操作数组，下标从0开始。
数组名[下标]：获取指定数组下标的值。
数组的遍历
数组名.length 
可以返回数组的元素个数
AIOOBE 数组下标越界
ArrayIndexOutOfBoundsException
冒泡排序


for(int i =0;i for(int j =0;j if(arr[j] int num = 0;
num = arr[j];
arr[j] = arr[j+1];
arr[j+1] = num;
}
}
}
冒泡排序一次对比两个，然后最大排序的数量是数组长度-1


冒泡排序 每轮一个比较，选则最大记性比较 外层循环 -1似乎也没事
选择排序
//先进行对比，后切换下标。
for (int i=0;i int k =i;
for(int j=k+1;j if(arr[j] k=j;
}
}
if(i!=k){
int num =0;
num = arr[i];
arr[i] = arr[k];
arr[k] = num;
}
}
插入排序


有个值为13 


二分查找又称作折半查找
二分数组必须是有序的


String 是引用数据类型。
//少了类类型


方法的构成
访问修饰符 返回值 方法名（参数列表）{
方法体
}
在没有学习访问修饰符，在没有学习封装之前
访问修饰符使用 public
返回值:方法结束后，对外提供的值。
方法名和类名一样
参数列表：执行方法需要的数据
方法分为四种
有返回值有参数
无返回值无参数
有返回值无参数
无返回值有参数
无返回值无参数： 返回值用void带刺参数列表不填值。
只要引用数据类型默认值就是null
有参数无返回值：
参数分为两种，一种叫做实参，在对象调用时赋予，
一种叫做形参，在方法参数列表时赋予
多个参数使用逗号隔开
形参和实参数据类型要做到一一对应。
有返回值无参数的方法
不定长参数 数据类型...参数名
在调用时，实参就可以写多个，在方法中，会以数组的形式
保存参数。
int num =10;
public void tase{
int num =20;
}
全局变量 &&局部变量
全都能用 只能元素里面使用 
变量的作用域，变量分为全局变量和局部变量
全局变量声明在类当中
局部变量声明在方法体或循环体当中
只作用于其中的一部分。
如果出现重名变量遵循就近原则。
就近原则 
String储存在栈类型中
String name1 = ""
String name2 = ""
String name3 = new String("小明");
String name4 = new String("小芳");
name1 ==nam2;//ture;
String  
看到new就是在栈内存当中保存了地址
在堆内存当中保存了内容所有说name1
和name3不在同一个区间内。
name3 和name4都开辟的新的空间
只是开辟了新的空间，只是地址不同。
频繁修改String有可能出现问题。
String对象不可变
一旦声明，如果修改值，就必须开辟新的内存空间，所以频繁操作字符串，会损失大量不必要的内存空间。
String 查询快
常量池在栈里
String对象
如果调用null对象的方法，会报出空指针一场
NullPointerException
chanAt()返回指定下标对应的字符串
如果下标超出，则报出字符串下标越界异常。
StringIndexOutOfBoundsException


indexOf返回指定字符串在此字符串中第一次出现的下标。
找不到返回-1
split拆分字符串。
String [] arr = test.split("A");
for(int i=0;i System.out.println(arr[i]);
}
day6


面向对象编程
类 对象
对象：万物皆对象
例子：如果说杯子是一个类
那么小明的杯子是一个对象


类一般比较抽象 而对象
是由类具现化的实例
和现实生活中不同
java中是先有了类才有对象


类里面包含什么？
1属性   2方法
结合现实生活中来说
属性一般都是名词
方法一般都是动词


如何去创建一个对象
类名 对象名  = new 类名();


如何去访问类中的属性
通过访问符"." 可以看作对象"的"属性


方法的构成：
访问修饰符 返回值 方法名(参数列表){
方法体
}
访问修饰符：在没有学习封装之前
访问修饰符使用public
返回值：方法结束后，对外提供的值
参数列表：执行方法需要的数据


方法分为四种
有返回值有参数
无返回值无参数
有返回值无参数
无返回值有参数
无返回值无参数：返回值使用void代替
参数列表不填值


有参数无返回值：
参数分为两种，
一种叫做实参，在对象调用时赋予，
一种叫形参，在方法参数列表里赋予
多个参数使用逗号隔开
形参和实参数据类型要做到一一对应


有返回值无参数：
需要返回什么数据类型，就在返回值上
写什么数据类型，并且在方法的最后
添加关键字return 用来将数据返回


不定长参数 数据类型...参数名
如
public void show(int...arr){}
c.show(1,2,3,4,5,6,7,8);
在调用时实参可以写多个
在方法中，会以数组的形式保存参数


变量的作用域
变量分为全局变量和局部变量
全局变量声明在类当中，作用于整个类
局部变量声明在方法体或循环体当中，
只作用于其中一部分
如果出现重名变量，遵循就近原则


String对象不可变
一旦声明，如果修改值，就必须开辟新的
内存空间，所以频繁操作字符串，会损失
大量不必要的内存空间


String对象的方法


equals


如果调用null对象的方法，会报出空指针异常
NullPointerException


charAt()返回指定下标对应的字符串
如果下标超出，则报出字符串下标越界异常
StringIndexOutOfBoundsException


indexOf()给定一个值，如果字符串包含
该值就返回该值第一次出现的下标
如果找不到返回-1


substring截取字符串
如果有一个参数 就从指定参数位置
截取到末尾


如果有两个参数，就把第一个参数作为开头
把第二个参数作为结尾
包含头不包含尾的截取


面向对象的三大特性
1封装 2继承 3多态


构造方法：
作用：用来初始化对象，
只调用一次 在创建对象的时候被调用
任何一个类都有构造方法
如果我们没有声明构造方法 java会给我们添加
一个无参数的构造方法
如果我们自己写了构造方法，java就不再自动
添加了


构造方法的写法：
方法名和类名相同
没有返回值 连void也没有


方法的重载：
方法名相同，参数列表不同 和返回值没有关系
方法的签名：指方法名和参数列表


this关键字：
本类对象的引用


封装：
访问修饰符的封装
四个访问修饰符
公开的 public
缺省的 default
受保护的 protected
私有的 private


public可以修饰 属性 方法 类
在一个项目下的任意位置都可以访问


private 可以修饰属性和方法
只能在本类当中访问
一般会提供公开的get和set方法
去操作属性 
public String getName(){
return name;
}
public void setName(String name){
this.name = name;
}


static关键字
是一个修饰符
可以修饰 属性 方法 代码块
修饰完毕后叫做静态属性 静态方法 静态代码块
static可以将属性和方法由成员级别
提升为类级别 


在对象没有创建之前 静态属性和方法就已经
存在了可以通过类名.属性名或类名.方法名
直接调用，静态属性和方法属于共享资源


加载顺序：
加载类——>加载静态属性和静态方法——>
加载对象——>加载普通属性和方法


在静态方法里面无法访问非静态的属性和方法
this关键字不可以在静态方法中使用


静态代码块
在创建对象时被调用，并且只调用一次
优先于构造方法 一般用来加载驱动
static{  }
day7
java当中继承发生在类当中
一个类可以继承另外一个类继承的类子类
被继承的是父类 父类比较抽象，子类更加具体。
使用关键字 extends来产生继承关系
java中只允许单继承，一个父类可以由多个子类，一个子类只能由一个父类。
子类可以访问父类当中非私有的属性和方法。
super获取父级元素
如果在写子级中调用父级属性或者方法，可以不用super，jvm会自动加上。
子类创建对象的时候，一定会去调用父级的构造方法，
通过super（参数）来调用
super必须放在子级构造方法第一行，并且只能有一个。
如果父类构造方法没有构造没有参数，super（）可以不写，但是jvm会自动添加。
重写就是方法名，和方法参数一样的
重写方法名相同，参数相同，重写，发生在继承关系中。子类重写的访问修饰符权限，一定要大于或者等于父类的访问修饰符。
重载方法名相同，参数不同 方法签名不同，之发生在一个类中
@override它下方的必须是一个重写的方法，不然报错。
如果不是方法重写，即使语法没有问题，依然不会通过编译
final关键字可以用来修饰变量、方法、类
final修饰的变量是一个常量。而且永远不能被修改。final一般配合static关键字配合使用声明一静态常量变量名全部大写
final修饰的方法，不能被重写。
final修饰的类不能被继承。
继承的优点 ：能提供代码的重用性。
*单例模式的第一个特点无法在别处创建对象，私有的构造方法。*
*只能在自己本类上创建对象。通过静态方法，返回该对象。*
懒汉使  恶汉使， 恶汉使有线程问题！（不安全）。
Object类 他一般叫做超类
Object类使所有类的父类，所有的类都直接或间接的继承Object
hashcode() 返回对象的哈希值，
clone ()  getClass()返回自解码对象 finalize()垃圾回收站机制。
toString
Object 的toString方法用来返回计算的哈希值 的哈希值类似于身份证号，每一个对象，都有自己特有的一个哈希值。
一般对我们创建的实体类，重写toString方法一般用来返回对象信息。
equals
判断两个对象的哈希值的 如果哈希值相同返回true，否则返回false。
String类修改了Object的equals方法。


修灌溉访问修饰符作用范围由大到小是 pubilc -protected=default-private;






day9
多态：
一个对象产生多种形态。
想要产生多态，需要继承或者实现的关系。liskov 里氏替换原则：凡是父类出现的地方，都可用子类来替换。
父类在前叫上转型， 子类在前是下转型，下转型容易出错。动物是猫会报错的。
*对象的上转型要重点记， Animal c2 = new Cat()//对象上转型 *
判断一 instanceof 判断二 ， 用来判断一不是不而会出现错误。
//向下转型的正确例子
//如果错误 就爆出 classcastException
Cat c1 = new Animal()//对象下转型 ClassCastException 类型转换异常，会报出的错误。
动物是猫 有很大几率出错。
向上转型：出现有子类特征的父类对象，当子类对象存在重写的方法的时候，会调用子类的方法。
后期会用到大量的数组的向上转型。


抽象方法/抽象类：当一个方法只需要被重写 不需要被调用的时候，就可以把这个方法定义为抽象方法。
1.使用关键字abstract修饰。  2.没有方法体。 3.如果一个类中包含了抽象方法，那这个类就必须是抽象类。4.抽象类无法实例化（无法创建对象）。5如果一个类继承了抽象类，就必须重写抽象类里所有的抽象方法。（除非继承的类是一个抽象类）。


抽象接口无法实例化
接口：
接口是更加纯粹的抽象类 *接口内只能由静态常量和抽象方法。*interface implements 
定义接口的关键字interface类和接口之间的关系是实现使用关键字implements java中一个类可以实现多个接口，
在街口里面定义常量和方法， 不写static final jvm会自动添加  方法不写public jvm会自动添加
接口和接口之间可以产生继承关系。接口可以多继承，接口和接口之间的关系是继承，并且是多继承。
接口的作用提高扩展功能的，继承了一个接口，就要重写方法。
抽象类提高了代码的重用性 接口扩展了功能，解决了单继承的局限性。
day11:
多态：
一个对象产生多种形态


产生多态需要
继承或者实现的关系


liskov 里氏替换原则：
凡是父类出现的地方，都可用子类来替换


对象的向上/向下转型


Animal c2 = new Cat();//对象的上转型
猫是一个动物 不会报错 


Cat c1 = new Animal();//对象的下转型
动物是猫 有很大几率出错


向上转型：创建的是有子类特征的父类对象
当子类对象存在重写的方法的时候，会调用
子类的方法


抽象方法/抽象类：当一个方法只需要被重写
不需要被调用的时候，就可以把这个方法定义
为抽象方法


1使用关键字abstract修饰
2没有方法体
3如果一个类中包含了抽象方法
那这个类就必须是抽象类
4抽象类无法实例化（无法创建对象）
5如果一个类继承了抽象类，那就必须
重写抽象类里所有的抽象方法，除非继承
的类是一个抽象类




接口：
接口是更加纯粹的抽象类
接口内只能有静态常量和抽象方法
定义接口的关键字interface
类和接口之间的关系是实现使用关键字implements
java当中一个类可以实现多个接口
接口和接口之间的关系是继承，并且是多继承


抽象类和接口：
抽象类提高了代码的重用性
接口扩展了功能，解决了单继承的局限性


*************************第八章*****************************
1.内部类 ，内部类属于外部类，匿名内部类使用最多，最难。
成员内部类：可以用任意访问修饰符。
关键如何创建内部类， 假设外部类名叫Outer 内部类叫Inner的话
Outer.Inner i = new Outer().new Inner();
内部类可以用外部类的属性。内部类可以访问外部类的私有属性和方法
外部类不能访问内部类 的属性和方法，想要访问必须创建内部类对象
我们不能在内部类中使用static静态属性或方法。除非定义的是静态常量。
内部类的作用：
1间接实现多继承 2.可以通过内部类封装属性和方法。
2.静态内部类：
静态内部类，更像是一个普通的类，可以直接创建内部类对象
处在同一磁盘下的class文件名最好别重名，
创建静态内部类对象，Outer2.Innner2 i2 = new Outer2.Inner2();
内部类只能访问外部类静态属性和方法，外部类也只能访问内部类当中的
静态属性和方法。 
3、局部内部类 声明在方法体当中的类，作用域范围小，局部类不能
加访问修饰符。局部内部类属性，默认添加了final来修饰，必须是常量
4、匿名内部类：没有名字的类
匿名内部类必须依托继承关系或者接口存在。创建对象时才会声明出来
*******************类名/接口名 变量名 = new 类名/接口名（）｛
要重写的方法。
｝主要这里要加分号。**********************只会调用一次。


自动装箱和拆箱
java八种基本数据类型都有鱼其对应的引用数据类型，其中int->Integer
char -> Charracter
自动装箱：
把int类型的数据转换成Interger类型的数据
Interger.paresInt("")可以将字符串转化为int类型。
如果输入的字符串有问题， 有可能报出数字格式化异常
NumberFormatException
枚举
是一个特殊的类 内部声明的都是静态常量。枚举无法创造对象， 因为
构造方法是私有的。声明枚举的关键字：enum 在枚举里面的枚举值
没有数据类型，可以配合switch来使用，建议使用大写。
枚举类型是class
StringBufer/StringBuilder
StringBufer线程安全，效率低  StringBuilder线程不安全，效率高
append()追加字符串 insert(下标，值)在指定下标后，插入值。
  ()返回当前容量，默认是18（有待研究，不常用）。
replace(开头，结尾，"这个是替换的内容") 包含头不包含的字符串替换。
reverse()反转字符串。String和StringBuffer可以用来相互转换。
String word = "123"; StringBUffer sb2 = new StringBuffer(word);
String word2  = "" + sb2;


第九章异常
异常一但发生，程序就会终止。RuntimExeotion之外的所有Excption需要去处理的
非受查一处能够Error和RuntimeException 不用去处理代表一些比较严重的错误，
如何去处理异常
1捕获，2抛出
捕获异常
异常
try-catch
会出现异常的代码要放在try中，如果出现问题，参数里面填的是异常的对象。
受查异常除了 cathc里面放异常处理。
try{
有可能会抛出的异常的代码
}catch(异常对象){
异常处理代码。
}finally{
总要执行代码
}
catch可以有多个但是不许保证异常对象 统计或者一级比一级高。
try-catch-finally
try-catch
try-finally 可以执行
catch-finally
try｛｝不可以执行
抛出 throw throws throws用来 修饰方法，被修饰的方法，有可能会抛出异常
throw 用来手动抛出异常在方法当中使用。
在方法体的后面去写抛出只是一暂缓的作用
 右击-new-javaProject 项目名不可以数字开头
2.src ->new ->package（包）。包名规范：公司性质.公司名.包名
3包下->new ->class
快速导入包 ctrl+shift+o快速导入包/删除不用包
ctrl+d 删除一行 ctrl +alt + 下 复制一行
alt+ / 联想
自定义异常：
如何去定义一个异常声明一个各类继承Exception这个类就变成异常类。
重写getMessage()方法，把错误信息返回出来。






面向对象的复习
41~50页


面向的对象的基础


什么是类？ 什么是对象？
类当中包含什么？
属性：变量
方法：分为四种


怎么去创建对象？
真么去调用对象的属性和方法？ 


String类的法广发 P48
着重记equals substring indexOf 


50~56封装
封装本身：私有的属性
需要提供公开的set/get方法去访问


构造方法 ：很重要 初始化对象
this关键字
static关键字（暂时放一下）


57~60继承
继承的关键字 子类和父类如何调用的
super关键字配合构造方法使用
方法的重写


62~最后  多态
里氏替换原则
对象的向上转型：创建的是父类对象
参数的多态性
抽象类 接口的使用
抽象方法的特点？
接口的使用




day13
泛型
泛型的最大作用就是用来防止类型转换。。
声明泛型类 将泛型写在类名后面
class Demo1{
}
泛型方法 将泛型写在访问修饰符后面
class Demo2{
public void show(T t)｛
｝
}




第十二章集合 


集合类型对应的所有接口：Iterable迭代器接口
Collection：类集合接口 List:列表接口
set：数据集接口 Queue：队列 Map：键-值对组合
映射表。


Listlterator扩展了父接口Iterator，允许双向遍历集合，并修改
和删除元素
list接口扩展了Collection ，特点：有序且可重复的
set接口扩展了Collection，特点:无序且不可重复。


list 列表 set 集合 map 映射 collection接口 
list接口主要学系其实现类 ArrayList 和  集合中类
LinkedList    在api中e类型就是泛型
list接口主要学系其实现类 ArrayList的方法
增加add() 直接向后追加 add(内容)也可以 在
指定下标增加 add(下标，内容);
删 remover()可以根据下标删除 remove(下标)
可以根据内容删除remover(值) int 类型的除外
如果存在interger类型数据，使用下标去删除
改set(下标,值)将指定下标的值作出修改，
查get(下标)返回指定下标的值。查单个 
查全部size()查集合的长度，1.通过下标查询
list.size()返回集合的元素个数。 
然后遍历数组，用get[i]来遍历全部数组，
似乎还有更好的方法，这种方式浪费资源
不会使用。


2.使用迭代器iterable() 来遍历 第一步：获得
迭代器，集合中提供了iterator()可以返回迭代器
第二步：遍历
迭代器当中提供hasNext方法判断是否有元素
next方法显示下一个元素


3 forech循环 内置了迭代器的增强性for循环 
假设说我们要遍历Object类型几何对象1
for(Object o:l){


}


for(遍历对象的数据类型 任意:要便利的对象名){


}




day15
list
实现类 Arraylist
ArrayList底层是数据结构，查找效率高
查询快，删改慢
LinkedList底层是链表结构。修改效率高
数据包含了一些头尾信息，删改快，查询慢。
提供了关于头尾的操作方法。
addFirst() removeLast（）再开头添加
在结尾删除等。 
list的特点：
有序（怎么存进去 怎么拿出来） 可以重复                      
Vector用法和Arraylist完全相同，但是
Vector线程不安全  ArrayList线程不安全
Map映射
存储数据采用的是键（key）值(value)对的方法
kay不可以重复，value可以重复。如果又重复的key
创建HashMap的map类方式
map name = new HashMap();
构造方法摘要 
HashMap() 
          构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 
HashMap(int initialCapacity) 
          构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 


后出现的会替换掉之前的。增：put（key:value）;
删除remover(key)该方法可以返回该key对应的value
key可以间接的通过put和remover方法实现修改
查:get(key)返回该key对应的value
查全部：map没有实现iterable接口所以无法直接使
用迭代器
使用keyset()方法返回一个set集合，该机和保存了map
当中所有的key
遍历map的下的所有
1 keyset()方法返回了set集合
该集合保存了map当中所有的key
2 entrySet()方法 返回一个Set集合（Map.Entry）类型 Map.Entry接口
提供了getKey()和getValue()方法可以提高效率的遍历map
TreeMap底层结构和HashMap不同 HashMap底层是哈希表，TreeMap地城是
二叉树  TreeMap会根据key值来进行自然排序。 HashMap是哈希值相同
 如果两个对象内容相同，想把他两看做同一个对象的话，就就重写
hashCoda还有equals方法
TreeMap的自动排序，无法笔记自定义对象，
可以让1.实体类实现Comparable接口
重写CompareTo方法，进行比较，如果比较对象指定信息要打返回正数，
如果比该对象指定信息小，返回负数，如果相同返回0 ；
2.可以在构造集合的时候传入一个比较器comparator接口（匿名内部类）重写compare方法比较
方式和第一种相同  map：无序的，不可重复。 set集合 用法和list相同，
特征就是去掉了value的map set :无序，不可重复。
独立的窗体对象Frame 默认不可见 需要使用setVisible（true)方法修改






set CloseOperation(JDialog.DISPOSE_ON_CLOSE);
设置用户在此窗体上发起 "close" 时默认执行的操作。必须指定以下选项之一：
DO_NOTHING_ON_CLOSE（在 WindowConstants 中定义）：不执行任何操作；要求程
序在已注册的WindowListener 对象的 windowClosing 方法中处理该操作。
HIDE_ON_CLOSE（在 WindowConstants 中定义）：调用任意已注册的 WindowListen
er 对象后自动隐藏该窗体。
DISPOSE_ON_CLOSE（在 WindowConstants 中定义）：调用任意已注册 WindowListe
ner 的对象后自动隐藏并释放该窗体。
EXIT_ON_CLOSE（在 JFrame 中定义）：使用 System exit 方法退出应用程序。仅
在应用程序中使用。
默认情况下，该值被设置为 HIDE_ON_CLOSE。




//给按钮添加上的鼠标事件适配器
name.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e
name.addKeyListener(new KeyAdapter() {
@Override//键盘监听器
public void keyPressed(KeyEvent e) {


DAY17反射
反射是一种机制通过反射，我们可以在运行的时候再去确定类以及类当中的属性和
方法
提高了灵活性想要实现反射，就必须创建class对象， 创建class对象有三种方式：
//拿到反射对象对象.getClass()方法\
Class c1 = new People1().getClass();
Class c2 = People1.class;
//类名.class // Class.forName("文件路径"这一种最常用
Class c3 = Class.forName("类的路径");
类的路径是包名.class名
需要处理一个异常ClassNotFoundException
Class c3 = null;
try {
c3 = Class.forName("Day17.People1");
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
c3这样创建他是全局变量，在class中都能拿到
通过class对象创建实体类对象， 1无参数的 class对对象名.newInstances();
People1 p1  = (People1)c3.newInstance();
但是这样的写法会报出一个异常捕获 throws InstantiationException
2.有参数的 class对象名.getConstructor（参数）
构造函数里需要添加指定数据类型的class对象，可之后调用Constructor对象的
newInstances（）方法其中会报出 IllegalArgumentException InvocationTarge
Exception
获取所有属性 class对象.getDeclaredFields();返回一个filed类型的
数组， 该数组包含类但中的所有属性 ， field [] arr= c3 getDeclaredFields();
for (Field field : arr) {
System.out.println(field);
}
getType()方法可以返回该属性数据类型所对应的class对象
getName()方法可以返回该属性所对应的对象名
Constructor c = null;
People1 p2 = null;
try{
c = c3.getConstructor(String.class,int.class);
p2 = (People1)c.newInstance("小名",12);
}catch(IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}catch (NoSuchMethodException | SecurityException e) {
e.printStackTrace();
}
导入这个包import java.lang.reflect.Field;
获取单个属性 Field f = class 对象.getDeclaredField("属性名");
暴力反射 可以获取私有的属性，不建议使用
f.setAccessable(true); 获取对象的属性值 f.get(实体类对象名)
设置对象的属性值 f.set（实体类对象,"值"）;
获取单个方法：
Method method = class对象名.getMethod（"方法名",null）;null代表没有参数
method.invoke(对象名.null)
Method method2 = class对象名.getMethod("方法名",String.class)；
代表该方法有一个String类型的参数 method2.inovke(对象名,"张三")；
15章多线程
什么是线程，什么是进程
进程是由线程构成的，一个进程当中，至少有一个线程。
多线程 指的是在单个程序中可以同喜运行多个不同的线程执行不同的任务。
java也是多线程的 finalize（）java的垃圾回收器线程当某个对象不会在被调用时
触发的 线程的特点：1并发性 以毫秒为单位，在多个任务之间进行切换
2不定向性 多个线程争抢资源是随机的，线程的优点：解决了多个程序同时运行的
问题，缺点程序开多了，会影响效率。 java提供了一个线程类叫做Thread，可以执
行多线程操作 创建线程类第一种方式：继承Thread ，重写run方法
Thread类包含的方法 setName()设置线程名称，getName()获得线程名称
如果这里的setName()和getName()不设置名字会用到Thread-n，n从0开始
start()开始执行线程的run方法
sleep（1000）以毫秒为单位让线程休眠， 需要捕获线程被打断错误
另一种开启多线程的方式， 实现Runable接口 重写run方法 在创建对象时
currentThread()获取当前的线程对象  必须要创建Thread对象才可以开启
毕向东   马士兵
线程同步  如果不同步，会出现资源多次使用，比如卖票就会出现票数为0的情况
实现线程同步，两种方法 1同步方法，2同步代码块 同步方法是使用 修饰符
synchronized修饰在访问修饰符后，返回值前 
同步代码块 synchronized(任意对象){要同步的代码}


Day18 Enumeration e = h.elements(); 
while(e.hasMoreElements()){
system.out.println(e.nextElement());
}
线程类：
线程状态有四种
就绪：线程对象new出来后 调用start()之前 
运行：调用了start之后
阻塞：因为某些原因无法运行，如sleep wait 或者被同步后
死亡：run方法运行完毕或线程被打断
不用记interrupt和stop()因为过时了
线程通信：同步代码块，同步方法同上一章
wait()让该线程进行等待，会释放资源锁。
notify()唤醒正在等待的线程，由阻塞状态进入到运行状态。
notifyAll()唤醒正在等待所有线程。
死锁：两条线程在同步时，都拿到了一部分一方想要的资源，而在等待另一方释放资
源的过程。


线程会用到的方法 
yield()不能保证100%有效
join（） 等待该线程终止  sleep() 线程休眠 start() 开始线程调用run方法  setName(String) 改变线程名字  wait() 等待


sleep方法不会放锁
wait notify notifyAll方法执行后
或者run方法执行完毕后可以放锁


Day20
IO流
File类包含了可以对文件进行基本操作和获取文件信息，但是不能获取文件中的内容
包含方法：
File流构造方法:
File(String directoryPath)
File(String directoryPath,String filename)
File()


//创建一个新文件
file.createNewFile();
//创建一个新的文件夹
file.mkdir();
返回文件名 getName();
返回上级路径类型是String getParent(); getParentFile()返回上一级文件路径类型是File
返回绝对路径 getAbsolutePath() 判断文件是否存在 exists()
返回一个File类型的数组，遍历文件夹返回文件夹内的所有File对象
返回的是字符串的数组 file.listFiles() "是否是文件?"+file.isFile() 
是否是文件夹?"+file.isDirectory()   "返回文件大小（以字节为单位）"+file.length()  删除文件  //file.delete();    File.separator 代表\ 路径用一个/和//都行


递归算法 
程序方法中，在自身当中调用自身方法的算法叫做递归运算
使用递归时，一定要有一个跳出递归的条件，否则方法没有意义并且浪费大量资源
/*
字符流
抽象类 :Reader Writer  
FIleReader:
用于读取字符流的类 包含两种构造方法， FileReader fr = new FileReader();
FileReader fr2 = new FileReader(String src);
主要包含读取方法read() 如果读到结尾没有数据，返回-1
FileWriter，用来写入字符串的类，构造方法和FileReader类似，但是可以添加一个
布尔类型的参数，代表文件是否续写，默认是false
写入的方法write()把数据写入到了缓冲区当中，需要调用flush方法将缓冲区的数据写入到文件内，其中close方法会自动调用flush方法。
如果想要换行：System.getProperty("line.separator") line.separator等价于 \n;
获得系统的关键：system.getProperty(); static fianl String CHANGELINE  
从缓冲区当中读取文本，大大提高了效率，
构造方法:  BufferedReader br = new BufferedReader(Reader 对象);
提供了readLine()一次读取一行，读到末尾返回null。 
System.currentTimeMillis() 可以用来创建在两个函数的执行前和执行后，用来获取
函数执行所花费的毫秒数。
文件当中换行就是newline()在BufferedWrter:写入文本 提供了一个文本提供换行


字节流：
FileInputsystem 从文件系统中的某个文件中获得输入字节
获得输入字节，每读到一个字节，就返回一个字节，所以说不能够处理文字类的内容
普遍应用于音频视频的传输,效率较高 用法和Read类相同
以后全部用字节流来操作数据 字符流 不能用来复制图片， 
FileOutputStream 文件输出流适用于将数据写入File 或 FileDescriptor的输出流。
获得输出字节和 FileReader用法完全相同
字节流的缓冲区 BufferedInputStream(输入)    BufferedOutputStream (输出)
无论是字节流还是字符流加上缓冲区后，效率会提升很多。
*/
Day21严重掉课程 需要时间去记忆代码用法格式熟练掌握
转换流
InputStreamReader/OutputStreamWirter
封装了字节流的字符流 可以根据指定编码格式通过码表对照 读取字符，从而做好使用字节流
去操作文本。构造方法 InputSteamReader(字节流对象,编码格式) OutputStreamWriter(字节流对象,编码格式) 如果不显示声明编码格式，会使用系统默认的编码格式 
读写方法和字节流相同


打印流 
PrintSream 永远不会抛出IO异常 提供了 print pritln可以向
PrintStream ps = new PrintStream(字节输出流对象，是否自动刷新,编码格式);


ByArrayInputStream /ByteArrayOutputStream
使用流的方式去操作数据 该流不需要关闭


ByteArrayInputStream bais = 
new ByteArrayInputStream(arr);
ByteArrayOutputStream baos = 
new ByteArrayOutputStream();




读写方式和inputStream相同
ByteArrayOutputStream 包含WriteTo方法 可以将字节输出流写入到一个文件当中
baos.writeTo(new FileOutoutStream("E://333.txt"));
DataInputStream/DataOutputStream 提供了多种输入方式的字节流 注意在读取的时候
要保证顺序一致。
DataInputStream/DataOutputStream 提供了多种输入方式的字节流，注意在读取的时候要保证


ObjectOutputStream/ObjectInputStream 将对象以流的形式保存到文件中(序列化) 或将文件中的对象以流的形式读取出来（反序列化） 实现序列化和反序列话的条件是实体类必须实现
Serializable接口，该接口没有抽象方法，是一个标记接口通过wrtieObject(p)存入
通过readObject()读取  创建 r 和 rw 
RandomAccessFile随机访问文件的读取和写入既提供了read方法也提供了write方法
构造方法：
RandomAccessFile raf =  new RandomAccessFile("D://12.txt","rw/r");
rw:读写 r:只读  如果寄信写入操作-就会报出IO异常  seek(字节数)设置节点
如果设置了节点 ，该流就会把节点当作文件的起始位置， getFilePointer()获得节点的位置


自定义缓冲区
byte arr[] = new Byte [1024];
字节流：声明一个byte类型的数组代表缓冲区
调用read方法是，把数据读到缓冲区内 调用write方法时，从缓冲区那数据些fos.write(arr,0,arr.length)
字符流：要声明一个char类型的数组




Day22又迟到了，早点来，
ip地址： ipv4协议 32位二进制组成 用十进制表示 取值范围 0~255 在同一个局域网下，不可能出现相同的ip如192.168.1.80 代表本机的IP 127.0.0.1
InetAddress InetAddress.getByName("ip地址")。 java提供了关于ip的工具类InetAddress
该类无法实例化，要通过单利模式返回对象， getHostAddress()返回IP值，（字符串形式）
getHostName()返回电脑名， cmd查询IP ipconfig 端口 端口号用来表示计算机上的应用程序
可以多个程序共享一个端口好，但是同一时间内，只能运行一个端口号相同的程序
否则，后开的程序，会顶掉之前的程序 端口的取值范围0~65535 0~1024是系统给预留的端口，
尽量不要使用。查看端口号  netstat -nao FilenameFilter这个接口下面有个accept（file，String）测试指定文件是否应该包含在某一文件列表中。
TCP协议 UDP协议
需要建立连接 不需要建立连接
三次握手连接 1.效率较高
2.TCP效率较低 每次传输建议不超过1k
原因1 建立连接会花费时间
原因2 必须保证连接不会中断
会不断查看连接状态
3.可以传输大量数据
建立UDP连接 


DatagramSocket 这个类用来发送和接受数据包
DatagramPacket 这个是数据包  常用的 DAtagramPacket(btye[] buf)
发送端 


接受端


BufferedReader br = 
建立TCP/IP连接 
severSecket 实现此类服务器的套接字
服务器


客户端