java基础学习总结

最新推荐文章于 2022-05-22 14:39:29 发布

starsky20

最新推荐文章于 2022-05-22 14:39:29 发布

阅读量4.8k

点赞数

文章标签： java string class thread exception regex

本文链接：https://blog.csdn.net/seashouwang/article/details/7879632

版权

Java 学习基础知识

一．JAVA 基构架包括：

1. JAVAEE ,企业版，主要用于企业环境的开发和应用。

2. JAVASE, 标准版，主要用于桌面制作和低端商务以用程序。

3. JAVAME，小型版，主要用于小分产品和嵌入式设备。

4.计算机语言的分类：

低级语言：最底层的01指令

汇编语言：提供了比较丰富的计算机指令的集合

高级语言：c / java

5. java的发展：

sun公司于1995年5月23开发出来的。

1996,1997 jdk1.0,1.1版本

2004,9.30 18:00 推出j2se

2009.4.20 被Oracle公司收购。

2010.9 Jdk1.7

java之父詹姆斯.高斯林，标志：一杯咖啡

6 .java语言体系：

javaSE：主要是桌面应用程序的开发，桌面应应用程序：即需要有安装和窗口的程序如：qq

javaEE：主要应用于WEB应用程序的开发（开发网站）

Web页面应用程序:使用浏览器打开的应用程序。

javaME：主要应用于手机开发

java下载工具：http://www.orcale.com

JDK: Java Developer Kit java开发工具集

JRE: java Runtime Environment java运行环境

bin：主要包含的是开发工具

demo：主要包含的是java语言的示例

include：主要包含开发所需要的操作系统的一些信息

jre：主要包含java程序运行需要的类

lib：主要包含的是java程序编译所需的类

sample：主要包含一些典型的小例子

7. java语言的特点：

1.开源性：open sources

2.跨平台型

3.一次编写到处运行

二，JAVA 环境的设置和程序的安装;

１，JAVA　程序的安装下载地址:（ｗｗｗ．ｓｕｎ．ｃｏｍ）．

２．JAVA 环境的设置:

一般设置情况，path环境变量的设置即可，此设置可以整个用户使用，设置方法，在我的电脑——》高级——》环境变量——》path ——》变量值的设置，

永久设置：java=_home=d:\jdk1.7\bin

临时设置：

set path=jdk的安装目录。

设置class path 环境变量：

class path 用来指定class文件的路径。

class path=d:\

注意在设置class path环境变量时，如果该路径后没有加分号，系统在寻找该class文件时会在指定目录中寻找，如果指定目录中没有，

系统不会在当前目录中寻找。所以一定要加分号。

环境变量不区分大小写。

如下图:

变量值的设置：即就是路径的设置，（此处自己选择，想设置在C, D , E , F 盘都可以），在设置的过程中一定不要改变原有的设置路径，只需要在最前面加上我们所需要的设置的路径即可（如：设置D盘 D:\Program Files\Java\jdk1.7.0\bin；然后选择确定即可），这事还没有完成，我们要在DOS 窗口查看是否正确，

开始——》运行—》cmd ——》set——》查看是否正确。

dos窗口：

cmd ：进入dos窗口

md：创建目录　　　　　　　　rd：删除目录

cd：进入指定目录　　　　　　 cd．．：退回到上一目录

cd／：退回到跟目录

dir：列出当前目录下的文件和文件夹。

三，Java的组成：

1. 关键字: 不能当标示符使用

例如：

class Demo // 定义一个类，类名为 Demo

