2016年最本安卓就业课件细分版02面向对象5天1024章

高端IT就业培训专家第十章二维数组本章目标二维数组引用声明二维数组的创建二维数赋值怎么把二维数组看成就是一维数组访问二维数组多维数组(了解)二维数组定义二维数组本质上是以数组作为数组元素的数组，即“数组的数组”。因为数组只能保存一行数据。在平时生活中，比如坐标等等，我们需要表示用二维的数组来表示。通过行号和列号来定位数据。定义：类型

数组名[

][

]类型[

][

]

数组名例如：float

a[3][4],b[5][10];定义a为3*4（3行4列）的数组，b为5*10（5行10列）的数组。注意，不能写成float

a[3,4],b[5,10];二维数组定义二维数组引用声明二维数组的声明、初始化和引用与一维数组相似。当使用new来创建二维数组时，不必指定每一维的大小，但要指定最左边的维的大小。int[][] array

=newint[2][

];intt1[][]=newint[][4];

//非法二维数组的初始化静态初始化：int

a[][]={{1,2},{2,3},{3,4,5}};动态初始化：int

a[

][

]

=

newint[2][3]；int

b[][

]=

new

int[2][

];b[0]

=

newint[3];b[1]

=

newint[5];二维数赋值二维数组的赋值，同一维数组类似。只是在{}中的每个元素又是每个一维数组。如：数据类型数据名[][]={{值1，值2，值3，值4

}，

//第一行数据{值5，值6，值7

}，

//第二行数据...,

}二维数组中，可以有列数不相等的数组。即每一行的列数不同时。我们需要对每一行进行赋值。二维数赋值int[

][

]

arr1={{13,

-9},{8,0,2},{10,11,9,8}

};二维数赋值测定数组的长度及数组赋值可用.length方法测定二维数组的长度，即元素的个数。只不过当使用“数组名.length”的形式测定的是数组的行数；而使用“数组名[i].length”的形式测定的是该行的列数。例如，若有如下的初始化语句：int[

][]

arr1={{13,

-9},{8,0,2},{10,11,9,8}};则arr1.length的返回值是3，表示数组arr1有3行或3个元素。而arr1[2].length的返回值是4，表示arr1[2]的长度为4，即有4个元素。怎么把二维数组看成就是一维数组实际上,在Java中只有一维数组。二维数组本质上也是一维数组,只是数组中的每一个元素都指向了另一个一维数组而已。//只初始化第一维的长度

int[][]arr=new

int[3][];//分别初始化后续的元素

arr[0]=new

int[3];

arr[1]=new

int[5];

arr[2]=new

int[4];遍历二维数组访问二维数组public

static

void

main(String[]

args)

{int

test[][]

=

{

{

1,

2,

3

},

{

4,

5,6

},

{

7,

8,

9

},

{

10,

11,

12

},{

13,

14,

15

}

};for

(int

row

=

0;

row

<

5;

row++)

{for

(int

col

=

0;

col

<

3;

col++)

{System.out.print(test[row][col]

+

"\t");}System.out.println();}}多维数组(了解)多维数组的声明：数据类型[][][]数组名称;数据类型 数组名称[

][

][

];多维数组的定义和二维数组是等价的。中括号的位置可以在数据类型的后面，也可以在数组名称的后面，其它的依次类推。多维数组的定义：int

a[][][]

=

new

int[2][2][2];int[][][]

b

={

{

{

1,

2

},

{

3,

4

}

},

{

{

5,

6

},

{

7,

8

}

}

};高端IT就业培训专家第十一章类与对象下本章目标多个引用类型变量引用同一个对象(下)对象什么时候成为垃圾"引用.成员"访问成员成员方法的参数(基本数据类型参数、引用数据类型参数)成员方法的返回值(返回值为基本数据、返回值为引用数据类型)局部变量与实例变量的区别？创建与销毁实例方法中this。怎么通过this访问实例方法与实例变量实例方法中返回this引用类型数组多个引用类型变量引用同一个对象引用类型变量在声明后必须引用对象才能使用。同一个对象可被多个引用类型变量引用如：MyDate

today；new

MyDate（）；作//引用变量赋值MyDate

a，b；//将变量分配一个保存引用的空间（栈）

today=//给today变量开辟数据空间（堆），

然后再执行赋值操//在内存开辟两个引用空间//开辟MyDate对象的数据空间，并把该空间的首地a

= new

MyDate（）；址赋给ab

=

a；//将a存储空间中的地址写到b的存储空间中对象什么时候成为垃圾(强引用)垃圾回收是Java程序设计中内存管理的核心概念，JVM的内存管理机制被称为垃圾回收机制，它负责自动回收那些无用对象所占用的内存。一个对象创建后被放置在JVM的堆内存中，只有当对象不再被程序中的任何引用变量引用时，它的内存才可能被回收。当垃圾回收器将要回收无用对象的内存时，先调用该对象的finalize()方法，该方法有可能使对象使对象复活，导致垃圾回收器取消回收该对象的内存。对象什么时候成为垃圾finalize()定义在Object类中：protected

void

finalize()

throws

