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 实现此类服务器的套接字
服务器


客户端

你可能感兴趣的:(Java)