{

public static void main(String[] args) // 主函数

{

System.out.println(“hello word”); //输出打印

}

注：/*1.在定义一个类的同时必须有主函数。

2.如果类名为一个单词，则首字母必须大写，多个单词，每个单词的首字母必须大写 */

2. 标示符：不能以数字开头，不能是关键字

3. 注释：单行注释 // ，多行注释/* 注释语*/ ，文档注释 /**注释语*/

4. 常量：在程序运行的过程中，数据的值不可改变的称之为常量。

整数常量;

小数常量：

字符常量、；使用' '之间的数据。可以使一个字符，一个中文，

可以是一个空格。可以是转义字符 '\t' ,一个Unicode码值 '\u00054'.

布尔常量；用 false true 表示

字符串常量；使用" "之间的数据称之为字符串常量.

5.进制的转换：

十进制转化为二进制，除以2，反向取余数，直到商为零。

二进制转换成十进制按权位展开即可，即乘以100110（2）= 1*2(5)+1*2(2)+1*2(1)

同理：八进制，十六进制转换成十进制，依次按权位展开。

如：123(8) = 1*8(2)+2*8(1)+3*8(0)

54(16) = 5*16(1)+4*16(0)

十进制转化为八进制，十六进制：除以8，16.反向取余数，直到商为零。 A,常量：程序运行期间值不能发生改变的。

常量主要有，整形(short,int,long)，浮点型(float,double)，字符型(char)，布尔型（ture,false），字符串常量。

\r：表示回车，将当前位置移到本行开头。Window系统中，回车符是有两个字符表示 \r\n 。

\n: 表示换行

\t：制表符

\b: 退格符

\’：表示单引号

\’’：表示双引号

\\：表示单斜杠

B,变量：在内存中有固定的单元，用来存放数据，程序运行期间值发生改变。

6.语句;

6.1基本数据类型：

整型：

byte 代表一个字节 2bit -128--127 -2(7)--2(7)-1

short: 代表两个字节 16bit -2(15)--2(15)-1

int :代表四个字节 32bit -2(31)--2(31)-1

long : 八个字节 64bit -2(63)--2(63)-1

程序默认类型为int类型

字符型：两个字节 16bit

浮点型：

float: 四个字节 32bit

double: 八个字节 64bit

java程序中小数部分默认的为double类型

布尔型：代表四个字节或者一个字节

当是基本boolean型是四个字节

当是基本类型的数组时每一个boolean是一个字节

类型转换：强制类型转换，大类型转换为小类型

自动类型转换：小类型转换为大类型

6.2.java常见运算符：

算术运算符：+ - * / % ++ --

注：取于时的结果主要看第一个数（被除数）。

赋值运算符：= == += -= *= /=

比较运算符：> < >= <= !=

逻辑运算符：& | && || !

位运算符： & | ^ >> << >>>

逻辑移位：即无符号右移

&与&& 的区别，&两边都参与计算，&&如果左边为 flase，则不计算右边

运算符的优先级：

. [ ] () {}

++ , -- ,~,!

*, /, %

+ , -

<< , >>, >>>

==, !=

=, *=, /=, %=, +=, -=, <<=, >>=, >>>=, &=, ^= , |=

A. 移位运算符（<< 左移，>> 右移，>>>无符号右移,~异或，^取反）

6.3.比较运算符：< <= > >= != ==

1.比较运算符的结果一定是boolean类型，true 或者false

2.较运算符比较的数据类型要一致，char,byte,short比较时类型会自动提升为int

3.整数和浮点数也可以比较

4.double类型的不可以比较，会损失精度。

6.4.逻辑运算符：用于一连串的比较，结果是true或者false

& 两边的都为true时，结果为true，负责有一边为false结果都为false

&& 短路与，当第一个比较的运算结果为false时，忽略第二个运算的比较

| 两边的比较运算都需要做比较。只要运算的结果又一个为true时，结果为true

|| 短路或，当第一个比较的运算结果为true时，忽略第二个运算的比较

！仅作一个比较，非真，即为假。非假，即为真。

^(异或) 两边相反时，结果为true,相同时为false

逻辑运算符：主要用于连接多个比较运算符。

结果也是boolean类型 true 或者 false,在为运算运算过程中都是以二进制计算，即0或者1.

6.5. 位运算符：

& | ^

码值：

原码：就是一个数的二进制表现形式。

反码：给每一位取反后的值。

补码：就是在反码的基础上加1（此处的加1是指1的二进制形式，如：一个字节表示：0000 0001）

补码求原码：

1，正数的原码就是补码。

2.负数的原码：给补码在求反一次加1.

注：补码在内存中主要是负数的存储方式。他的最高位为1（1代表符号位），而正数的最高位为0(即符号位)。

总结规律：

当三个数连续进行^ 而且有连个数相同, 那么结果一定等于那个不同的数据。项目中可以利用该规律进行高效的数据交换

例1:

class Demo6

{

public static void main(String[] args)

{

操作数1 操作数2 结果将true = 1 false = 0

1 1 1

1 0 0

0 0 0

0 1 0

练习： 6 & 8

分析：

0000 0110 6

& 0000 1000 8

-------------------

0000 0000 0

0000 0101

& 0000 0111 7

--------------------

0000 0101 5

System.out.println( 6 & 8 );

System.out.println( 5 & 7 );

操作数1 操作数2 结果将true = 1 false = 0

1 1 1

1 0 1

0 0 0

0 1 1

0000 0110 6

| 0000 1000 8

----------------

0000 1110 8+4+2 = 14

System.out.println( 6 | 8 );

System.out.println( 7 | 15 );

操作数1 将true = 1 false = 0

1 0

0 1

~ 0000 1000 8

------------

1111 0111 负数补码

1000 1000 取反

+ 0000 0001 +1

------------

1000 1001 -9

1000 0110 -6的原码

1111 1001 -6的反码

+ 0000 0001 1的原码也是补码

------------------------------------

1111 1010 -6的补码

1000 0101 -6的补码的反码

+ 0000 0001 1的补码

------------------------------------

1000 0110 -6的原码

总结规律：

正数的~ = 正数+1 并将符号翻转 ~90 = -（90+1） = -91

负数的~ = 负数+1 并将符号翻转 -6 = -（-6+1）= 5

byte a = -6;

System.out.println( ~8 );

~ 1111 1010 -6的补码

-----------

0000 0101 5

System.out.println( ~-6 );

System.out.println( ~-48 );

操作数1 操作数2 结果将true = 1 false = 0

1 1 0

1 0 1

0 0 0

0 1 1

0000 0110 6的原码补码

^ 0000 0111 7的原码补码

--------------

0000 0001 原码 1 补码形式

总结规律：

当三个数连续进行^ 而且有连个数相同, 那么结果一定等于那个不同的数据。项目中可以利用该规律进行高效的数据交换。

6.6. 算术移位：

移位：

左移：在左移的过程中数值会增大，如果所要移动的数是2的幂数时，即2（n）,2的n次方。

此时使用所要移动的数乘以2(n)，即(乘以2的幂数，n代表移动的位数)。如果不是2的幂数，此方法不能使用。

右移：在右移的过程中数值会减小，如果所要移动的数是2的幂数时，即2（n）,2的n次方。

此时使用所要移动的数除以2(n)，即(除以2的幂数，n代表移动的位数)。如果不是2的幂数，此方法不能使用。

逻辑移位：

>>>

即无符号右移，不管是正数还是负数在移位的过程中最高位都是补零。

交换两个数的方法1：通常是定义第三方变量用于存储数据，然后进行交换。

int x = 45;

int y = 89;

int temp = x;

x = y;

y = temp;

//Method 2: 将x与y装在一个容器中，即y这个比较大的容器

y = y+x; //将x装入y中

x = y-x; //通过x与y之和后的y减去x(即这时y中存储的是x)

y = y-x; //使用x+y之和减去y中存储的x，这是x中只剩下y

//Method 3: 使用取反操作

x = x^y;

y = x^y; // x^y^y = x

x = x^y; // x^y^x = y

}

6.7. 优先级：

自增和自减的优先级和()同级

7.JAVA中的流程控制语句：

1.顺序语句：按照一定的顺序执行代码。

2.判断语句：按判断的结果来执行

方式1：

if( 判断条件 ){ 如果条件满足。执行该代码 }

方式2：

if( 判断条件 ){ 如果条件满足。执行该代码 }else{ // 不成立执行该代码 }

方式3：

if( 判断条件1 ){}else if( 判断条件2 ){} else if( 判断条件3 ){}...else{}

备注：判断条件： boolean 比较元算符逻辑运算符.

在使用if语句时，如果if的语句后没有写{}，此时if语句执行的是离他最近的语句。为了避免代码混乱，最好书写清楚。

例1:

class Sentence

{

public static void main(String[] args)

{

int a = 78;

int b = 65;

if(a > b)

{

System.out.println(a);

}

System.out.println("Hello World!");

}

3.选择语句: 按照选择进行执

class Demo3

{

public static void main(String[] args)

{

int month = 34;

switch(month)

{

case 12:

case 1:

case 2:System.out.println("冬季");// break;

case 3:

case 4:

case 5:System.out.println("春季"); break;

case 6:

case 7:

case 8:System.out.println("夏季"); break;

case 9:

case 10:

case 11: System.out.println("秋季"); break;

default:

System.out.println("输入错误，请检查");

}

实验总结：当输入的选项满足switch语句时，首先执行switch内部的case语句,然后结束整个语句。

当输入的选项不满case语句时，首先先执行case语句，再执行default语句。

如果default语句没有放在最后，而是case语句之前，则需要执行case语句，然后通过break语句或者大口号（}）结束整个语句。

关键字：

switch ：用于输入用户的选择

case ：代表一个选项

break ：代表选择结束 switch语句的结束｝也可以终止选择

执行原理：

先执行case语句，再执行default语句。

使用switch做选择时必须要注意：

1. 用的选择只能是如下数据类型：

byte 、 short 、 char 、 int 、枚举

注意问题：

判断语句和选择语句

if ----> switch 成绩的等级不是所有的都可转

swicth ----> if 完全可以

实际开发中：

原则：能够使用switch实现的，优先使用switch case语句

优点：

1. 结构比较清晰

2. 效率高，所有的选项内容会提前进入内存

4. 循环语句：按照循环的次数进行重复执行

循环方式1：

while( 循环的条件 )

{

满足条件重复执行

}

方式2： do while

do{

需要重复的代码

}while( 循环的条件 );

总结：

while和do while和相互转换，但是不同的是do while至少要执行一次。

for(条件初始化语句;循环条件;循环后语句)

{

需要执行的代码；

}*/

条件初始化语句：主要用于初始化变量。

循环条件语句：比较运算符和逻辑运算符。

循环后语句：使得初始化变量循环一次之后发生变化。

for循环运行原理：

for( 1;2;3 ){

// 4

}

顺序：

1243

243

初始化语句永远只是执行一次。

例2;

class ForSentence

{

public static void main(String[] args)

{

for(int x=0;x<9;x++)

{

System.out.println("x="+x);

}

System.out.println(x);

}

/*ForSentence.java:21: 错误: 找不到符号

System.out.println(x);

符号: 变量 x

位置: 类 ForSentence

1 个错误

总结：1.通过实验可以的知：在for循环语句中定义的局部变量，仅在for语句中有效，当for循环语句执行完毕

，将释存储放空间。如果在循环该语外访问该变量，该变量已经不存在。

例3;

class Demo4

{

public static void main(String[] args)

{

int x=0;

for( ;x<9;)

{

System.out.println("x="+x);

//x++;

}

System.out.println(x);

}

结论：1.在for语句中，如果初始化的变量定义在for循环体的外面(即全局变量)，此时可以被其他成员访问。

2.for循环语句中的初始化语句可以为空

3.for循环语句中的循环后需要执行的语句可以为空，但是一定要在{}执行代码中写上，

如果没有循环后需要执行的语句，会出现死循环。

4，for语句中的所用语句为空时，此时处于死循环。

循环控制语句： break, continue的用法

break: 主用用于停止循环或着选择语句，

适用范围：循环语句，选择语句。

continue：主要用于控制循环体，是循环继续执行下一次，并不能结束整个循环。

适用于：循环语句

class Demo4

{

public static void main(String[] args)

{

int x=0;

for( ;x<9;)

{

System.out.println("x="+x);

//x++;

}

System.out.println(x);

}

结论：1.在for语句中，如果变量定义在for循环的外面，此时可以被其他方法访问。

2.for循环语句中的初始化语句可以为空

3.for循环语句中的循环后需要执行的语句可以为空，但是一定要在{}执行代码中写上，

如果没有循环后需要执行的语句，会出现死循环。

4，for语句中的所用语句为空时，此时处于死循环。

代码块和变量的作用域

代码块：使用{}将相同功能的代码包含起来，那么这个{}内的称之为代码块。

特点：

1，代码块后面不要使用分号(;)，通知编译器结束语句。

2，代码块是按照顺序依次执行。

五：流程控制

顺序结构

选择结构

循环结构

1.if(条件表达式)

语句；

例2. if(条件表达式)

语句1；

else if(条件表达式)

语句2；

else

语句3；

class ifexpression

{

public static void main (String[] args)

{

int val=75;

if(val>90)

System.out.println("优秀");

if(val>70 && val<80)

System.out.println("良好");

if(val<60)

System.out.println("努力");

}

例3：switch(常量表达式)

case常量表达式1: 语句1；break；

case常量表达式2: 语句1；break；

case常量表达式3: 语句1；break；

default: 语句n；

六：数组

1. 一位数组的定义方式：

元素类型 [ ] 数组名= new 元素类型[元素个数或数组长度 ]；

例：int arr [ ]=new int[ ]{1,2,3,4,5} ;

元素类型 [ ] 数组名={元素 } 例：Int arr[ ]={3,2,4,5} ;

注：/*1.输出打印部分，使用”+”，主要作用是字符窜之间的连接

2. “ “ （双引号）的用法：不发生改变的放在引号中间，改变的放在引号外，并两个字符串之间用”+”连接 */

函数调用方法：

class Demo

{

public static void main(String[] args)

{

int arr[]={3,5,6,2,8};

printArr(arr);

}

public static void printArr(int arr[])

{

for(int i=0;i<arr.length;i++)

System.out.println("i="+i+","+"arr["+i+"]="+arr[i]+";");

}

//对一位数组中的元素排序

class NumberDemo

{

public static void main(String[] args)

{

int a[]={20,10,50,40,30,70,60,80,90,100};

sort(a);

sop(a);

}

public static void sort(int arr[])

{

for(int x=0;x<arr.length-1;x++)

{

if(arr[x]>arr[x+1])

{

int temp=arr[x];

arr[x]=arr[x+1];

arr[x+1]=temp;

}

public static void sop(int a[])

{

for(int i=0;i<a.length;i++)

{

System.out.println("a["+i+"]="+a[i]);

}

} */

//练习二：乘法表

class chengFaDemo

{

public static void main(String[] args)

{

chengFa();

}

public static void chengFa()

{

for(int i=1;i<10;i++)

{ for(int j=1;j<=i;j++)

{

sop(i,j);

}

System.out.println();

}

public static void sop(int x,int y)

{

System.out.print(x+"*"+y+"="+x*y+"\t");

}

例 2：

比较数组中的数字，并找出最大值和最小值

class Demo

{

public static int getmax(int arr[])

{

int max=arr[0];

for(int i=1;i<arr.length;i++)

{ if(arr[i]>max)

max=arr[i];

}

return max;

}

public static int getmin(int arr[])

{

int min=arr[0];

for(int i=1;i<arr.length;i++)

{ if(arr[i]<min)

min=arr[i];

}

return min;

}

public static void main(String[] args)

{

int arr[]={3,5,6,2,8,7};

int max=getmax(arr);

System.out.println("max="+max);

int min=getmin(arr);

System.out.println("min="+min);

}

例3;

// 查找数组下标所对应的元素

class ArrTest

{

public static void main(String[] args)

{

int arr[]={3,6,2,8,1};

int index=getIndex(arr,2);

System.out.println("Index="+index);

}

// 获取key第一次出现的数，如果不是返回子为-1 ，则key不在数组中

public static int getIndex(int arr[],int key)

{

for(int i=0;i<arr.length;i++)

{ if(arr[i]==key)

return i;

}

return -1;

}

例4：

// 折半查找，可以提高效率，但是比须是有序的的数组

class ArrTest

{

public static void main(String[] args)

{

int arr[]={4,7,8,24,45,67};

int index=halfSearch(arr,3);

System.out.println("Index="+index);

}

public static int halfSearch(int arr[],int key)

{

int min=0,max=arr.length-1,mid;

while(min<max)

{

mid=(max+min)>>1;

if(key>arr[mid])

min=mid+1;

else if(key<arr[mid])

max=mid-1;

else

return mid;

}

return -1;

}

public static int halfSearch(int arr[],int key)

{

int min,max,mid;

min=0;

max=arr.length-1;

mid=(min+max)/2;

while(arr[mid]!=key)

{

if(key>arr[mid])

min=mid+1;

else if(key<arr[mid])

max=mid-1;

if(min>max)

return -1;

mid=(min+max)/2;

}

return mid;

}

例5：

//有一个有序的数组，将一个元素插入到数组中，并保证数组还是有序的。

// 折半查找，可以提高效率，但是比粗是有序的的数组

class ArrTest

{

public static void main(String[] args)

{

int arr[]={4,7,8,24,45,67};

int index=halfSearch(arr,3);

System.out.println("Index="+index);

}

public static int halfSearch_2(int arr[],int key)

{

int min=0,max=arr.length-1,mid;

while(min<max)

{

mid=(max+min)>>1;

if(key>arr[mid])

min=mid+1;

else if(key<arr[mid])

max=mid-1;

else

return mid;

}

return min;

}

例6：

// 第一种：十进制转换为二进制

class ArrTest

{

public static void main(String[] args)

{

toBin(6)

}

public static void toBin(int num)

{

while(num>0)

{

System.out.println(num%2);

num=num/2;

}

// 第二种：十进制转换为二进制

class ArrTest

{

public static void main(String[] args)

{

toBin(6);

}

public static void toBin(int num)

{

StringBuffer s = new StringBuffer();

while(num>0)

{

s.append(num%2);

num=num/2;

}

System.out.println(s.reverse());

}

第三种：十进制转换为二进制

class ArrTest

{

public static void main(String[] args)

{

toBin(60);

}

public static void toBin(int num)

{

char chs[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

char arr[] = new char[8];

int pos=arr.length;

while(num!=0)

{

int temp = num & 1;

arr[--pos] = chs[temp];

num = num>>>1;

}

for(int x=pos;x<arr.length;x++)

{

System.out.println(arr[x]);

}

2: 十进制转换为十六进制

int n = num & 15;

n1-10+'A';

int temp=num>>>4;

temp&15;

// 第一种：十进制转换为十六进制

class ArrTest

{

public static void main(String[] args)

{

toHex(6);

}

for(int x=0;x<8;x++)

{

int temp=num&15;

if(temp>9)

System.out.println((char)(temp-10+'A'));

else

System.out.println(temp);

num=num>>>4;

}

// 第2种：十进制转换为十六进制

class ArrTest

{

public static void main(String[] args)

{

toHex(60);

}

public static void toHex(int num)

{

char chs[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

char arr[] = new char[8];

for(int x=0;x<arr.length-1;x++)

{

int temp = num & 15;

// System.out.println(chs[temp]);

arr[x]=chs[temp];

num = num>>>4;

}

for(int x=0;x<arr.length-1;x++)

{

System.out.println(arr[x]+",");

}

// 第三种：十进制转换为十六进制

class ArrTest

{

public static void main(String[] args)

{

toHex(60);

}

public static void toHex(int num)

{

char chs[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

char arr[] = new char[8];

int pos=arr.length;

while(num!=0)

{

int temp=num&15;

arr[--pos]=chs[temp];

num=num>>>4;

}

for(int x=pos;x<arr.length;x++)

{

System.out.println(arr[x]);

}

2. 二维数组：

定义方式1：元素类型数组名 [ ][ ]=new 元素类型[数组长度 ] [数组长度];

例： IInt arr[ ] [ ] =new int [2 ][3 ] 相当于两个一维数组

arr[0]=new int[3]; arr[1]=new int[3]

定义方式2：元素类型数组名 [ ][ ]= { 元素}；

例：Int arr[ 3][ ]={{1,2,3},{4,5},{7}};

相当于三个一维数组：arr[0]={1,2,3} ; arr[1]={4,5}; arr[2]={7};

注：数组中第二个中括号中不写元素的个数，这样方便操作，因为我们在定义数组的时，数组中的元素如果太多，在定义是困难.

例1：将数组中的元素按大小顺序排列

classCompaer

{

public static void main(String[ ] args)

{

int arr[ 2][ 4]={5,3,2,0,6,8,2,9};

Arrprint(arr);

forXuhuan(arr);

forTo(arr);

Arrprint( arr);

}

/* 选择发排序 */

public static void forTo(int arr)

{

for(int i=0;i<arr.length-1;i++)

for(j=1;j<arr.length;j++)

If(arr[i]>arr[y])

{

int temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

/* 冒泡法排序*/

public static void forXuhuan(int arr)

{

for(int i=0;i<arr.length-1;i++)

for(j=1;j<arr.length-i;j++)

If(arr[j]>arr[j+1])

{

int temp= arr[j];

arr[j]= arr[j+1];

arr[j+1]=temp;

}

public static void Arrprint(int arr)

{

for(int x=0;x<arr.length;x++)

{

If(x!=arr.length-1)

System.out.print(arr[x]+”,”);

else

System.out.println(arr[x]);

}

5.面向对象：

静态：static。

用法：是一个修饰符，用于修饰成员(成员变量，成员函数).

当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，

还可以直接被类名调用。类名.静态成员。

static特点：

1，随着类的加载而加载。

也就说：静态会随着类的消失而消失。说明它的生命周期最长。

2，优先于的对象存在

明确一点：静态是先存在。对象是后存在的。

3，被所有对象所共享

4，可以直接被类名所调用。

实例变量和类变量的区别：

1，存放位置。

类变量随着类的加载而存在于方法区中。

实例变量随着对象的建立而存在于堆内存中。

2，生命周期：

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失

静态使用注意事项：

1，静态方法只能访问静态成员。

非静态方法既可以访问静态也可以访问非静态。

2，静态方法中不可以定义this，super关键字。

因为静态优先于对象存在。所以静态方法中不可以出现this。

3，主函数是静态的。

静态有利有弊

利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象中都存储一份。

可以直接被类名调用。

弊端：生命周期过长。

访问出现局限性。(静态虽好，只能访问静态。)

饿汉式:是先初始化对象。

Single类一进内存，就已经创建好了对象。

class Single

{

private static Single s = new Single();

private Single(){}

public static Single getInstance()

{

return s;

}

//对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。

//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。

class Single

{

private static Single s = null;

private Single(){}

public static Single getInstance()

{

if(s==null)

{

synchronized(Single.class)

{

if(s==null)

s = new Single();

}

return s;

}

//记录原则：定义单例，建议使用饿汉式。

class

{

public static void main(String[] args)

{

System.out.println("Hello World!");

}

// 继承：

class Fu extends Object

{

int num=5;

Fu()

{

System.out.println("NAME");

}

Fu(int x)

{

System.out.println("fu ...."+x);

}

class Zi extends Fu

{

Zi()

{

System.out.println("zi run");

}

Zi(int x)

{

System.out.println("zi..."+x);

}

class Person

{

public static void main(String[] args)

{

Zi z = new Zi(0);

System.out.println(z.num);

}

当子类继承父类，沿袭了父类的功能，到子类中，

但是子类虽具备该功能，但是功能的内容却和父类不一致，

这时，没有必要定义新功能，而是使用覆盖特殊，保留父类的功能定义，并重写功能内容。

覆盖：override

1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

2，静态只能覆盖静态。

记住大家：

重载：只看同名函数的参数列表。

重写：子父类方法要一模一样。（即函数名和参数列表）

3，子父类中的构造函数。

在对子类对象进行初始化时，父类的构造函数也会运行，

那是因为子类的构造函数默认第一行有一条隐式的语句 super();

super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();

为什么子类一定要访问父类中的构造函数。

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。

所以子类在对象初始化时，要先访问一下父类中的构造函数。

如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

注意：super语句一定定义在子类构造函数的第一行。

结论：

子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

因为子类每一个构造函数内的第一行都有一句隐式super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。

子类中至少会有一个构造函数会访问父类中的构造函数。

final : 最终。作为一个修饰符，

1，可以修饰类，函数，变量。

2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。

3，被final修饰的方法不可以被复写。

4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。

当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。

而这个值不需要改变，所以加上final修饰。

5.作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过_连接。

6，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

class Demo

{

final int x = 3;

public static final double PI = 3.14;

final void show1()

{}

void show2()

{

final int y = 4;

System.out.println(3.14);

}

class SubDemo extends Demo

{

//void show1(){}

}

class FinalDemo

{

public static void main(String[] args)

{

System.out.println("Hello World!");

}

抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象。因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

4.抽象类的出现提高了代码的复用性。让子类继承使用

6.抽象类中一定有构造函数。主要是给成员初始化。

* 优点：

* 1.提高代码的复用性。

* 2.强制子类实现父类中没有实现的功能

抽象类和一般类没有太大的不同。

该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。

这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。

通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。

抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

abstract 关键字，和哪些关键字不能共存。

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。

而抽象方法出现的就是需要被复写。

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。

可是抽象方法运行没意义。

abstract class Animal

{

String name = "huan huan";

public abstract void run();

public Animal()

{

System.out.println("父类构造函数");

}

class Dog extends Animal

{

public void run()

{

System.out.println("dog 跑......");

}

public class AbstractClass

{

public static void main(String[] args)

{

// TODO Auto-generated method stub

Dog d = new Dog();

d.run();

}

接口的特点：

1. 接口中定义的所有的属性默认是public static final的，即静态常量

既然是常量，那么定义的时候必须赋值。

2. 接口中定义的方法不能有方法体。接口中定义的方法默认添加public abstract

3. 有抽象函数的不一定是抽象类，也可以是接口类。

4. 由于接口中的方法默认都是抽象的，所以不能被实例化。

5. 对于接口而言，可以使用子类来实现接口中未被实现的功能函数。

6. 如果实现类中要访问接口中的成员，不能使用super关键字。因为两者之间没有显示的继承关系，

况且接口中的成员成员属性是静态的。可以使用接口名直接访问。*/

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

interface Inter

{

public static final int NUM = 3;

public abstract void show();

}

interface InterA

{

public abstract void show();

}

class Demo

{

public void function(){}

}

class Test extends Demo implements Inter,InterA

{

public void show(){}

}

为什么定义接口？主要是胡根据现实中事物的存在而定义个一种抽象事物，而该抽象的发法包含一类事物的共性，

此时就需要定义为一个接口，其他类如果需要该接口中的方法时，只能是实现该接口，实现其抽象方法，正在方法的方法体中

写上自己需要的执行代码即可。接口的出现主要是避免了继承的缺陷，在类与类之间只能是单继承关系，而类与接口之间可以多实现，

这样可以扩展类的功能，即增强类的扩展性。

instanceof关键字：该关键字用来判断一个对象是否是指定类的对象或者接口。属于比较运算符

用法：

对象 instanceof 类;

该表达式是一个比较运算符，返回的结果是boolea类型 true|false

多态：

1，多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系。要么继承，要么实现。

通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高程序的扩展性。

4，多态的弊端：

虽然提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5，多态的应用

6，多态的出现代码中的特点(多态使用的注意事项)

在多态中成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：非静态成员函数在多态调用时，编译看左边，运行看右边。

（简单的理解就是，在编译的时候看那父类中是否有调用的函数，如果没有，编译失败，如果有，编译通过。

运行时看子类中是否有调用的函数，如果没有，会调用父类中的函数）。

在多态中，成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：

无论编译和运行，都参考做左边。

第一种情况:

class A

{

public static int a = 1;

}

class B

{

public static int b = 2;

}

class C

{

public static int c = 3;

}

//情况2：

class A

{

public static int a = 1 + B.b;

}

class B

{

public static int b = 2 + C.c;

}

class C

{

public static int c = 3 + A.a;

}

/情况3错误

class A extends C

{

public static int a = 1 + c;

}

class B extends A

{

public static int b = 2 + a;

}

class C extends B

{

public static int c = 3 + b;

}

public class Test

{

public static void main(String[] args)

{

// 情况1的输出

//System.out.println( A.a + B.b + C.c );

// 情况2的输出

System.out.println( A.a + B.b + C.c );

// 情况3的输出

//System.out.println( A.a + B.b + C.c );

// 情况4 将以上3中情况的输出类变量的顺序加以任意改变参考结果

}

Static Nested Class 和 Inner Class的:

1. 成员内部类(成员属性、成员方法)

1.1 私有的成员内部类

特点：不能在其他类中直接创建内部类对象来访问

1.2 静态的成员内部类

特点：如果内部类中包含有静态成员，那么java规定内部类必须声明为静态的访问静态内部类的形式：

Outer.Inner in = new Outer.Inner();

1.3 匿名内部类

2. 局部内部类

包含在外部类的函数中的内部类称之为局部内部类。

访问：可以在包含局部内部类的方法中直接创建局部内部类的对象调用局部内部类的成员。

访问方式：

1.内部类可以直接访问外部类中的成员

2.外部类要访问内部类需要创建内部类的对象。

3.在外部类的成员位置上建立内部类对象可一直接访问内部类中的成员。

4.从内部类中访问本地变量; 需要被声明为最终类型

class Outer

{

int x = 4;

static class Inner

{

int x = 1;

public static void method()

{

//System.out.println(Outer.this.x);

System.out.println("成员位置内部类、、、");

}

public void show()

{

//Inner in = new Inner();

//in.method();

System.out.println("外部类方法");

}

//第二种；

public void InnerMethod()

{

final int x = 4;

class Inner

{

int x = 8;

public void print()

{

int x = 2;

System.out.println("x = " + x);

System.out.println("内部类定义在函数的内部");

}

Inner in = new Inner();

in.print();

}

public void out()

{

System.out.println("外部类方法"+x);

}

class Demo1

{

public static void main(String[] args)

{

//内部类在成员位置上的非静态访问方式；

/* Outer out = new Outer();

out.show();

Outer.Inner in = new Outer().new Inner();

in.method();

//静态访问方式

Outer.Inner in = new Outer.Inner();

in.method();*/

//第三种：内部类在函数的内部

Outer out = new Outer();

out.InnerMethod();

System.out.println("Hello World!");

}

匿名内部类：

1. 当成员内部类和外部的抽象类或接口有继承或者实现关系，那么可以直接使用匿名内部类进行代码的简化

2. 可以在外部类的成员函数中直接创建抽象类或接口的对象，只要在创建对象的同时使用{}重写或实现抽象类的方法或接口的未实现方法即可。

开发中的启示：

1. 任何类都可以new，只不过抽象类接口在new的时候需要使用{}同时实现未被父类实现的方法即可。

interface MyShape

{

int x = 4;

void print();

}

class Outer

{

int x = 9;

public void show()

{

final int x = 8;

new MyShape(){

public void print()

{

System.out.println(Outer.this.show());

System.out.println("匿名内部类的使用");

}

}.print();

}

public void show()

{

System.out.println("外部类方法");

}

class Inner implements MyShape

{

public void print()

{

int x = 3;

System.out.println(x);

System.out.println("内部类可以实现接口的");

}

Inner in = new Inner();

in.print(); */

}

class Demo4

{

public static void main(String[] args)

{

Outer out = new Outer();

out.show();

System.out.println("Hello World!");

}

/*结论：1.当内部类实现接口时，如果该方法中访问的变量本类没有，则会在父类中查找（接口名.变量名），

如果父类中没有，会出现异常。

2.内部类在继承接口和抽象类的时候，都可以通过new 关键字创建对象(即匿名内部类)，

只需要在对象后增加{}如：new person(){//复写父类的方法}; ，并在大口号中将父类中的方法复写.

3.匿名内部类简化了代码的书写，提高效率。*/

异常：Exception

实现方式一：

try{ // 可能发生异常的代码 } catch( 异常类的类型 e ){ // 当发生指定异常的时候的处理代码 }catch...

比较适合用于专门的处理异常的代码，不适合释放资源的代码。

实现方式二：

try{ } catch(){} finally{ // 释放资源的代码 }

finally块是程序在正常情况下或异常情况下都会运行的。

比较适合用于既要处理异常又有资源释放的代码。

实现方式三：

try{ }finally{ // 释放资源 }

比较适合处理的都是运行时异常且有资源释放的代码。

finally:关键字主要用于释放系统资源。

1. 在处理异常的时候该语句块只能有一个。

2. 无论程序正常还是异常，都执行finally。

自定义异常

运行时异常：

SecurityException 安全异常

IllegalArgumentException 无效的参数异常

ClassCastException 类的转型异常

IndexOutOfBoundsException 数组角标越界异常

ArithmeticException 算术异常

EventException

非运行时异常：

ClassNotFoundException 找不到类异常

FileNotFoundException 文件找不到异常

IOException 流异常

Error：

OutOfMemoryError 内存溢出错误

注意：1.在导包的过程import 一定不能放在package之上。否则编译报错。

2.一个类中可以导入多个包，导包方法：包名.类名，也可以使用：包名.*，

这虽然简化了代码的书写，但是如果一个包中有多个类的时候，这样会导致导入的其他没有使用到类，

浪费内存空间。建议使用，需要那个就导入那个类。

3.在编译的过程中使用方法：javac <options> <source files> 即：javac -d 目录存放位置源文件

运行时：java 包名.类名

通过包所在的路径访问包中的类：一般包放在哪我们就需要设置( set classpath)在这个路径下调用包中类的方法。

jar工具：主要用于对class文件进行打包(压缩)

jar工具压缩的文件后缀一定是： .jar( java active rar ) war( web active rar )

jar用法：

jar {ctxui}[vfm0Me] [jar-file] [manifest-file] [entry-point] [-C dir] files ...

示例 1：将两个类文件归档到一个名为 classes.jar 的归档文件中：

jar cvf classes.jar Foo.class Bar.class 压缩

示例 2：使用现有的清单文件 "mymanifest" 并将 foo/ 目录中的所有文件归档到 "classes.jar" 中：

jar cvfm classes.jar mymanifest -C foo/ .

jar的常见应用：

压缩： jar -cvf jar文件要压缩的文件

查看压缩信息 jar -tvf jar文件 [ > 重定向文件 ]

解压： jar -xvf jar文件

进程：是一个正在执行中的程序。

每一个进程执行都有一个执行顺序。该顺序是一个执行路径，或者叫一个控制单元。

线程：就是进程中的一个独立的控制单元。

线程在控制着进程的执行。

一个进程中至少有一个线程。

Java VM 启动的时候会有一个进程java.exe.

该进程中至少一个线程负责java程序的执行。

而且这个线程运行的代码存在于main方法中。

该线程称之为主线程。

扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

1,如何在自定义的代码中，自定义一个线程呢？

通过对api的查找，java已经提供了对线程这类事物的描述。就Thread类。

创建线程的第一种方式：继承Thread类。

步骤：

1，定义类继承Thread。

2，复写Thread类中的run方法。

目的：将自定义代码存储在run方法。让线程运行。

3，调用线程的start方法，

该方法两个作用：启动线程，调用run方法。

发现运行结果每一次都不同。

因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。

明确一点，在某一个时刻，只能有一个程序在运行。(多核除外)

cpu在做着快速的切换，以达到看上去是同时运行的效果。

我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。

这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长，cpu说的算。

为什么要覆盖run方法呢？

Thread类用于描述线程。

该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是run方法。

也就是说Thread类中的run方法，用于存储线程要运行的代码。

class Demo extends Thread

{

public void run()

{

for(int x=0; x<60; x++)

System.out.println("demo run----"+x);

}

class ThreadDemo

{

public static void main(String[] args)

{

//for(int x=0; x<4000; x++)

//System.out.println("Hello World!");

Demo d = new Demo();//创建好一个线程。

//d.start();//开启线程并执行该线程的run方法。

d.run();//仅仅是对象调用方法。而线程创建了，并没有运行。

for(int x=0; x<60; x++)

System.out.println("Hello World!--"+x);

}

什么是线程：线程是一个应用程序执行时候的多条路径。

java中的线程：

Thread ：线程

java.lang.*

实现:

创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。

该子类应重写 Thread 类的 run 方法。

线程执行的原理：

CPU + 代码 + 数据

thread1 main 进行抢占CPU资源

在物理上只有一个CPU的情况下，JVM是采用抢占CPU资源，给不同的线程划分指定执行时间片的方式来实现。

java中隐含的两个线程：

1. main函数 JVM main函数也称之为主线程

2. GC 是一个后台的线程( 自动升级 )

java中定义线程的模型：

1. CPU

2. 功能代码

3. 数据

线程的使用细节：

1. 线程的启动使用父类的start()方法

2. 如果线程对象直接调用run()，那么JVN不会当作线程来运行，会认为是普通的方法调用

3. 线程的启动只能由一次，否则抛出异常 (无效线程状态异常 IllegalThreadStateException )

4. 可以直接创建Thread类的对象并启动该线程，但是如果没有重写run()，什么也不执行。

5. 匿名内部类的线程实现方式

线程的创建方式：

1. 方式一：继承Thread类，并重写run()

1.1 共享数据的( 静态属性面向对象的单例 )

1.2 单继承

1.3 在加锁的时候很麻烦，需要进行区分使用的变量是否是静态的，如果是使用类的Class对象作为锁，

否则使用this作为锁。

创建线程的第二种方式：实现Runable接口

步骤：

1，定义类实现Runnable接口

2，覆盖Runnable接口中的run方法。

将线程要运行的代码存放在该run方法中。

3，通过Thread类建立线程对象。

4，将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数。

为什么要将Runnable接口的子类对象传递给Thread的构造函数。

因为，自定义的run方法所属的对象是Runnable接口的子类对象。

所以要让线程去指定指定对象的run方法。就必须明确该run方法所属对象。

5，调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

实现方式和继承方式有什么区别呢？

实现方式好处：避免了单继承的局限性。

在定义线程时，建立使用实现方式。

两种方式区别：

继承Thread:线程代码存放Thread子类run方法中。

实现Runnable，线程代码存在接口的子类的run方法。

class Demo8

{

public static void main(String[] args)

{

new Thread(new Runnable(){

public void run()

{

System.out.println(Thread.currentThread().getName()+"Runnable...........");

}})

{

public void run()

{

System.out.println("Thread.........");

}

}.start();

System.out.println("Hello World!");

}

/*匿名内部类

结论：如果执行线程时，即继承了Thread的run方法，又实现了Runnable的run方法时，执行的是Thread的run方法，

不是Runnable的run方法。*/

如果同步函数被静态修饰后，使用的锁是什么呢？

通过验证，发现不在是this。因为静态方法中也不可以定义this。

静态进内存是，内存中没有本类对象，但是一定有该类对应的字节码文件对象。

类名.class 该对象的类型是Class

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class

主线程和子线程交替运行

子线程先运行50次，在主线程运行100次，然后主线程和子线程交替运行。

例1:

class SonThread implements Runnable

{

boolean tag = true;

public void run()

{

for(int y=1;y<=50;y++)

{

synchronized(ThreadTest.class)

{

if(!tag)

{

try

{

ThreadTest.class.wait();

}

catch (Exception e)

{

}

for(int x =1;x<=50;x++)

{

System.out.println("子线程..... "+x);

}

tag = false;

ThreadTest.class.notify();

}

class ThreadTest

{

public static void main(String[] args)

{

SonThread s = new SonThread();

Thread t = new Thread(s);

t.start();

for(int y =1;y<=50;y++)

{

synchronized(ThreadTest.class)

{

if(s.tag)

{

try

{

ThreadTest.class.wait();

}

catch (Exception e)

{

}

for(int x =1;x<=100;x++)

{

System.out.println("主线程..... "+x);

}

s.tag = true;

ThreadTest.class.notify();

}

System.out.println("Hello World!");

}

例4:

/*单例设计模式的线程同步；*/

class Ticket

{

static int tick = 50;

private static Ticket ticket = new Ticket();

private Ticket()

{

}

public static Ticket getInstance()

{

return ticket;

}

public void setTic(int x)

{

this.tick = x;

}

public int getTic()

{

return this.tick;

}

class SellTick extends Thread

{

Ticket ticket = null;

public SellTick(Ticket ticket,String name)

{

super(name);

this.ticket = ticket;

}

public void run()

{

while(true)

{

synchronized(SellTick.class) //this

{

if(ticket.getTic()>0)

{

System.out.println(this.getName()+":买票"+ticket.getTic());

int num = ticket.getTic();

ticket.setTic(--num);

}

else

{

System.out.println("票已经售完，请明天再来"); break;

}

例5:

class Demo5

{

public static void main(String[] args)

{

Ticket ticket = Ticket.getInstance();

SellTick t1 = new SellTick(ticket,"1号");

SellTick t2 = new SellTick(ticket,"2号");

t1.start();

t2.start();

System.out.println("Hello World!");

}

例6:

package Itcast;

/*模拟一个软件的升级过程；*/

class UpdateVersion implements Runnable

{

public void run()

{

int i = 0;

while(true)

{

System.out.println(Thread.currentThread().getName()+"数据检索中。。。。。。。"+","+i++);

try

{

Thread.sleep(10);

}

catch (InterruptedException e)

{

//e.printStackTrace();

}

if(i == 100)

{

System.out.println(Thread.currentThread().getName()+"版本需要更新。。。。。"+i);

break;

}

public class Program

{

public static void main(String[] args)

{

// TODO Auto-generated method stub

UpdateVersion v = new UpdateVersion();

Thread t = new Thread(v,"迅雷");

t.start();

System.out.println("Hello World!");

}

例7:

死锁:

当多个线程同时获取多个共享资源时，有可能会发生死锁状态，死锁不可接触，只能在设计时人为地避免。

一下是通过连个不同的字节码文件对象作为锁。

class DeadLock implements Runnable

{

private boolean b;

DeadLock(boolean b)

{

this.b = b;

}

public void run()

{

if(b)

{

while(true)

{

synchronized(DeadLock.class)

{

System.out.println(Thread.currentThread().getName()+", "+"lock1");

synchronized(DeadLockTest.class)

{

System.out.println(Thread.currentThread().getName()+", "+"lock2");

}

else

{

while(true)

{

synchronized(DeadLockTest.class)

{

System.out.println(Thread.currentThread().getName()+", "+"lock2");

synchronized(DeadLock.class)

{

System.out.println(Thread.currentThread().getName()+", "+"lock1");

}

public class DeadLockTest

{

public static void main(String[] args)

{

DeadLock d1 = new DeadLock(true);

DeadLock d2 = new DeadLock(false);

Thread th1 = new Thread(d1);

Thread th2 = new Thread(d2);

th1.start();

th2.start();

System.out.println("Hello World!");

}

例8: 死锁。

同步中嵌套同步。

class Ticket implements Runnable

{

private int tick = 1000;

Object obj = new Object();

boolean flag = true;

public void run()

{

if(flag)

{

while(true)

{

synchronized(obj)

{

show();

}

else

while(true)

show();

}

public synchronized void show()//this

{

synchronized(obj)

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exception e){}

System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);

}

class DeadLockDemo

{

public static void main(String[] args)

{

Ticket t = new Ticket();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(Exception e){}

t.flag = false;

t2.start();

}

线程间的通信：

Lock(接口)锁的使用方法；

多线程中1.5版本，将同步锁替换为Lock操做。

将object中的wait(),notify(),notifyAll()去不替换为condition对象。

通过condition中的 await(),signal(),signalAll()方法唤醒等待的线程。

该对象可以通过Lock锁获取对象。

Condition newCondition()

返回绑定到此 Lock 实例的新 Condition 实例。

class Resoure

{

private boolean flag = false;

private String name;

private String sex;

private Lock lock = new ReentrantLock(); //常见Lock锁的子类创建对象

private Condition condition_cus = lock.newCondition(); //通过Lock锁获取condition对象

private Condition condition_pro = lock.newCondition();

public void setName(String name,String sex)

{

lock.lock();

try

{

while(flag)

{

try

{

condition_pro.await(); //判断标记并等待

}

catch (Exception e)

{

}

this.name = name;

this.sex = sex;

System.out.println(Thread.currentThread().getName()+ "生产者："+name+":"+sex);

flag = true;

condition_cus.signal();//唤醒消费者

}

finally

{

lock.unlock();//释放锁

}

public void getName()

{

lock.lock();

try

{

while(!flag)

{

try

{

condition_cus.await();

}

catch (Exception e)

{

}

System.out.println(Thread.currentThread().getName()+ "消费者.........："+name+":"+sex);

flag = false;

condition_pro.signal(); //唤醒生产者

}

finally

{

lock.unlock();

}

class Producer implements Runnable

{

private Resoure r;

Producer(Resoure r)

{

this.r = r;

}

public void run()

{

while(true)

{

r.setName("北极熊","雄仔");

}

class Customer implements Runnable

{

private Resoure r;

Customer(Resoure r)

{

this.r = r;

}

public void run()

{

while(true)

{

r.getName();

}

class LockTest

{

public static void main(String[] args)

{

Resoure r = new Resoure();

Producer p = new Producer(r);

Customer cus = new Customer(r);

Thread t1 = new Thread(p); //创建一个线程

Thread t2 = new Thread(p);

Thread t3 = new Thread(cus);

Thread t4 = new Thread(cus);

t1.start(); //启动线程，调用run方法

t2.start();

t3.start();

t4.start();

System.out.println("Hello World!");

}

线程终止：

1. 正常终止当线程的run()执行完毕，线程死亡。

2. 使用标记停止线程

String类：

Object：描述的是多有类的通用属性和方法。

常用方法：

String toString() 返回对象的描述信息 java.lang.Object@de6ced 类名@哈希码值的十六进制形式

当直接打印一个引用变量的时候，那么会调用该引用变量指向的对象的toString()

boolean equals(Object obj) 返回的是比较的结果如果相等返回true，否则false 比较的两个引用变量指向的是不是同一个对象(内存地址)

int hashCode() 返回该对象的哈希码值：采用操作系统底层实现的哈希算法。同一个对象的哈希码值是唯一的。

编程习惯：

1. 开发者要对自定义的类重写toString()，对对象做详细的说明

2. 开发者要对自定义的类重写equals()，使得比较两个对象的时候比较对象的属性是否相等，而不是内存地址。

3. java规定如果两个对象equals返回true，那么这两个对象的hashCode码必须一致。

Object使用细节：

1. 任何类的最终父类都是Object。

2. 不要显示的继承Object，这样的话就无法再继承其他类。

//练习：

/**

* 正则表达式：符合一定规则的表达式。

* 作用：用于专门操作字符串

* 特点：用一些特定的符号来表示一些代码的操作，简化书写。

* 具体操作功能：

* 1.匹配： boolean matches(String regex) 告知此字符串是否匹配给定的正则表达式

2.切割： String split

String[] split(String regex) 根据给定正则表达式的匹配拆分此字符串。

3.替换：String replaceAll();

String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串

获取：

Pattern对象中的方法：

Matcher matcher(CharSequence input) 创建匹配给定输入与此模式的匹配器。

Matcher对象中的方法：

1. boolean find() 尝试查找与该模式匹配的输入序列的下一个子序列。

boolean find(int start) 重置此匹配器，然后尝试查找匹配该模式、从指定索引开始的输入序列的下一个子序列。

String group()

返回由以前匹配操作所匹配的输入子序列。

String group(int group) 返回在以前匹配操作期间由给定组捕获的输入子序列。

int end() 返回最后匹配字符之后的偏移量。

public static void huoQu()

{

String str = "ming tian jiu yao shang ke le .";

String regex = "\\b[a-z]{3}\\b";

//将规则封装成对象

Pattern p = Pattern.compile(regex);

//让正则对象和要作用的字符串相关联

Matcher m = p.matcher(str);

// boolean matches()

// 尝试将整个区域与模式匹配。

// System.out.println(m.matches());

while(m.find()) //将规则作用到字符串上，并进行符合规则的字串查找

{

System.out.println(m.group()); //用于获取匹配后的结果

System.out.println(m.start()+"...."+m.end()); //获取字串的角标

System.out.println(m.groupCount());// 返回此匹配器模式中的捕获组数。

System.out.println(m.replaceAll("*"));// 替换模式与给定替换字符串相匹配的输入序列的每个子序列。

}

//替换：

public static void replaceAllDemo()

{

//将字符串中的数字替换为#

String str = "wer13545465656ty90908uiod8u0890f";

String reg = "\\d+";

String s = str.replaceAll(reg, "#");

System.out.println(s);

//按照叠词替换&

String str4 = "erkktyqquizzzzhhho";

String reg1 = "(.)\\1+";

//String s1 = str4.replaceAll(reg1, "&");

String s1 = str4.replaceAll(reg1, "$1");

System.out.println(s1);

}

//切割：

public static void splitMethod()

{

//按String reg= "," 进行切割

String str1 = "zhangsan,lisi,wangwu";

//String reg = " +" 按照多个空格切割

String str2 = "zhangsan lisi wangwu";

//String reg = "\\."

String str3 = "zhangsan.lisi.wangwu";

String str4 = "erkktyqquizzzzhhho"; //按照叠词切割

String reg = "(.)\\1+"; //将重复的封装为一个组，并反向引用改组,通过\n应用，n就是组的编号。

splitDemo(str4,reg);

}

public static void splitDemo(String str,String reg)

{

String [] arr = str.split(reg);

for(String s : arr)

{

System.out.print(s);

}

//手机号码匹配 13xxxx 15xxxx 18xxxx

public static void checkTel()

{

String tel = "13527678798";

String regex = "1[358]\\d+";

System.out.println(tel.matches(regex));

}

//需求：对qq号码进行校验。

// 要求长度5~15，0不能开头，只能是数字

class RegexDemoq2

{

public static void main(String[] args)

{

Regexpipei();

general_1();

}

//方法一：

public static void Regexpipei()

{

String qq = "123456789e";

//String regex = "[1-9][0-9]{4,14}";

String regex="[1-9]\\d{4,14}";

// boolean matches(String regex)

// 告知此字符串是否匹配给定的正则表达式。

boolean flag = qq.matches(regex);

if(flag)

System.out.println(qq+"si...ok");

else

System.out.println(qq+" 不合法");

}

//方法二：

public static void general_1()

{

String qq = "123456472w";

int len = qq.length();

if(len>5 && len<15)

{

//static long parseLong(String s)

//将 string 参数解析为有符号十进制 long。

try

{

long l = Long.parseLong(qq);

System.out.println(l);

}

catch(NumberFormatException e)

{

System.out.println("出现非法字符...");

}

else

{

System.out.println("长度错误");

}

//方法三：

public static void general()

{

String qq = "123456472w";

int len = qq.length();

if(len>5 && len<15)

{

if(!qq.startsWith("0"))

{

char[] arr = qq.toCharArray();

boolean flag = true;

for(int x=0;x<arr.length;x++)

{

if(!(arr[x]>='0' && arr[x]<='9'))

{

flag = false;

break;

}

if(flag)

{

System.out.println("qq:"+qq);

}

else

{

System.out.println("出现非法字符");

}

else

{

System.out.println("不可以0开头");

}

}else

{

System.out.println("长度错误");

}

class Demo2

{

public static void main(String[] args)

{

String st = "abdjavashanedljavajichujava";

String str = " ab df ";

//System.out.println("["+reverse(str)+"]");

//System.out.println("["+show(str)+"]");

rege(st);

//System.out.println(index(st,"java"));

}

//去除字符串两端的空格

public static String show(String str)

{

int start = 0;

int end = str.length()-1;

while(start<end && str.charAt(start)== ' ')

start++;

while(start<end && str.charAt(end)== ' ')

end++;

return str.substring(start,end+1);

}

//使用正则表达式去除字符串两端的空格

public static void rege(String str)

{

//String regex = "[a-zA-Z]{2}+ +";

String regex ="(.)\\1+"; //"java+";

Pattern p = Pattern.compile(regex);

Matcher m = p.matcher(str);

int count=1;

while(m.find())

{

System.out.println(m.group()+", "+"count:"+count++);

}

//字符串的反转

public String method(String str)

{

char[] chs = str.toCharArray();

for(int start=0,end=str.length();start<end;start++,end--)

{

char temp = chs[start];

chs[start] = chs[end];

chs[end] = temp;

}

return new String(chs);

}

public static int index(String str,String key)

{

int index = 0;

int count = 0;

while((index = str.indexOf(key))!=-1)

{

str = str.substring(index+key.length());

System.out.println(str);

count++;

}

return count;

}

3，获取一个字符串在另一个字符串中出现的次数。

"abkkcdkkefkkskk"

思路：

1，定义个计数器。

2，获取kk第一次出现的位置。

3，从第一次出现位置后剩余的字符串中继续获取kk出现的位置。

每获取一次就计数一次。

4，当获取不到时，计数完成。

public class StringFind

{

/**

* @param args

public static void main(String[] args)

{

String str = "yiqiekkjieiyoukkkendddengkk";

//System.out.println(stringIndex(str, "kk"));

int number = show(str);

System.out.println(number);

}

//第一种：通过角标查找出现的次数

public static int stringIndex(String str,String key)

{

int count = 0;

int index = 0;

while((index = str.indexOf(key))!=-1)

{

System.out.println(str);

str = str.substring(index+key.length());

count++;

}

return count;

}

//第二种：根据正则表达式进行匹配查找

public static int show(String str)

{

int num = 0;

String regex = "(.)\\1+"; //"\\w+";

//System.out.println(str.matches(regex));

//将给定的正则表达式编译到该模式下

Pattern pt = Pattern.compile(regex);

//根据匹配的模式切割

String[] buf = pt.split(str);

for(String st : buf)

{

System.out.println(st);

}

//创建匹配给定输入与此模式的匹配器

Matcher mt = pt.matcher(str);

//查找与该模式匹配的下一个子序列

while(mt.find())

{

// 返回在以前匹配操作期间由给定组捕获的输入子序列

String s = mt.group();

//System.out.println(s.toString());

num++;

System.out.println(mt.start());

}

return num;

//System.out.println(str.replaceAll(regex, ","));

}

//通过切割的次数查找

public static void reg(String str)

{

int count=0;

String[] reg = str.split("kk");

for(String buf : reg)

{

System.out.println(buf);

count++;

}

System.out.println(count);

}

/**需求：将下列字符串转成：我要学编程。

* 思路：

* 1.如果只想知道该字符是对是错，使用匹配。

* 2.想要将已有的字符串变成另一个字符串，替换。

* 3.想要按照自定的方式将字符串变成多个字符串，切割，获取规则已外的子串。

* 4.想要拿到符合要求的字符串，获取，获取符合规则的子串。*/

* 192.68.1.254.102.49.23.013.10.10.10.2.2.2.2.8.109.90.30

* 将IP地址按地址段进行排序。

* 按照自然那顺序排序，只要让每段是3位即可。

* 1.按照每段需要的最多的0进行补齐，至少保留3位。

* 2.将每一段值保留3位，所有的IP地址都是3位。

public static void Ipsort()

{

String ip = "192.68.1.254 102.49.23.013 10.10.10.2 2.2.2.8 109.90.30.23";

//将所取的数字封装成组，使用$1取第一组，并在组的前面加上00 。

ip = ip.replaceAll("(\\d+)", "00$1");

System.out.println(ip);

ip = ip.replaceAll("0*(\\d{3})","$1");

System.out.println(ip);

String[] arr = ip.split(" ");

TreeSet<String> ts = new TreeSet<String>();

for(String s : arr)

{

ts.add(s);

}

for(String s : ts)

{

System.out.println(s.replaceAll("0*(\\d+)","$1"));

}

/*需求：对邮箱地址进行校验*/

public static void CheckMail()

{

String mail = "abc@sina.com.cn";

String regex = "[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\\.[a-zA-Z]+)+";

String reg = "\\w+@\\w+(\\.\\w+)+";

if(mail.indexOf("@")!=-1)

System.out.println(mail);

System.out.println(mail.matches(regex));

System.out.println(mail.matches(reg));

}

/网页爬虫：（蜘蛛）

public class RegexTest2

{

public static void main(String[] args) throws Exception

{

//GetMails();

Myweb();

}

//获取网页中的邮件地址

public static void Myweb() throws Exception

{

URL url = new URL("http://192.168.1.254:8080/myweb/mail.thml");

URLConnection con = url.openConnection();

BufferedReader bufrin = new BufferedReader(new InputStreamReader(con.getInputStream()));

String line = null;

String mailreg = "\\w+@\\w+(\\.\\w+)+";

Pattern p = Pattern.compile(mailreg);

while((line=bufrin.readLine())!=null)

{

Matcher m = p.matcher(line);

while(m.find())

{

System.out.println(m.group());

}

//获取文档中的邮件地址，使用获取功能，Pattern Matcher

public static void GetMails() throws Exception

{

BufferedReader bufr = new BufferedReader(new FileReader("E:\\java练习程序\\mail.txt"));

String line = null;

String mailreg = "\\w+@\\w+(\\.\\w+)+";

Pattern p = Pattern.compile(mailreg);

while((line=bufr.readLine())!=null)

{

Matcher m = p.matcher(line);

while(m.find())

{

System.out.println(m.group());

}

Math：类封装了很多数学的功能。

static double ceil(double a) : 返回大于等于指定小数的最小整数

static double floor(double a): 返回小于等于指定小数的最大整数

static long round(double a) : 四舍五入

static double random() : 返回大于等于0.0 小于1.0的小数 1.0<= x < 11.0

9. IO流

9.1 IO的概念

主要做设备和设备之间的数据传输。

9.2 IO的分类

单位：

字节流 (主要操作二进制数据)

字符流 (主要操作字符文本数据)

方向：

输入流 Reader

输出流 Writer

以代码为基准：输入流、输出流

9.3 IO的体系结构

字符流（使用了缓冲区）

-----| Writer 抽象类每次操作一个字符

write(int) write( char[] ) flush() close()

--------| FileWriter

--------| OutputStreamWriter

--------| BufferedWriter

newLine()

-----| Reader 抽象类每次操作一个字符

read() read(char[]) close()

--------| FileReader

--------| InputStreamReader

--------| BufferedReader

readLine()

----------| LineNumberReader

getLineNumber()

setLineNumber()

mark(34242)

reset()

skip()

字节流不是用缓冲区

-----| OutputStream 抽象类每次操作一个字节

write(byte) write(byte[]) close()

--------| FileOutputStream

--------| ObjectOutputStream

--------| BufferOutputStream (有缓冲区了)

--------| PipedOutputStream

-----| InputStream 抽象类每次操作一个字节

--------| FileInputStream

--------| BufferedInputStream

--------| ObjectInputStream

--------| SequenceInputStream

--------| PipedInputStream

9.4 字符流

1. 操作单位为字符

2. 使用了内存中的缓冲区，所以需要刷新

3. 操作文本数据，不能操作二进制数据

4. 内部做了码表的转换，所以要注意乱码

编码和解码的码表必须一致。

getBytes()

new String()

9.5 字节流

1. 操作单位是字节

2. 没有使用缓冲区，不需要刷新

3. 主要操作二进制数据，无需编码

9.6 转换流

字节流到字符流的桥梁。

InputStreamReader 将字节输入流转换为字符输入流

OutputStreamWriter 将字节输出流转换为字符输出流

new BufferedReader( new InputStreamReader( (System.in) ) );

9.7 标准输入和输出流

InputStream System.in

PrintStream System.out

接受控制台输入的数据：

BufferedReader read = new BufferedReader( new InputStreamReader( (System.in) ) );

---》23

String age = read.readLine();

Person age int

int age = Integer.parseInt(age);

---》34.8

String price = read.readLine();

double price = Double.parseDouble(price);

注意：

学会使用标准流重定向实现日志文件。

9.8 顺序流 SequenceInputStream

new SequenceInputStream( InputStream in1 , InputStream in2 )

new SequenceInputStream( Enumeration< ? extends InputStream > )

new Enumeration(){

public boolean hasMoreElements(){

return it.hasNext()

}

public Object nextElement(){

return it.next()

}

注意：

文件的切割和合并。

9.9 File类

该类描述的是一个文件或文件夹。

0. 属性

separator \ /

pathSeparator ;

1. 构造函数：

new File(String name)

new File( File dir , String name)

2. 常见的方法

boolean createNewFile()

delete()

deleteOnExit()

createTempFile(String prefix, String suffix) .tmp 存储在系统的默认的临时文件夹中

exists() 目录或是否存在

isFile()

isDirectory()

String[] list() 返回一个文件夹下面的所有的目录和文件

File[] listFiles() 返回一个文件夹下面的所有的目录和文件对象

File [] listFiles(FileFilter filter)

-----| FileFilter 接口

public boolean accept(File pathname){

return pathname.getName().endsWith(".java");

}

mkdir() 创建一级目录

mkdirs() 常见多级目录

renameTo() 重命名如果指定的路径不相同实现的是剪切

9.10 序列化和反序列化流

序列化：对象 ------》目标设备

反序列换：目标设备----》对象

ObjectInputStream

ObjectOutputStream

注意：

1. 序列化的类对象一定要实现Serializable接口

2. 为了避免整容后不认识该对象，在序列化的类定义的时候需要定义一个

public static final long serialVersionUID = 1L;

3. 如果A实现了Serializable接口，B继承了A，那B可以被序列化。

9.11 管道流

主要做的是线程之间的数据通信

PipedInputStream

PipedOutputStream

注意：

需要相互连接

9.12 打印流

打印方便开发者格式化输出日志信息或其他数据信息。

PrintStream

PrintWriter

println()

print()

printf()

%s 字符串

%d 正数

%f 小数

%c 字符

9.13 其他流

RandomAccessFile

new RandomAccessFile( 文件设备 , "rw" );

writeUTF();

readUTF();

seek();

DataInputStream

DataOutputStream

......

* 序列化和反序列化流：该流功能比较强大，能直接读取一个对象，在存储的过程一定要注意，是怎样读进文件中存储，

* 就必须怎样取出，应为改流在存储的过程中是以UTF-8编码存储的，而UTF-8中中文一般是三个字节，如果在取出时没有

* 按照要求，则会出现非法的字符。

public class ObjectStream

{

public static void main(String[] args) throws Exception

{

ObjectOutputStream();

ObjectInputStream();

}

public static void ObjectInputStream() throws Exception

{

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("e:\\testfile\\outobj.txt"));

ObjoutInput p = (ObjoutInput)ois.readObject(); // 从 ObjectInputStream 读取对象

System.out.println(p);

ois.close();

}

public static void ObjectOutputStream() throws Exception

{

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("e:\\testfile\\outobj.txt"));

oos.writeObject(new Person("zhangsan",34));

oos.close();

}

* RandomAccessFile(File file, String mode)

创建从中读取和向其中写入（可选）的随机访问文件流，该文件由 File 参数指定。

此处的 String mode：

mode 参数指定用以打开文件的访问模式。允许的值及其含意为：

"r" 以只读方式打开。调用结果对象的任何 write 方法都将导致抛出 IOException。

"rw" 打开以便读取和写入。如果该文件尚不存在，则尝试创建该文件。

"rws" 打开以便读取和写入，对于 "rw"，还要求对文件的内容或元数据的每个更新都同步写入到底层存储设备。

"rwd" 打开以便读取和写入，对于 "rw"，还要求对文件内容的每个更新都同步写入到底层存储设备。

public class RandomAccess

{

public static void main(String[] args) throws Exception {

// TODO Auto-generated method stub

RandomAccessFile ran = new RandomAccessFile("f:\\random.txt","rw");

/* ran.writeBoolean(true);

ran.writeDouble(45.3);

//ran.writeChars("ghjk");

System.out.println(ran.readBoolean());

System.out.println(ran.readDouble());

}

* 注：该流既能写又能读取，注意在写入和读取是不能同步进行的。

* 在写入的时候只能是写入，读取的时候只能是读取。

GUI: Graphycal user interface

java.awt.(abstract wiondow Tools)抽象窗口工具集

component

--containor

-----window

--------Jpanel

--------Jframe

--Jbotton

--Jlable

--JtxtComponent

----JtextFiled

----JFileArea

四大布局管路器：

----borderlayout :边界式布局（north,south,west,east,center）

----FlowLayout :流式布局，即一个接着一个

----GridLayout ：网格式布局，即成网格状的排列

----CardLayout ：卡片式布局

网络传输：

IP地址分为A、B、C、D、E5类。常用的是B和C两类。

Inetaddress:

getLocalHost() //返回本地的主机名

getHostAddress() //返回本地主机地址

getHostName()

getByName(String host)

getAllByName(String host)

UDP

将数据极其源和目的封装为数据包，不需要建立连接。

每个数据包大小限制在64K中

因为无连接，所以不可靠

因为不需要建立连接，所以速度快

如：人说话、飞秋、凌波、CS等

TCP

建立连接，有特有的通道

在连接中传输大数据量

通过三次握手机制连接，可靠协议

通信前必须建立连接，效率稍低

如：打电话、物流送货等

HTML语言：

<!--

HTML: 超文本标记语言该语言主要用于开发页面(.html 或 .htm )

超文本：由于该文本代表的是不同的页面，而且不同的页面可以使用超链接直接访问

标签： HTML语言开发很多用于编写网页的特定的文本元素，而且这些文本元素为了和一般的元素进行区分，使用了

<>将文本包起来，那么这样的文本称之为标签。

学习HTML语言其实就是学习HTML语言内置的所有的标签元素。

HTML语言：

开发该语言的目的：蒂姆.伯纳斯.李为了在局域网中共享数据

Intenet ： www 万维网世界上所有的在这个网络中的人都可以实现共享数据

HTML发展历史：

w3c组织：一个关于web开发的标准化组织，主要规范web(网页)开发的一些标准 HTML。

w3c提供很多关于页面开发API文档

HTML语法：

1. 页面的组成

1.1 文档声明

文档声明语句是给浏览器看的，浏览器可以通过文档声明来具体的解析页面中的标签。

1.2 文档内容

<html></html> 代表一个具体的网页该标签是网页文件的根标签

<html>

<head><title>我的网站</title></head> 代表页面的头部

<body>网页要显示的内容</body>

</html>

2. 页面的标签和属性

标签：使用<>包起来的文本称之为标签，但是该标签必须是HTML语言定义好的

带标签体的标签：如 <h2>我的文章</h2>

空标签：如 <br/>

属性：

color:是font标签的属性名

red：是font标签color属性的属性值，注意属性值最好使用"" 或‘’引起来-->

2H<sub>2</sub> + O<sub>2</sub> = 2H<sub>2</sub>O

<!--hr标签代表一根线条该标签是一个空标签 width属性：线条宽度 align属性线条居中方式

color属性：线条颜色 size属性：线条粗度 -->

实体：其实就是转义字符。

特殊字符转义字符（ & 名字 ; ）

< <

> >

& &

例:

<body>

段落要这样写：

< p >这是一个段落</p>

&hearts;

</body>

列表标签:

新闻

</ul>

新闻

</ol>

<!--table标签代表一个表格 border属性：用于指定表格的边框 cellspacing属性：指定列和列的距离

cellpadding属性：设置列的内容到列的边框的距离-->

超链接:

<BODY>

<!--a代表超链接标签， href属性：指定单机跳转的页面，也可以指定协议

mailto:本地使用outLook taget属性：指定了在哪里打开超链接指定的文件 _new 在新的窗口打开 _self在当前的窗口打开 _blank在新的选项中打开 -->

<br/>

<!--img图片标签空标签

src属性，指定的图片路径（绝对路径。相对路径）

音频和视频/字符滚动:

<TITLE> 音频和视频/字符滚动 </TITLE>

<!--embed该标签代表一个音频或视频文件

src代表要播放的音频或者视频文件

hidden属性:将默认播放器显示，默认false

autostart属性：自动播放视频音频文件，默认为true

loop属性：指定是否需要循环播放，默认true-->

<br/>

<br/>

</embed>

<!--marquee字符滚动

direction属性：指定滚动的方向

scrollamount属性：指定滚定的速度

scrolldelay属性：指定延时速度

loop属性：指定循环次数，默认的是-1，代表无线循环，可以指定具体的次数-->

</marquee>

</BODY>

</HTML>

画中画效果:

iframe画中画标签

src属性:指定画中画显示的页面

scrolling属性：指定画中画的是否有滚动条

frameborder属性：指定画中画的边框

表单:

<!--from标签主要用于接收用户的数据

action属性：指定将表单多搜索的用户输入的数据提交给谁

method属性：指定提交数据的方式。

get http://www.sina.com name=jack&pass=12334 缺点：提交数据是明码。数据小于1k.

post:数据无限，提交的数据不会在地址栏显示出来

enctype属性：指定数据的编码方式MIME

application/x-www-form-urlencoded 说明提交的数据是一般的表单字段数据

multipart/form-data 提交的数据是一个混合数据（name file）

cellspacing 设置列与列之间的距离. cellspadding:设置列中的内容到列的边框之间的距离(table标签的属性)

clospan:合并列. rowspan;行的合并.(td标签的属性)

注：在开发的过程中上传web应用的时候需要使用multipart/form-data-->

Frameset:框架:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<HTML>

<HEAD>

<TITLE> 页面窗口的切割 </TITLE>

</HEAD>

<!--使用frameset标签可以讲当前窗口切割为不同的子窗口，因为是做窗口的切割，

所以该页面不能出现body标签-->

<!--frame标签代表被切割的一个子窗口

src属性：可以指定该子窗口中要显示的内容

name属性：给子窗口设置一个名字-->

</frameset>

</frameset><noframes></noframes>

</HTML>

CCS:样式表:castcading style sheet

link标签引入外部文件，href属性：指定引入资源的路径。type属性指定引入资源为MIME类型。

rel标签指定引入的资源与目标的关系 stylesheet*/

@import url("yswj2.css");

   在页面上写超连接，并默认的的字体为红色

分析：1.使用超连接 2.使用font对字体进行更改

由于这样的操作非常的复杂，每次都需要修改，因此使用css

css: css技术对页面上的html的元素进行显示效果的修饰。

html(主要负责页面的结构) css(负责页面显示效果)

css样式表的注释：/* */

css页面样式表的引入方式：

1.行内样式：html所有的标签都有一个style属性，该属性可以指定html属性显示样式。

如：<a style="color":red></a> 特点：只对当前更改的html元素起作用

2.内部样式：在html页面中的<head></head>标签中使用。

3.外部样式：将样式形成一个单独的样式文件，在每一个需要样式的页面中导入的标签导入样式文件。

样式文件：指的是后缀为.css的单独文件。

link标签：主要用于引入外部样式文件。

实现方式1：<link href="yswj2.css" type="text/css" rel="stylesheet"/>

实现方式二：@import url(css文件路径); 如：@import url("yswj2.css"); url也可以省略不

Link标签和@import 语句

1.归属不同：link属于html语言，@import属于css语言的语句，所以应该写在<style></style>中

2.引入时间不同：link导入浏览器一遇到该标签就导入该样式文件。

import 导入时先加载所有页面，然后加载样式文件。

3.link标签在页面中可以使用多次。

import在页面中使用的次数是有限的，大约30次

4.link可以实现换肤 dom . import 不可以实现。

-->

</body>

</html>

选择器的分类:

<head>

</head>

<style>

/*标签选择器

h1{

color:#FF0000;

}*/

/*id选择器

#my{

color:#00FF00;

}*/

/*类选择器

.type{

color:#00FF00;

}

.my2{

color:#CCFF99;

}*/

/*并集选择器

a,h1{

color:#33FF66;

}

#my, .type{

color:#0000CC;

}*/

/*交际选择器

p a{

background-color:#FFFF00;

}

/*通用选择器*/

font-size:18px;

}

</style>

<body>

<h1>标签选择器</h1>

<h2 id="my">id选择器</h2>

<a href="#">并集选择器</a>

<p>publid static void main<a href="#">交际选择器</a></p>

</body>

</html>

<!--选择器的分类：

1.标签选择器:通过标签名找页面中被修饰的元素。

2.id选择器：通过给定的html的id找页面中被修饰的元素.

特点：id不能以数字开头,id的属性最好唯一。

属性值主要是给指定的标题添加背景颜色,属性值可以使英文单词，也可以是十六机制表示形式,百分比.

3.类选择器：通过class属性找页面中修饰的元素。

特点：

1.在 CSS 中，类选择器以一个点号显示。

2.一个页面的class属性可以指定多个值，每个值之间使用空格进行隔开。

3.使用该选择器可以找到任意属性的值。

4.注意：类名的第一个字符不能使用数字！它无法在 Mozilla 或 Firefox 中起作用。

4.并集选择器：可以使用其他的选择器选择好页面元素，并通过逗号（,）将相同页面元素连接。

5.交际选择器：通过其他选择器选择(A)的元素使用空格与另外一个选择器(B)相连接。

如：选择的是p元素下面的多用a元素。

p a{

background-color:#FFFF00;

}

6.通用选择器：使用*选择页面上的多用元素。

font-size:18px;

}

应用：主要对整个页面上的元素所有样式的设置。

7.伪类选择器 -

伪类选择器:

<head>

<title>伪类选择器</title>

<style>

a:link{

color:red;

}

a:visited{

color:green;

}

a:hover{

color:yellow;

}

a:active{

color:blue;

}

</style>

</head>

<body>

<a href="#">伪类选择器</a>

</body>

</html>

<!--伪类选择器:

a:link : 未访问的时候

a:visited: 访问过后的时候

a:hover: 鼠标移上去的时候

a:active: 按下去的时候

常用工具的定义:

<style>

color:#FF0000; /*指定文本的颜色R(red) G(green) B(blue)*/

direction:ltr /*文本剧中*/

line-height:30px;/*设置行高*/

letter-spacing:10px; /*设置字符间距*/

background:url(../新建文件夹/123.bmp) no-repeat;/*设置背景图片*/

}

ul{

list-style:none; /*取消列表符号*/

list-style-image:url("../新建文件夹/1600FG100_025.jpg");

}

</style>

例3；

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<head>

<style>

html{

filter; gray;

}

</style>

</head>

<body>

</body>

</html>

javaScript:

<!-- javascrpt引入方式：

1.内部脚本：使用script标签包含脚本代码

·特点：该标签可以写在页面的任何位置。

在页面中该标签可以出现多次。

2.外部脚本：

变量的定义：使用var关键字定义一个变量，该关键字可以省略不写。： var=varable

例：var a = 34;

script中有数据类型。但是在定义基本数据类型的时候不需要指定。

基本数据类型的关键字：typeof 变量。通过该变量可以查看script中的基本数据类型。

javascript语句：语句后面可以忽略分号，如果有多条语句，一定要加上分号。

注释：多行注释/* */ ，单行注释：//

//-->

//代码块的使用：

document.write("<p>this is program</p>");

{

var d = 99;

document.write(d);

}

document.write("<hr/>this is program2<hr>");

var a = new Data();

if(d)

{

document.write("true");

}

else

{

document.write("document false");

}

/*自动类型的转换：

默认的number类型会自动的转化为boolean类型。

非0数字转换为true, 0转换为false

非空为true, 空(null)转换为false

undefined 默认转化为false.

引用类型可以自动转化为boolean类型。

if(){}

if(){} else{}

以上if判断语句在判断条件是可以接受任何类型的数据,

注意如下:

非0数字转换为true, 0转换为false

非空为true, 空(null)转换为false

undefined 默认转化为false.

</script>

// 练习：根据用的输入月份，判断季节冬季：12 1 2 春季 3 4 5 夏季 6 7 8 秋季 9 10 11

var month = 5;

if( month===12 || month=== 1 || month=== 2 ){

document.write("冬季");

}else if( month===3 || month=== 4 || month=== 5 ){

document.write("春季");

}else if( month===6 || month=== 7 || month=== 8 ){

document.write("夏季");

}else if( month===9 || month=== 10 || month=== 11 ){

document.write("秋季");

}else{

document.write("输入有误！");

}

// switch case语句

var a = "22";

switch(a){

case "12": document.write("12"); break;

case "22": document.write("22"); break;

case "32": document.write("32"); break;

default: document.write("数据不在【 12 22 32】中!");

}

// 练习：根据学生的成绩，返回学生成绩对应的等级 A 90~100 B 80~89 C 70~79 D 60~69 E 60以下

document.write("<hr/>");

var scope = 75;

switch(true){

case scope>=90 && scope<=100: document.write("A"); break;

case scope>=80 && scope<=89: document.write("B"); break;

case scope>=70 && scope<=79: document.write("C"); break;

case scope>=60 && scope<=69: document.write("D"); break;

case scope>=0 && scope<=59: document.write("E"); break;

default: document.write("数据不在【0~100】中!");

}

document.write("<hr/>");

var a = 10;

// 三目运算符可以简化以下程序代码

if( 23 > 12 ){

a = 20;

}else{

a = 30;

}

document.write( a + "<br/>");

document.write( a = ( 23 > 12 ? 20 : 30 ) + "<br/>");

// 定义数组 for in语句主要用于遍历对象和数组

var a = [23,34,56,78];

for( var temp in window){

document.write(temp+"<br/>");

}

window.document.write("JavaScript");

</script>

函数：

1.函数的定义：

function 函数名（参数列表（参与运算的未知内容））

{

return 数据;

}

特点：1.没有返回值，不能使用void,d但是可以再函数体内写return

语句返回计算结果。

2.函数的定义和调用没有先后顺序，浏览器的解释器程序会默认先做函数的定义。

3.打印《函数名》直接返回的是函数的定义。

4，函数名的类型是function.

5.函数可以任意赋值。

6.函数是javascript中最小的变量作用域，全局作用域。

7.函数中的变量如果没有使用var关键字生命的话，该变量的默认的作用域是全局的，如果使用了var，

作用域是整个函数，如果一个变量的作用域想在函数中，那么该变量一定要使用var关键字。

8.javascript中可以有重名的变量，但是后面的同名变量会将前面的同名变量覆盖。

javascript中可以有重名的函数，但是后面的同名函数会将前面的同名函数覆盖，与形参无关。

9.javascript中没有重载，函数的调用与形参没有任何关系。

10，声明函数时可以不需要声明形参，如果需要获取形参，使用关键字，arguments[]直接获取。

11，javascript中自带有可变参数。

例1: 获取当前系统的是时间对象

<head>

<title>Date对象</title>

<style>

span{

background-color:#CCC;

}

</style>

</head>

<body>

// 获取当前系统的是时间对象

function showDate(){

// 获取系统时间

var date = new Date();

// 获取年、月、日、时、分、秒

var str = date.getFullYear() + "年" + (date.getMonth()+1)+"月" + date.getDate()+"日" +"\星期"+date.getDay() + " "+date.getHours()+"时" + date.getMinutes()+"分"+date.getSeconds()+"秒";

// 将格式化好的时间显示在页面的span标签体中

var span = document.getElementById("mydate");

// 给span标签设置标签体内容

span.innerHTML = str.fontcolor("red");

// 调用定时函数

window.setTimeout("showDate()",1000);

}

// 调用函数

showDate();

</script>

</body>

</html>

2.数组的定义:

<head>

<title>Arra对象</title>

</head>

<body>

/* // 数组的定义,可以不指定长度

var a = [22,3,5,67];

document.write(a+"<br/>"); // 默认是空的不是null

document.write((typeof a)+"<br/>"); // object

document.write(a.length+"<br/>"); // 0

// 数组的初始化使用角标赋值的时候角标可以是任意类型，但是数组的长度取决于整数下标的个数

var a = new Array();

a[0] = 1;

a[1] = 2;

a[3] = 3;

a["a"] = "abc";

a[true] = "hello";

document.write(a+"<br/>");

document.write(a["a"]+"<br/>");

document.write(a.length+"<br/>");

document.write("<hr/>");

for( var temp in a){

document.write(a[temp]+"<br/>");

}

// 指定长度的数组定义，可以越界进行赋值

var a = new Array(3);

a[0]=1;

a[1]=2;

a[2]=3;

a[3]=4;

document.write(a+"<br/>");

document.write(a.length+"<br/>");

// 直接赋值的数组数组中的数据可以是任意类型

var a = [1,"jack",true,new Object(),null,NaN];

document.write(a+"<br/>");

document.write(a.length+"<br/>");

var a = [1,2,3];

document.write(a.concat([4,5],[6,7])+"<br/>"); // 1,2,3,4,5,6,7

document.write(a.join("_")+"<br/>"); // 1_2_3

document.write(a.pop()+"<br/>"); // 3

document.write(a+"<br/>"); // 1,2

document.write(a.push(4,5)+"<br/>"); // 4

document.write(a+"<br/>"); // 1,2,4,5

document.write(a.toString()+"<br/>"); // 1,2,4,5

document.write(a.valueOf()+"<br/>"); // 1,2,4,5

// 数组的排序

var a = [12,22,32,2];

document.write("排序之前："+a+"<br/>");

a.sort(compareTo);

document.write("排序之后："+a+"<br/>");

// 定义一个比较函数

function compareTo(a,b){

return a-b;

}*/

// 二维数组

var a = new Array();

a[0] = new Array(2,3);

a[1] = new Array(4,5);

document.write(a[1][1]+"<br/>");

// 二维数组

var b = new Array( new Array(1,2),new Array(3,4,5) );

document.write(b[0][1]+"<br/>");

// 二维数组

var c = new Array( [10,11,12],[13,14,15],[16,17,18] );

document.write(c[2][0]+"<br/>");

// 二维数组

var d = [ [10,11,12],[13,14,15],[16,17,18] ];

document.write(c[0][2]+"<br/>")

// 遍历二维数组

for(var temp in d){

document.write(d[temp]+"<br/>");

}

document.write("<hr/>");

for(var i = 0 ; i < d.length; i++){

for(var j = 0; j<d[i].length; j++){

document.write(d[i][j]+"<br/>");

}

// 项目应用：主要用于报表的实现。

</script>

</body>

</html>

3.对象的定方式:

1.正则表达式的使用:

r str = "absfdfghjkgfds"

var reg = new RegExp("^\\w+$","g");

document.write(reg.test(str)+"<br/>");

document.write(reg.toString()+"<br/>");s

//字符串简写的校验方式

var regx = /^\w+$/g;

document.write(regx.test(str)+"<br/>");

//邮箱的校验

var s = "wshhao@itcast.cn";

var reg = /^\w+@\w+(\.\w+)+$/g;

document.write(reg.test(s)+"<br/>");

var d = "shakfdhhhhdfklkfjld";

var reg = /^\h{2,}/g;

document.write(reg.test(d)+"<br/>");

document.write(d.replace(reg,"ww")+"<br/>");

document.write("<hr/>");

例2:

<body>

系统时间：<span id="mydate"></span><input type="button" value="停止" οnclick="mystop();" />

// 4. 设置定时器方法，定时显示系统的时间

var i = window.self.setInterval("showDate()",1000);

function showDate(){

// 1、获取系统时间

var date = new Date();

// 2. 获取页面的目标对象

var span = window.document.getElementById("mydate");

// 3. 给目标对象设置日期时间

span.innerHTML = date;

}

showDate();

function mystop(){

// 清理掉定时器

window.clearInterval(i);

}

setTimeout() 该函数在指定定时器的时候，如果需要循环调用那么该方法的调用必须写在函数中。

setInteval() 该函数在指定定时器的时候，如果需要循环调用那么该方法的调用必须写在函数的外面。

</script>

例: 添加节点

<head>

</head>

<body>

</form>

需求：给指定的form表单中添加一个label元素和input单行文本元素

//1、创建一个label节点对象

var dom = window.document;

var lab = dom.createElement("label");

// 创建一个<input type="text" name="uname" />

var inp = dom.createElement("INPUT");

// 设置元素对象的属性

inp.setAttribute("type","text");

inp.setAttribute("name","uname");

//2、对label标签的标签体设置文本值

//lab.innerHTML = "<font color='red'>用户:</font>";

var text = dom.createTextNode("用户:");

lab.appendChild(text);

//3、使得新建的节点对象和DOM树发生关系

dom.frm.appendChild(lab);

dom.frm.appendChild(inp);

</script>

</body>

</html>

例: 删除页面元素

<head>

<title>删除页面元素</title>

</head>

<body>

</form>

//0、获取dom树对象

var dom = window.document;

//1、获取父亲节点

var parent = dom.frm;

//2、获取儿子节点

var child = dom.getElementsByTagName("label")[0];

//3、使得父亲和指定的儿子断绝关系

parent.removeChild(child);

// 使用简化的方式删除页面的中input元素

dom.getElementsByTagName("INPUT")[0].parentNode.removeChild( dom.getElementsByTagName("INPUT")[0] );

</script>

</body>

</html>

例: 修改页面元素

<head>

<title>修改页面元素</title>

</head>

<body>

<p style="color:#0F0">我是传智播客的一员</p>

function changeColor(){

//1、获取到要修改的元素对象

var dom = window.document;

var p = dom.getElementsByTagName("P")[0];

//2、调用对象的set相关方法进行设置

p.style.color = "red";

}

</script>

</body>

</html>

例: 校验码

<head>

<style>

/* 2. 添加页面样式 */

span{

color:#F00;

background-color:#999;

font-size:16px;

font-weight:bold;

margin-left:10px;

padding:5px;

font-style:italic;

text-decoration:line-through;

}

</style>

</head>

校验码: <input type="text" name="checkcode" /><span></span> <a href="#" οnclick="createCode();">看不清,换一张....</a>

// 3. 生成校验码

function createCode(){

// 3.1 使用数组冲存储所有的校验吗数据

var datas = ["","1 ","2 ","3 ","5 ","a ","c ","r ","y ","F ","Y ","O ","P ","你 ","好 ","吗 ","中 ","国 "];

// 3.2 每次随机取4个 0~17随机数

var rand = 0;

var rel = "";

for(var i = 0; i<4; i++){

rand = Math.ceil( Math.random()*17 );

rel += datas[rand];

}

// 长度为4的rel字符串中保存的是校验码的值

// alert(rel);

var span = window.document.getElementsByTagName("span").item(0);

// 设置span的标签体是rel

span.innerHTML = rel;

}

</script>

</body>

</html>

例: 两级联动:

<head>

</head>

<body>

省份：<select id="province" οnchange="getProvince();">

</select>

城市：<select id="city">

</select>

function $(id){

return window.document.getElementById(id);

}

// 使用二维数组存储城市和省份之间的映射关系

var cities = new Array();

cities[0] = new Array();

cities[1] = new Array();

cities[2] = new Array();

cities[3] = new Array();

cities[0][0] = "---请选择---";

cities[1][0] = "---请选择---";

cities[1][1] = "广州市";

cities[1][2] = "深圳市";

cities[1][3] = "佛山市";

cities[2][0] = "---请选择---";

cities[2][1] = "福州市";

cities[2][2] = "厦门市";

cities[2][3] = "泉州市";

cities[2][4] = "三明市";

cities[3][0] = "---请选择---";

cities[3][1] = "长沙市";

cities[3][2] = "湘潭市";

cities[3][3] = "株洲市";

// 获取省份不同的角标【广东省： 1 福建省： 2 湖南省：3 】

function getProvince(){

var province = $("province");

var index = province.selectedIndex;

// 求每一个省份中对应的城市的个数

var count = 0;

while( cities[index][count] != null ){

count++;

}

//alert(count);

// 设置city的长度

$("city").length = count;

// 循环给city的select对象添加option对象

for( var i = 0; i<count; i++ ){

$("city")[i] = new Option(cities[index][i]);

}

</script>

</body>

</html>

例:JavaScript高级应用

<html>

<head>

<title>JavaScript高级应用</title>

</head>

<a href="#">itcast</a>

</form>

// 在一个DOM节点对象之前添加一个DOM对象

function insertNodeBefore(){

// 1. 创建要插入的节点对象

var p = window.document.createElement("P");

p.innerHTML = "This is a p element";

// 2. 添加到a之前

window.document.frm.insertBefore(p,window.document.getElementsByTagName("A").item(0));

// 3. 将页面中的p元素丢对象替换为div元素对象

var div = window.document.createElement("DIV");

div.innerHTML = "My is a div element";

window.document.frm.replaceChild(div,p);

// 4. div a 将这两个元素交换swapNode()

div.swapNode(window.document.getElementsByTagName("A").item(0));

}

</script>

</body>

</html>

<!--- 浏览器渲染(页面元素的表形式)一个页面的时候：

1、浏览器对所有元素的默认样式。

2、用户指定的样式

3、开发者自己定义的样式( 行内 ---》内部 -----》外部 ) !important -->

</body>

</html>

starsky20

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