Throwable因为该方法为protected，所以任何Java类都可以覆盖finalize()方法，该方法中进行释放对象所占的相关资源的操作。JVM的垃圾回收操作对程序来说都是透明的。因此程序无法预料某个无用对象的finalize()方法何时被释放。finalize()方法的特点：垃圾回收器是否会执行该方法及何时执行该方法，都是不确定的。finalize()方法有可能使对象复活，使它恢复到可触及状态。垃圾回收器在执行finalize()方法时，如果出现异常，垃圾回收器不会报告异常，程序继续正常运行。对象什么时候成为垃圾垃圾回收器作为低优先级线程独立运行。在任何时候，程序都无法迫使垃圾回收器立即执行垃圾会后操作。程序中可调用System.gc()或Runtime.gc()方法提示垃圾回收器尽快执行垃圾回收操作，但是不能保证调用后垃圾回收器会立即执行垃圾回收。Java语言建立了垃圾收集机制，用以跟踪正在使用的对象和发现并回收不再使用(引用)的对象。该机制可以有效防范动态内存分配中可能发生的两个危险：因内存垃圾过多而引发的内存耗尽，以及不恰当的内存释放所造成的内存非法引用。"引用.成员"访问成员成员：成员变量与成员方法访问成员

"对象(引用).成员"访问成员类成员还可以使用"类名.成员"方式来访问方法的参数与返回值在第四章讲过方法的参数与返回值，类型都可以为任意数据类型（java的数据类型只有基本数据类型与引用数据类型）而这里要补充的是方法参数类型与返回值类型都为引用类型的知识点成员变量深入局部变量定义在类的方法内或代码块内的变量局部变量只在定义它的方法体内或代码块内有效局部变量在使用之前，必须先初始化全局变量（成员变量）一个类中既不在方法体内也不在程序块内定义的变量类中所有的方法和代码块都可以访问成员变量对于没有初始化的成员变量，系统会指定默认的值21实例方法中this实例方法没有使用static声明的方法使用对象才能调用的方法实例方法中this指当前类对象更准确的说法是指调用实例方法的对象this可被当作实例方法或类方法的实参this可被当作实例方法或类方法返回值this还可用于构造方法中(后面的章节再讲)this的演示图堆内存main栈内存public

class

Stu

{public

intno;public

void

setNo(int

no)

{ this.no

=

no;this.showNo();}public

void

showNo()

{System.out.println("学号"

+

this.no);}public

static

void

main(String[]

args)

{Stu

stu1

=

newStu();Stu

stu2

=

newStu();Stu1地址no:0stu2地址no:018no:1820no:20}stu2stu1引用类型数组引用对象的变量为引用数据类型变量，引用数据类型变量可以使用，类、接口或数组来声明。数组引用变量是存放在栈内存(stack)中，数组元素是存放在堆内存(heap)中，通过栈内存中的指针指向对应元素的在堆内存中的位置来实现访问，以下图来说明数组此时的存放形式。高端IT就业培训专家第十二章构造方法本章目标构造方法的定义默认构造方法构造方法重载构造方法的调用构造方法的主要作用构造方法中this访问实例成员构造方法中this调用构造方法构造方法初步构造方法作用是初始化,一般用于初始化对象(具体讲解见下一节)构造方法的定义构造方法与类名相同，没有返回值，连void都不能写构造方法的形参与成员方法的参数一样，可以没有参数，也可以有参数构造方法初步构造方法可以重载构造方法是可能重载的，与成员方法相同public

class

Stu

{public

String

name;public

int

age;public

Stu()

{System.out.println("Stu()");}public

Stu(int

x)

{System.out.println(x);}}构造方法初步默认构造方法当一个类中如果一个构造方法都没有写，那么编译器会为类加上一个默认的构造方法。默认构造方法的格式：public修饰无参空实现构造方法初步构造方法的调用只要创建对象都会触发一个构造方法被调用，也只会触发一个构造方法被调用，具体触发的是那个构造方法，由创建对象时的参数决定构造方法的初始化作用构造方法主要使用就是对象的属性进程赋值构造方法中可以使用this.表示刚刚创建的对象对象被创建后，如果不使用构造方法初始化，则对象刚创建出来时，数值型属性的值默认为0，boolean型属性默认值为false,引用型属性默认值为null;构造方法中this的使用构造方法中可以使用this.

表示刚刚创建的对象构造方法中this可用于this访问对象属性this访问实例方法this在构造方法中调用重载的其它构造方法只能位于第一行不会触发新对象的的创建归纳this在实例方法和构造方法中的作用this是java多态的体现之一this只可以构造方法和实例方法中存在this在构造方法中表示刚刚创建的对象this在实例方法中表示调用该方法的对象this可以在实例方法和构造方法中访问对象属性与实例方法this有时可省实例方法中可返回thisthis可当作实参this可调用重载的构造方法高端IT就业培训专家第十三章java

API常用类介绍本章目标字符串对象创建String常用方法介绍StringBufferStringBuilder==与equals()MathRandomSystemDateCalendarSimpleDateFormat正则表达式创建字符串直接写字符串创建字符串对像，该字符串会在数据段的字符串常量池中产生对象。String

str1

=

"Hello";使用连接符(+)创建字符串对像,字符串可与连接任何其它数据，任何数据可以连接字符串Stringstr2

=

"Hello"+23+23;//"Hello2323"String

str3

=

23+23+str2+true;//"46Worldtrue"23+23+str2+true;//"46Worldtrue"使用new创建字符串对象String

str4=new

String("小明");字符串常用方法public

int

length();//得到长度public

char

charAt(int

index);//根据下标得到字符public

String

trim();//去掉前后空格public

int

compareTo(String

anotherString);//比较字符串大小public

boolean

endsWith(String

suffix);public

int

indexOf(String

str);public

String

substring(int

beginIndex,

int

endIndex);public

String[]

split(String

regex);public

replace(char

oldChar,

char

newChar);public

replaceAll(String

regex,

String

replacement);public

boolean

equal(Object

obj);StringBuffer和StringBuilderStringBuffer与StringBuilder的方法都是一样的，都是用于构造字符串StringBuffer与StringBuilde的区别：StringBuffer是线程安全的，StringBuilder是线程不安全的，所以性能高于StrngBuffer.StringBuffer和StringBuilder示例：使用StringBuffer或StringBuilder完成//String

s=

12+2

+"3";

//143//String

s2=

"3"+12+2;

//3122String

str="Hello"+true+123+"World";的功能StringBuffer

sb=new

StringBuffer();//改为下面一条语句代替，结果相同.//StringBuilder

sb

=

new

StringBuilder();sb.append("Hello");sb.append(true);sb.append(123);sb.append("world");String

str=

sb.toString();System.out.println(str);//Hellotrue123world==与equals()==比较引用值equals();是Objetive的方法。子类可重写String中重写了equals方法，用于比较字符串内容Math不能创建Math类对象，因为构造方法被private修饰（public修饰的构造方法在任何地方都可以被触发，而private修饰的构造方法只能在当前类中触发）Math类中所有的成员都是类成员,使用时直接使用类名点访问，详见原代码或帮助文档。（类方成员都可以使用staitc访问）最常用的方法只有一个public

static

double

random();

该类方法返回大于或等于0.0D,

小于1.0之间的随机数。其它方法可通过帮助文档自学。java.util.Random用于取得随机值示例：创建Random对象，得到随机boolean值，得到随机整数，得到大于等0，小于10的整数。public

static

void

m1()

{Random

random

=

new

Random();boolean

r1=random.nextBoolean();//得到随机的boolean值int

r2=random.nextInt();//得到随机整数int

r3=random.nextInt(10);//得到随机整数，但是r3>=0

&&

r3<10}SystemSystem.out.println()System类中有public

final

static

PrintStream

out=nullPrintStream();PrintStream为中有很多重载的println()方法System.out.print()与前面类似，只是不换行System.exit(0);退出程序System.currentTimeMillis();

返回从1970年1月1号0点0分0秒0毫秒到现在为至的毫秒数DateDate对象用于封装时间使用当前时间初始化新建的Date对象Date()使用用指定时间初始化新建的Date对角Date(int

year,

int

month,

int

date)Date(int

year,

int

month,

int

date,

int

hrs,

int

min)Date(int

year,

int

month,

int

date,

int

hrs,

int

min,

int

sec)Date(long

date)Date(String

s)java.util.Data使用当前时间初始化新建的Date对象，并取出年月日星期几点分秒public

static

voidm1()

{Date

date

=

newDate();System.out.println(date.getDate());//19号System.out.println(date.getDay());//星期2System.out.println(date.getHours());//17点System.out.println(date.getMinutes());//14分System.out.println(date.getMonth());//(0+1)月，月份从0月开始计算

System.out.println(date.getSeconds());//23秒System.out.println(date.getTime());//与System.currentTimeMillis()作用相同

System.out.println(date.getYear());//(116)年，加上1900年就是现在多少年}通过Calendar还可以得到Date对象，示例

Calendar

calendar=Calendar.getInstance();Date

date=calendar.getTime();SystemDate对象中封装的时间可被改变，使用set??方法即可public

static

void

m1()

{Date

date

=

new

Date();date.setDate(28);date.setYear(200);System.out.println(date.getDate());//28号System.out.println(date.getYear());//(200)年}Calender•Calender也是用于操作时间，大部分情况下使用Calender替换Date•Calender的创建Calendar

calendar

=

Calendar.getInstance();得到时间int

year=calendar.get(Calendar.YEAR);//显示年份int

month=calendar.get(Calendar.MONTH);//

显示月份(从0开始,实际显示要加一)int

day_of_year=calendar.get(Calendar.DAY_OF_YEAR);//今年的第N天int

day_of_month=calendar.get(Calendar.DAY_OF_MONTH);//本月第N天int

hour_of_day=calendar.get(Calendar.HOUR_OF_DAY);//几点int

minute=calendar.get(Calendar.MINUTE);//

当前分钟数Calender修改calendar封装的时间calendar.add(Calendar.HOUR_OF_DAY,3);//3小时以后calendar.add(Calendar.MINUTE,

15);//15

分钟以后calendar.add(Calendar.MINUTE,-30);//30分钟前..........calendar.setTime(new

Date());//使用Date对象重置时间Calender重置时间示例private

void

f2(){Calendar

c

=

Calendar.getInstance();System.out.println(c.get(Calendar.SECOND));//53try

{

Thread.sleep(3000);

}

catch

(InterruptedException

e)

{

e.printStackTrace();

}System.out.println(c.get(Calendar.SECOND));//53c.setTime(new

Date());System.out.println(c.get(Calendar.SECOND));//56}SimpleDateFormat格式化Date可以对Date对象格式化后得到格式规定的字符串时间表示1）yyyy表示年2）dd表示

日3）hh表示

时4）ss表示

秒5)mm与yyyy、dd在一起表示月;与hh、ss在一起表示分SimpleDateFormat格式化Date示例：Date

date

=

new

Date();SimpleDateFormat

sdf=new

SimpleDateFormat("yyyy-mm-ddhh:mm:ss");String

str

=

sdf.format(date);System.out.println(str);//2016-38-30

04:38:36System.out.println(new

SimpleDateFormat("dd:yyyy:mm-----hh点mm分ss秒").format(date));//30:2016:38-----04点38分36秒System.out.println(new

SimpleDateFormat("yyyy年mm月dd日").format(date));//2016年38月30日System.out.println(new

SimpleDateFormat("hh点mm分ss秒").format(date));//04点38分36秒正则表达式入门概念:“正则表达式”（RegularExpression）就是一个特殊的字符串，用来匹配字符串与查找字符串•java基础架包中java.util.regex

包主要由三个类所组成Pattern对象表示一个已编译的正则表达式。Pattern

类没有提供公共的构造方法。必须调用公共的静态compile

方法，它将返回一个Pattern

对象。Matcher

是一个靠着输入的字符串来解析这个模式和完成匹配操作的对象。Matcher

也没有定义公共的构造方法，需要通过调用Pattern

对象的matcher

方法来获得一个Matcher

对象。PatternSyntaxException

对象是一个未检查异常，指示了正则表达式中的一个语法错误。正则表达式入门示例示例:判断字符串是否以ax开头by结尾，并且中间有仅只有一个字符public

class

Test{public

boolean

m1(String

str)

{////方式一：Pattern

p

=

pile("ax.by");// Matcher

m

=p.matcher(str);////boolean

b

=

m.matches();方式二boolean

b

=

Pattern.matches("ax.by",

str);return

b;}public

static

void

main(String[]

args)

{Test

t

=new

Test();System.out.println(t.m1("axmby"));}}正则表达式组成规范匹配字符的通匹符"."--->用于匹配一个任意的字符串"[]"--->为了解决句点符号匹配范围过于广泛这一问题，你可以在方括号（“[]”）里面指定看来有意义的字符。此时，只有方括号里面指定的字符才参与匹配。也就是说，正则表达式“t[aeio]n”只匹配“tan”、“Ten”、“tin”和“ton”。但“Toon”不匹配“|”如果除了上面匹配的所有单词之外，你还想要匹配“toon”，那么，你可以使用“|”操作符。“|”操作符的基本意义就是“或”运算。要匹配

“toon”，使用“t(a|e|i|o|oo)n”正则表达式。这里不能使用方扩号，因为方括号只允许匹配单个字符；这里必须使用圆括号“()”,它的作用与算术表达式中的作用是一样的，表示一个整体正则表达式组成规范（4）4.“-”与表示数字或字母的范围,[0-9]表示0到9中的其中一个字符,[3-8]表示3到8中的一个字符

[a-z]表示a到z中的其中一个字符,[b-m]表示b到m中的一个字符

[A-Z]表示A到Z中的其中一个字符[b-d3-8]表示b到z或3到8中其中一个字符

[a-c][0-9]{3}可以匹配a234,b112,c223等.(5)"^"--->即非,用来确定紧靠该符号右边的符号不能出现示例[^0-9]表示不可以为0到9和[3-8]3到8中的一个字符示例^A表示不可以为A的字符正则表达式组成规范快捷符号\d\D[0-9][^0-9]\w[A-Z0-9]\W[^A-Z0-9]\s[\t\n\r\f]\S[^\t\n\r\f]示例："\\d{6}",匹配6个数字组成的字符。，注意前面要用两个\\表示转义正则表达式组成规范"\"表示转义如果正则表达式中要使用的字符与通配符冲突，则在前加上"\\"表示不是通配符使用比如"[0-9]{3}\\*{2}[0-9]{2}a*"中*不是次数，而是字符*。它可以匹配0到9的三个数字开头，后面是两个*，再后是0到9的2个数字最后是0到多个a字符。示例：这个"234**23a"可以匹配上面的正则表达式。"$"表示结束，每个正则表达式后面都可以加上$,实质上加与不加作用相同特殊的匹配[\\u4e00-\\u9fa5]匹配汉字示例"[\\u4e00-\\u9fa5]{3}",可以匹配三个汉字组成的字符串正则表达式组成规范匹配次数的通匹符这些符号用来确定紧靠该符号左边的符号出现的次数：正则表达式组成规范示例示例1：a*Hello可以匹配以Hello结尾，以0到多个a开头的字符串,如Hello,aHello,aaHello,aaaHello示例2：MyA*Hello可以匹配以My开头，以Hello结尾，中间可以有0到多个A，如MyAAAHello示例3：HelloE+World可以匹配以Hello开头，以World结尾，中间可以有1到多个E，如HelloEEWorld示例4：HelloE?World可以匹配以Hello开头，以World结尾，中间必须有0到1个E示例5：HelloE{3}World可以匹配以Hello开头，以World结尾，中间必须有3个E示例6：HelloE{2,4}World可以匹配以Hello开头，以World结尾，中间必须有2到4个E示例7：Hello[^abc]可以匹配以Hello开头，不能以a或b或c结尾正则表达式的使用在java代码中正则表达式的作用有三种判断字符串的正确性查找子字符串在其它类特别是String中的使用正则表达式的使用查找子字符串示例：查找字符串中是否有算术运算符private

void

m2()

{••••Pattern

p

=

pile("\\+|\\-|\\*|/|%");Matcher

m

=

p.matcher("23

*234/1000");boolean

b

=

m.find();System.out.println(b);//true•

}示例：找字符串中是否有两个数字组成的子字符串private

void

m3()

{•••Pattern

p

=

pile("\\d{2}");Matcher

m

=

p.matcher("aabbcc23sdf23");System.out.println(m.find());//true正则表达式的使用在其它类特别是String中的使用示例：通过运算符把字符串拆开public

void

m1()

{•••••String

s

=

"23

*234/1000";String[]

a

=

s.split("\\+|\\-|\\*|/");for

(String

string

:

a)

{System.out.println(string);}}正则表达式的使用判断字符串的正确性示例：判断电话号码是否是以136开头的11个数字的电话号码•private

void

m1()

{//方式一：//boolean

b

=

Pattern.matches("136\\d{8}","

");//方式二：Pattern

p

=

pile("136\\d{8}");Matcher

m

=

p.matcher("

");boolean

b

=

m.matches();System.out.println(b);//true}高端IT就业培训专家第十四章自动装箱和拆箱本章目标介绍封装类自动装箱自动拆箱什么情景下要使用封装类型`对于简单类型数据，为了和Java面向对象的思想一致，Java对它们进行了封装，使它们都有相应的封装类简单数据类型封装类booleanBooleanbyteByteshortShortintIntegerlongLongcharCharacterfloatFloatdoubleDouble封装类示例public

class

WrapperClass{public

static

void

main(String[]

args){Integer

i

=

new

Integer(10);Integer

j

=

new

Integer(10);System.out.println(i==j);}}1010ij自动装箱/拆箱Integer

iObject=new

Integer(100);Integer

iObject=100;非法!Jdk5.0以前合法,自动装箱Jdk5.0中int

i=new

Integer(100);合法,自动拆箱Jdk5.0中将简单类型数据自动转换成对应封装类型将封装类型自动转换成对应简单类型自动装箱/拆箱int

i1

=

100;//自动封装

Integer

i2=200;//自动拆装int

i3

=

i2;//自动封装

Integer

i4=i3;int

i=i1+i2;System.out.println(i4.MAX_VALUE);i4.hashCode();自动装箱/拆箱需要注意的地方：boolean类型的值所有byte类型的值在-128~127之间的short类型的值在-128~127之间的int类型的值在\u0000~\u007F之间的char类型的值注意上面范围内的数据的自动装箱方式什么情景下要使用封装类型类的封装性，是指尽可能为外界展现一个有限的界面，而把其内部实现细节隐藏起来，在与其他对象的交互使用中，我们可以很好地保持本对象的数据的隐藏，防止其被其他对象破坏。某些情况下，数据必须作为对象出现,此时必须使用封装类来将简单类型封装成对象。某些情况下，使用封装类使我们可以更加方便的操作数据。比如封装类具有一些基本类型不具备的方法，比如valueOf(),toString(),

以及方便的返回各种类型数据的方法，如Integer的shortValue(),longValue(),intValue()等。高端IT就业培训专家第十五章static本章目标类变量声明及其访问类方法声明及其访问静态代码块单例设计模式static关键字•static关键字静态变量（类属性）:成员变量被static修饰静态方法（类方法）:成员方法被static修饰静态内部类静态代码块访问类名.静态成员变量类名.静态成员方法对象.静态成员变量对象.静态成员方法static关键字其它不可用于修饰构造器静态变量和静态方法是在程序运行时分配内存的，直到程序运行结束才会销毁静态变量和静态方法被类的每一个对象公用。静态方法中不能使用“this”和“super“示例public

class

Test

{public

static

intx;public

int

y;public

int

z;public

static

void

main(String[]

args)

{Test

t1

=

new

Test();Testt2

=

new

Test();t1.x

=

10;t1.y

=

20;System.out.println(t1.x);//10;System.out.println(t1.y);//20;System.out.println(t2.x);//10;System.out.println(t2.y);//0;System.out.println(Test.x);//10}}t1y:0z:0t2x:0x:10y:20z:0y:0z:0示例静态函数中不能出现this非静态成员不能使用Stu.访问public

class

Stu

{public

int

x;public

static

int

y;public

static

void

m1(){this.x

=

23;this.y

=

34;

this.m3();this.m2();Stu.m3();

Stu.y

=

34;Stu.m2();}public

static

void

m2(){

}public

void

m3(){this.m2();Stu.m2();this.y

=

34;Stu.y

=

34;this.x

=

34;Stu.x

=

34;}}static初始化块static自由块只在类加载时执行一次，通常用于初始化静态变量public

class

Count

{private

int

serialNumber;public

static

int

counter;static

{counter

=

1;}public

static

int

getTotalCount()

{return

counter;}public

Count()

{counter++;

serialNumber

=

counter;}}单例设计模式单例设计模式在一个项目中，把一个类的对象设计成只能被创建一次，任何时候，任何地方要使用该类的对象时，实计上使用到的都是该类的同一个

对象高端IT就业培训专家第十六章继承本章内容继承的概念Object介绍继承的语法子类对象实例化过程父类引用指向子类对象构造方法在继承中的使用子类的构造方法中的super的使用子类实例方法中super的使用继承时方法的重写语法为什么要使用重写super在重写方法中的使用重写类的toString方法继承的概念类的继承是面向对象编程的特征之一（抽象，封装，继承，多态）。子类可以继承父类的属性和行为（是否可以继承，与父类属性和行为的修饰符有关），同时又可以添加子类独有的属性和行为。继承表示一个“是不是”的关系父类的构造函数不会被继承。Object介绍在Java中，Object类是其他所有类的父类，或者说，其他所有类都继承于

Object类。•Object类在java.lang包中在我们自定义某一个类时，该类会默认继承Object类，或者说，会默认继承

Object类的属性和方法。继承的语法类的继承的基本语法[修饰符]class<子类名>[extends<父类名>]{

[代码块]}比如：自定义Cat类，继承于Animal类public

class

Cat

extends

Animal

{............}子类对象实例化过程当创建子类对象时，先调用父类构造（默认情况下隐式调用父类的无参构造器），后调用子类构造。创建子类对象时，会先按照其父类的信息开辟空间，然后如果有新增的属性或者方法，再继续分配。父类中的属性i父类中的属性n父类中的方法method父类中的属性i父类中的属性n父类中的方法method子类中的属性a子类中的方法method1子类对象引用父类引用指向子类对象父类引用可以指向子类对象。此引用只能访问到父类和子类公共部分，无法访问子类新增的特性（属性和方法）比如：Animal

mAnimal=new

Cat();因此，任何需要传入Animal类型引用的地方，都可以传入Cat对象引用•public void

method(Animal

mAnimal){}•method(new

Cat());父类引用指向子类对象父类中的属性i父类中的属性n父类中的方法method父类中的属性i父类中的属性n父类中的方法method子类中的属性a子类中的方法method1父类引用构造方法在继承中的使用子类不继承父类的构造方法。调用子类的构造方法之前，会先调用其父类的构造方法。如果没有显示调用父类的构造方法，默认调用父类的无参构造方法。可以使用super关键字，显示调用父类的构造方法子类的构造方法中的super的使用在子类构造方法中，可以使用super关键字显示调用父类的构造方法（该方法必须写在构造方法的第一行）语法：super(参数列表)子类实例方法中super的使用在子类的实例方法中，可以使用super关键字，调用父类的方法。语法：super.函数名(参数列表)继承时方法的重写语法在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。比如：Cat继承Animal，Animal有一个方法eat，因此，Cat会继承eat方法。但是，Cat不想使用Animal的eat，或者说它想重写eat方法。此时，可以使用方法覆盖。继承时方法的重写语法public

class

Animal

{void

eat()

{System.out.println("Animal

eat");}}public

class

Catextends

Animal

{void

eat()

{System.out.println("Cat

eat");}}继承时方法的重写语法此时，如果创建Cat对象，并调用eat方法，就会

调用到Cat类的eat方法，而不是Animal的eat方法。覆盖的方法必须和父类完全一致（名称，参数，返回，是否是静态）。覆盖的方法的访问权限不能比父类更严格。覆盖的行为不能比父类抛出更多异常。为什么要使用重写为了符合面向对象编程的多态特征，因此需要使用到方法的覆盖。比如：有一个游戏，玩家可以选择动物，然后让他们发出叫声。那么，在设计游戏框架时，可以设计发出声音的函数为say，但是，该函数的具体实现无法确定（因为，设计者无法提前知道用户会选择哪种动物）为什么要使用重写此时可以使用方法的覆盖来解决该问题。创建类Animalclass

Animal

{void

speak(){};}创建子类Catclass

Cat

extends

Animal

{void

speak(){System.out.println("miao,miao,

miao")};}为什么要使用重写创建子类Dogclass

Dog

extends

Animal

{void

speak(){System.out.println("wang

wang

wang")};}那么，在设计say方法时，可以这么设计。

say（AnimalmAnimal）

{mAnimal.speak();}//如果传入的是Cat对象，就会miaomiao

miao，如果传入的是Dog对象，就会

wang

wangwangsuper在重写方法中的使用在覆盖方法中可以使用super关键字调用父类的方法。重写类的toString方法如前面所说，Java中所有的类都是继承于Object类的。在Object类中，有一个toString方法，该方法可以被重写。实际上，很多标准的Java类都重写了该方法。System.out.println(引用类型变量)可以理解为

System.out.println(引用类型变量.toString())高端IT就业培训专家第十七章访问权限本章目标权限修饰符介绍private、default、protected、public权限修饰符修饰类权限修饰符修饰成员方法权限修饰符修饰成员变量权限修饰符修饰构造方法•final修饰类•final修饰成员变量•final修饰局部变量•final修饰成员方法权限修饰符介绍只影响被修饰元素的作用域，不影响生命周期。作用域是指被修饰的元素在哪些地方可以被访问。权限修饰符有private、default、protected、public,从左到右权限变大权限修饰符可以的元素有类、成员、构造方法成员指成员变量和成员方法权限修饰符修饰类只有default与public可以修饰类，default修饰的类只能在同包中被使用，pulbic修饰的类可以在任何地方被使用。权限修饰符修饰成员四个权限修饰符都可以修饰成员•private成员只能在当前类中被访问•default成员只能在当前类和同一个包中的其它类中被访问•protected成员只能在当前类、同一个包中的其它类和子类中被访问•public成员可能在任何地方法被访问提示：成员被访问的前提是，成员直实存在。权限修饰符修饰成员包内类内包外子类publicyesyesyesyesprotectednoyesyesyesdefaultnonoyesyesprivatenononoyes权限修饰符修饰构造方法四个权限修饰符都可以修饰构造方法构造方法被指定调用的地方有两种。一是在子类构造方法中使用super指定父类的构造方法;二是使用new创建对象构造方法能在哪些地方被指定调用，与饰构造方法权限修饰符有关private

构造方法只能在当前类中被指定调用default

构造方法只能在当前类和同一个包中的其它类中被指定调用protected构造方法只能在当前类、同一个包中的其它类和子类中被指定调用public构造方法可以在任何地方被指定调用finalfinal修饰的类不能被继承final修饰的成员变量（包括实例变量与类变量）是值不能被修饰的成员变量，是一种常量。final修饰的局部变量也是值不能被修饰的局部变量。提示：常量是一种特殊的变量final修饰的方法不能被重写高端IT就业培训专家第十八章抽象类本章目标

抽象类的概念

抽象类的声明语法

抽象类被继承

抽象类引用类型变量引用子类对象

设计中什么思想指导下使用抽象类抽象类的概念使用了关键词abstract声明的类叫作“抽象类”。如果一

个类里包含了一个或多个抽象方法，类就必须指定成

abstract（抽象）。“抽象方法”,属于一种不完整的方法，只含有一个声明，没有方法主体（对类的抽象）。抽象类不能被直接实例化。被abstract修饰的方法是抽象方法，抽象方法只有声明，没有实现，抽象方法只能定义在抽象类或者接口中。抽象类的声明语法抽象类语法：abstractclass<类名>{}抽象方法语法abstract<返回类型><方法名>(参数列表);抽象类被继承抽象类被继承，和普通类被继承是一样的。继承的类将会继承该抽象类的属性和方法，包括那些抽象方法。abstract

class

Animal

{abstract

void

speak();}抽象类被继承普通类继承抽象类class

Cat

extends

Animal

{void

speak(){}}普通类继承抽象类必须实现抽象类中所有的抽象方法。继承类可以被实例化：new

Cat();抽象类被继承抽象类继承抽象类abstract

class

Bug

extends

Animal{}抽象类继承抽象类，不必实现抽象类中所有的抽象方法，继承类也是一个抽象类，因此不可以被实例化。抽象类引用类型变量引用子类对象抽象类可以创建引用类型变量，用于指向其子类对象。Animal

mAnimal

=

new

Cat();此时，mAnimal引用只能调用Animal类中有的方法，以及被Cat类实现的方法，不能调用Cat中新增的方法。可以认为，Cat放弃了Cat的特性，变成了普通的Animal（向上转型）抽象类引用类型变量引用子类对象因此，在任何需要传入抽象类引用参数的方法中，都可以传入该抽象类的子类对象引用（向上转型）。比如：speak（Animal

mAnimal）{}；//Cat是继承于Animal

的普通类speak（new

Cat()）;为什么要使用抽象类如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象

类。抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。在面向对象领域，抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类，而这一组任意个可能的具体实现则表现为所有可能的派生类。比如：把大象放冰箱，总共分3步：打开冰箱，放进大象，关闭冰箱。这一套行为是固定的，但是，具体实现可以有任意多的情况，比如，怎么放进大象，是肢解放还是硬塞？为什么要使用抽象类在设计程序架构时，可以使用抽象类。比如，你知道一个程序算法的骨架，但是在设计之初，你无法确定算法中某些具体步骤。假设，设计一个类，用来计算柱状体的体积，核心的算法骨架是：底面积x

高。但是，在设计之初，无法确定该柱状体的底面积如何计算（不确定是圆形，方形还是三角形）此时，就可以将该类设计成一个抽象类为什么要使用抽象类abstract

class

Column

{double

h;//设置高void

setH(double

h){this.h

=

h;}//不确定的方法abstract

double

getArea();//已知算法double

getVolume()

{return

getArea()

*

h;}}为什么要使用抽象类然后将，具体的柱状体类继承Columnclass

Cylinder

extends

Column

{double

r;//设置底面半径void

setR(double

r){this.r

=

r;}@Override//实现抽象方法，因为确定是圆柱体，因此底面积可以计算出来

double

getArea(){return

3.14

*

r

*

r;}}那么，我们可以这么得到圆柱体体积//创建圆柱体对象Cylinder

cylinder

=

new

Cylinder();//设置圆柱体底面半径

cylinder.setR(1);//设置高

cylinder.setH(10);//计算体积double

v

=

cylinder.getVolume();为什么要使用抽象类还有一种情况也会常用到抽象类，在C/C++中有全局函数，但是在java中，每一个方法都必须放在类中，那么，想达到全局函数的效果应该这么做呢？可以设计一个类，将类中的方法设计成public

static的修饰。又因为，这个类通常是不需要实例化的，它只是作为这一系列函数的容器存在的。因此，可以将这个类设计为抽象类（注意抽象类中可以有抽象方法，也可以没有）。高端IT就业培训专家第十九章接口本章目标

接口介绍

接口的声明语法

实现接口的实现类

接口引用类型变量引用接口实现类对象

设计中什么思想指导下使用接口

普通类与抽象类思想上的区别

抽象类与接口思想上的区别概念接口是一种协议类可以实现接口，实计上就是根据接口协议对类自身进行扩展定义接口格式public

interface

接口名{无素}一般都只使用public修饰接口体中可以有0到多个元素元素有两种公共的静态常量(可省public,static

final)公共的抽象方法(可省public,abstract)接口和抽象区别普通类与抽象类都可以实现接口接口可以被多实现接口可以继承接口(单继承)抽象类与接口思想上的区别抽象类是提取子类的公共代码接口是类遵守接口协议对类进得扩展。接口可以创建引用类型变量（后面讲）一个类可以在继承父类的同时再实现1到多个接口示例高端IT就业培训专家第二十章多态本章目标instanceof运算符多态的概念什么是多态多态主要体现在哪些地地方多态中的回调机制接口或父类引用可以引用子类对象引用类型的类型转换与强制类型转换回调机制instanceof运算符instanceof是二元运算符格式“对象引用

instanceof返回值为boolean型类名或接口名”类名或接口名创建的引用类型变量能引用前面对象引用则返回true,否则返回false如果"对象引用instanceof

类名或接口名"对象引用为null,则通通返回falseinstanceof运算符如果"对象引用instanceof

类名或接口名"对象引用为null,则通通返回false.instanceof前面的对象引用的编译时类型要么与后面的类(或接口)相同或者具有继承（或实现）关系,否则会引发编译错误。多态的概念什么是多态种状态，多种表现形式多态主要体现在哪些地地方编译时才能动态确定相关的元素，父类或接口定义的引用变量可以指向

子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的

那个对象的方法，而不是引用变量的类型中定义的方法多态中的回调机制引用类型提升父类(包括抽象类)创建的引用类型变量可以引用子类对象。父类引用类型变量引用子类对象时，调用方法只能调用父类中出现过的方法，如果方法被重写，真正调用到的是子类中的方法。（解释:父类中出现过的方法理解为父类中的抽象方法或普通方法）接口可以创建引用类型变量，这种变量——接口引用类型变量可以引用接口实现类对象,调用方法时只能调用创建引用类型变量的接口中出现过的方法.引用类型强制转换引用类型强制当引用类型被提升后，不能调用对象所属类中新增加的方法，如果要能调用就得强转引用类型变量当作型参引用类型变量当作型参时怎么传值接口引用类型变量为形参时，只能传接口实现类对象普通类引用类型变量为形参时，可以传普通类对象，也可以传普通类子类对象抽象类引用类型变量为形参时，只能传抽象类子类对象回调机制回调用几乎是所有语言最重要的机制引用类型提升可以实现java中重要的回调，下面请大家一起来举例学习。高端IT就业培训专家第二十一章内部类本章目标内部类的概念局部内部类成员内部类静态内部类匿名内部类内部类分别可以是实例类、抽象类、接口的子类。使用匿名内部类实现回调内部类的概念在类中或类的成员方法中创建的类叫内部类内部类分为可分为四种：成员内部类静态内部类局部内部类匿名内部类不管是哪种内部类，内部类都可以是"普通类"或"抽象类的子类"或"接口的实现类"。成员内部类成员内部类创建在类中，方法外，使用任何访问权限修饰符都是相同效果成员内部类中不可有静态成员外部类可以使用成员内部类，其它类不可能使用内部类成员内部类的实例方法中佣有外部类对象,使用"外部类名.this"获取,所以可以使用"外部类名.this"访问外部类成员（内部类的实例方法中

this表示内部类对象，外部类名.this表示外部类对象）;静态内部类静态内部类创建在类中，方法外，使用static修饰四种访问权限修饰符都可以修饰静态内部类，类可以被任何地方使用，其它类使用静态内部类时，要受静态内部类的权限修饰符影响，这种

影响与类中成员变量或成员方法一样导入静态内部类的包的格式为import...外部类.内部部类只导入外静态内部类的外部类也可以使用静态内部类，只是使用时格式为"外部类.内部类";静态内部类中可以有静态成员变量与静态成员方法静态内部类静态内部类的实例方法中没有外部类对象，所以不能在静态内部类中使用"外部类.this"，即静态内部类只能访问外部类的静态成员，不能访问外部类的实例成员局部内部类方法中定义的内部类局部内部类与局部变量有很多相似之处都不可使用权限修饰符修饰作用域范围相同，都是定义地方起到第一个"}"结束局部内部类佣有外部类对象，即可以使用"外部类名.this"访问外部类成员局部内部类中可访问外部方法的局部变量，但是该局部变量必须是final修饰的。匿名内部类匿名内部类可为外部类成员变量赋值是创建匿名内部类可以在方法体中直接创建并使用，并且可以与局部内部类一样可以访问外部方法的final修饰的局部变量匿名内部类可以为调用方法传参时创建匿名内部类中佣有外部类对象,即可以使用"外部类名.this"访问外部类成员开发中经常使用匿名内部类实现回调高端IT就业培训专家第二十二章异常处理本章目标异常与错误的概念java

API异常类图异常分类：编译型异常与解释型异常异常处理抛出异常处理捕获异常处理自定义异常简介MVC框架中异常的使用异常与错误的概念异常分为抛出异常捕捉异常，只要处理好异常程序不会停止的。异常分类编译时异常解释时异常错误不可处理，程序停止运行java

API异常类图异常处理分类异常处理分类抛出异常处理捕获异常处理捕获异常处理try-catch语句，try－catch-finally语句，try--finallly语句调用有抛出异常的方法必须使用try捕获try

块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。一个try

块可能有多个catch

块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的catch代码块catch

块：用于处理try捕获到的异常。finally块：无论是否捕获或处理异常，finally块里的语句都会被执行。当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，

finally块不会被执行：1）在finally语句块中发生了异常。

2）在前面的代码中用了System.exit()退出程序。

3）程序所在的线程死亡。4）关闭CPU。可嵌套Try-catch-finally执行流程Try-catch-finally执行流程示例图Try-catc