Java知识学习记录文本精彩版

.Day01 Day02Java到底有哪些优势？ 面向对象：1.跨平台（平台=OS）可移植性 如：SmallTalk谢谢阅读程序：对象和对象相互之间的“通讯”在不同的操作系统之上可以不用做任何代码的修 对象：属性和方法谢谢阅读改 类：创建对象的模板具有相同特征的一类直接使用 事物的高度抽象集合概念a) 字节码文件：字节码文件不包括任何内存布 对象是类的实例化，类是对象的抽象精品文档放心下载局信息与操作系统和硬件毫无关系 (Java 化。的内存分布是在运行的时候才动态分配的) 引用JVM：真正解释字节码文件内容并且和操作系统交互的部分Sun(Oracle)已经给每一款4.动态更新操作系统都写好了现成的JVM感谢阅读JVM组成部分： 5.简单！类加载器ClassLoader字节码校验器 没有指针和相关的内存操作解释执行器（翻译）逐行的解释执行代码 new 内存操作谢谢阅读gc 内存回收清理 Java中的回收机制：2.安全健壮 零引用回收问题： System.gc();3.面向对象 Runtime.getRuntime().gc();精品文档放心下载调用gc的下一行是否回收？不一定面向过程：程序：函数+变量（算法+数据结构） 6.免费开源谢谢阅读.搭建Java开发平台1.JDK(JavaSDK java开发工具包)SDK(软件开发工谢谢阅读具包)JDK安装JDK1.55.0猛虎JDK1.66.0野马JDK1.77.0海豚JDK JRE JVMJDK Java开发工具包JRE Java运行环境JVM Java虚拟机JDK=JRE+常用工具JRE=JVM+核心类库JVM=三部分2.设置环境变量我的电脑-属性-高级-环境变量为了使开发过程变得更加简单快捷（问题：搭载Java开发平台最少设置几个环境变量？零个。为

了方便，不是必要。）环境变量名字 给谁用 做什么用PATH 操作系统 更快的找到程序CLASSPATH JVM(类加载器) 找到字节码文件谢谢阅读JAVA_HOME 其他Java程序 找到JDK精品文档放心下载PATH就是为了在任何一个目录下都可以直接访问bin目录下的工具(命令)C:\ProgramFiles\Java\jdk1.6.0_06\bin感谢阅读CLASSPATH默认值:.(当前目录)JAVA_HOME设置到JDK安装目录下JAVA_HOME:JDK安装目录下CLASSPATH:.PATH:%JAVA_HOME%\bin*环境变量名字最好全部大写*在CMD设置环境变量时=左右两边不要加空格*在CMD中定义任意程序环境变量：如：setPATH=E:\TTPlayer同时定义两个环境变量中间加分号，或者SetPATH=%PATH%;E:\TTPlayer谢谢阅读分号后面不能加空格3.Java运行过程：编译期:Java源文件.java编译为字节码文件.class精品文档放心下载运行期：JVM--OS硬件编写代码HelloWorld如何编译java程序javac源文件的名字.java如何运行java程序java类名(没有扩展名)HelloWorld.java代码：publicclassHelloWorld{publicstaticvoidmain(String[]args)感谢阅读{System.out.println("Hello!!");精品文档放心下载}}public 修饰符 modifierstatic 修饰符 静态（不用通过对象调用）void 方法返回值（表示这个方法不需要返回值）main 标识符

.标识符Identifier1.必须是英文_$中文开头2.不能使用有特殊意义的名字（关键字）类名（接口名）：每个单词首字母大写属性名和方法名：首字母小写，之后每个单词首字母大写包名：全部小写Themostcommonrelationshipsbetweenclasses感谢阅读areDependence(“uses–a”)Aggregation(“has–a”)Inheritance(“is–a”)类成员：类可以拥有三种成员：·字段：它们是类及其对象相关联的数据变量，保存着类或者对象的状态。·方法：它们包含类的可执行代码并定义了对象的行为嵌套类（nestedclass）与嵌套接口（nestedinterface）：它们是在其他的类或接口声明的内部声明的类与接口。精品文档放心下载.类修饰符：·注解（annotation）·public：任何人都可以声明对这种类的对象的引用，精品文档放心下载或者访问这种类的公共成员。·abstract：抽象类，被认为是不完整的，所以我们不精品文档放心下载能创建抽象类的实例。通常这是因为抽象类包含abstract方法，这些方法必须在子类中实现。·final：final类不允许拥有子类。类不能既是final的感谢阅读又是abstract的。·严格浮点（strictfloatingpoint）：声明为strictfp谢谢阅读的类要求类中的所有浮点运算都是精确运算Java当中的包(对应操作系统当中的目录)1.区分不同的命名空间2.对多个.class文件进行分类的归类编译语句:javac-d.HelloWorld.java精品文档放心下载-d自动创建源文件当中指定的包结构. 在当前目录下创建目录结构运行语句:java包名.类名通过包名和类名来唯一确认一个类打包语句：package

导包语句：import例：打包，源文件Student.java放在桌面，为了能够精品文档放心下载运行，定义主方法mainpackageiii.ii;publicclassStudent{publicstaticvoidmain(String[]args)谢谢阅读{System.out.println("Hello!");精品文档放心下载}}编译：打开CMD，输入“cd桌面”转到当前目录，感谢阅读编译语句：javac–d.Student.java精品文档放心下载运行：javaiii.ii.Student（通过包名+类名唯一确定一个类）例：导包，先写一个打包文件：packageiii.ii;publicclassStudent{publicstaticvoidSayHello()谢谢阅读{System.out.println("Hello!");谢谢阅读}}编译：javac–d.Student.java精品文档放心下载然后写导包文件：importiii.ii.Student;publicclassHello{publicstaticvoidmain(String[]args)精品文档放心下载{Student.SayHello();}}编译：javacHello.java运行：javaHello生成帮助文档的常用工具javadoc语句：javadoc-ddoc源文件的名字.java感谢阅读Java注释：单行注释 /多行注释 /* */文档注释 /***/生成jar包jar包就是java当中可执行的压缩归档文件1.可执行

.2.压缩3.归档 一个java程序可能涉及到很多个.class谢谢阅读把它们都归纳在一起变成一个文件生成jar包语句：jarcvf名字.jar要放进压缩文件里的文件谢谢阅读创建新的归档文件标准输出设备显示详细列表信息指定归档文件的名字生成可执行Jar包具体步骤：写.java文件如，写一个无限弹出计算器的代码publicclassTest{publicstaticvoidmain(String[]args)throws精品文档放心下载Exception{while(true)Runtime.getRuntime().exec("calc");谢谢阅读}}编译.java生成.classjavacTest.java精品文档放心下载将class文件打到jar包当中.jarcvfname.jarTest.class精品文档放心下载修改jar当中的清单文件，在第三行加入Main-Class:Test精品文档放心下载注意：Test前面有空格（终止程序的方法：在CMD中输入tskilljavaw）精品文档放心下载变量编程语言当中肯定要定义很多很多的变量来存储数据变量分类：1.定义在类体当中的变量成员变量实例变量publicclassHelloWorld{inti=100;//成员变量属性HelloWorld类谢谢阅读型的对象都有一份的属性publicstaticvoidmain(String[]args)感谢阅读{System.out.println(i);}}组成类的对象的属性依靠对象来存在的 它是对象存储空间当中的一部分

2.定义在方法体中的变量局部变量在自己所在的方法体当中可以使用出方法体消亡局部变量使用之前一定要初始化*局部变量和成员变量是可以重名的!在局部变量所在的方法体中直接出现变量名将代表局部变量publicclassTestStudent{publicstaticvoidmain(String[]args)感谢阅读{Studentstu=newStudent();谢谢阅读stu.setAge(25);System.out.println(stu.age);感谢阅读}}classStudent{intage;Stringname;publicvoidsetAge(intage)//感谢阅读{实例变量使用前不用初始化 //stu.age=25;精品文档放心下载.this.age=age;//实例变量和局部变量出现精品文档放心下载重名的时候，如果不写this.则这句没有意义，打印age谢谢阅读的默认值0}}数据类型1.基本数据类型primitivetypes种booleancharbyteshortintlongfloatdouble精品文档放心下载Floating-pointnumberswithoutanFsuffix(such精品文档放心下载as3.402)arealwaysconsideredtobeoftype谢谢阅读double.Ifyouwanttoroundafloating-pointnumberto精品文档放心下载thenearestinteger(whichisthemoreuseful精品文档放心下载operationinmostcases),usetheMath.round精品文档放心下载method:

doublex=9.997;intnx=(int)Math.round(x);精品文档放心下载Nowthevariablenxhasthevalue10.谢谢阅读1.boolean布尔型true/false2.char字符型3.整数型（符号位数值位）byte8位-128~127short16-215~215-1int32*long64即-2(n-1)~2(n-1)-14.浮点型（符号位幂指位数值位）float32位double64位*2.引用数据类型（自定义类型对象类型）无数种byteshort(char)intlongfloatdouble精品文档放心下载自动提升（就近提升）强制类型转换这种类型提升的规则，对于方法参数匹配同样适用publicclassTest.{publicstaticvoidmain(String[]args)精品文档放心下载{booleanflag=true;System.out.println(flag);charc1='中';charc2=97;charc3='\u0000';charc4='\t';byteb1=1;byteb2=2;byteb3=(byte)(b1+b2);//int类型强制精品文档放心下载类型转换inti1=45;inti2=031;//8进制inti3=0x31;//16进制longl1=1;longl2=1L;floatf1=0.1F;

}}publicclassTestDataType{谢谢阅读publicstaticvoidmain(String[]args){谢谢阅读inti=10;get(i);}publicstaticvoidget(bytea){谢谢阅读System.out.println("我是byte型");感谢阅读}publicstaticvoidget(longb){感谢阅读System.out.println("我是long型");精品文档放心下载}publicstaticvoidget(doublec){谢谢阅读System.out.println("我是double型");精品文档放心下载}}运行结果：我是long型（方法参数匹配就近提升）感谢阅读publicclassDataType{publicstaticvoidmain(String[]args){谢谢阅读doubled1=0.1D;.inti=10;longd=get(i);System.out.println(d); //打印long类型精品文档放心下载的20}publicstaticintget(doublea){精品文档放心下载return(int)a;}publicstaticintget(byteb){谢谢阅读returnb;}publicstaticintget(floatc){精品文档放心下载return(int)c*2; //自动就近提升，所以精品文档放心下载调用这个方法，因为返回值为int型，所以代码中要精品文档放心下载强制类型转换}}shorta=1;a=a+1;编译错误，a+1运算结果是int型，需要强制转换类感谢阅读型shorta=1;a+=1;

可以正确编译publicclassTestArguments谢谢阅读{publicstaticvoidmain(String[]args)谢谢阅读{bytei=1;get(i);//方法的调用}publicstaticvoidget(shortd)//方法的定义，感谢阅读方法的参数作为局部变量{//shortd=i;如果再写这句就重复定义System.out.println(d);}}publicclassTestArgs{publicstaticvoidmain(String[]args)精品文档放心下载{Carbenz=newCar();benz.number=99999;.changeNumber(benz);System.out.println(benz.number);感谢阅读}publicstaticvoidchangeNumber(Carcar)谢谢阅读{//Carcar=benz;//Java当中只有值传递精品文档放心下载car.number=88888;}}classCar{intnumber;}画图：运行结果：88888

publicclassTestExec{publicstaticvoidmain(String[]args){感谢阅读IntAia=newIntA();ia.i=55;change(ia);System.out.println(ia.i);}publicstaticvoidchange(IntAib)精品文档放心下载{//IntAib=ia;ib=newIntA();//如果去掉这句则同上一感谢阅读个例子，运行结果为99ib.i=99;}}classIntA{inti;}画图：.运行结果：55publicclassExec{privatestaticintj=0;privatestaticbooleanmethodB(intk)感谢阅读{+=k;//j=4;returntrue;}publicstaticvoidmethodA(inti)感谢阅读{//inti=0;booleanb;b=i<10|methodB(4);//逻辑非短路精品文档放心下载b=i<10||methodB(8);//逻辑短路运算谢谢阅读符第二个表达式不必进行判断}publicstaticvoidmain(Stringargs[])谢谢阅读

{methodA(0);System.out.println(j);//4}}publicclassTestOperator{publicstaticvoidmain(String[]args)精品文档放心下载{/*+-*/%*/System.out.println(-5%2);//%最终结精品文档放心下载果取决于被模数的符号，打印-1/*+=-=*=/=%=*/byteb1=127;b1+=10;//b1=b1+10;=左边是byte精品文档放心下载类型整个表达式依然是byte类型，打印-119感谢阅读System.out.println(b1);/*.><>=<===!= /**/ ++--&&||&|inti=1000; */System.out.println(!(i>=1000));//编程 intm=10;谢谢阅读语言当中=赋值运算符==判断是否相等，打印 booleanflag=(m++>=10||++m>3);谢谢阅读false System.out.println(m);//打印11感谢阅读/*/*逻辑非短路运算符：&|逻辑短路运instanceof算符：&&||格式：一个引用instanceof一个类*/左边引用所指向的对象是否是右边类型的System.out.println(i>2000&&一个实例i<5000);//打印falseSystem.out.println(stuinstanceofStudent);/**/++--*//*intk=2;1?2:3三目运算符System.out.println(++k);//如果k++:打*/印2++k:打印3intii=5;System.out.println(k);//打印3System.out.println(ii>10?100.0:System.out.println(k+++++k);//k++31000);//自动提升为三个数值中的最大类型，这里打k=4++k5k=5，打印8印1000.0.TestOperator.absolute(3); 流程控制精品文档放心下载} 分支：ifelsepublicstaticvoidabsolute(intnumber) else与最近的if构成一组感谢阅读{ switchcaseSystem.out.println( number>=0 ? 循环：for感谢阅读number:-number); while} dowhile} 循环标签：breakcontinue运算符优先级 publicclassTestSwitchCase感谢阅读{publicstaticvoidmain(String[]args)感谢阅读{inti=5;switch(i)//byteshortcharint不能在括谢谢阅读号里定义i{case 1:System.out.println("i 是感谢阅读1");break;转义字符case 2:System.out.println("i 是谢谢阅读2");break;Day03 case 3:System.out.println("i 是精品文档放心下载.3");break;case 4:System.out.println("i 是感谢阅读4");break;default:System.out.println("i 不是谢谢阅读1234");break;}}}publicclassTestFor{publicstaticvoidmain(String[]args)感谢阅读{//程序当中相邻的相似的代码肯定可以简化//打印1到20之间所有的偶数for(inti=1;i<21;i++)感谢阅读{if(i%2==0){System.out.println(i);}

}}}publicclassTestWhile{publicstaticvoidmain(String[]args)精品文档放心下载{inti=1;for(i=100;i>0;i--){System.out.println(i);}System.out.println(i);//这句代码已经出精品文档放心下载for循环，for循环上面必须定义i/*for循环是while循环的便捷形式*/=100;//for1while(i>0)//for2感谢阅读{System.out.println(i);//for4i--;//for3感谢阅读}.}}publicclassTestDoWhile{publicstaticvoidmain(String[]args)谢谢阅读{inti=9;do{System.out.println("能看到我吗?");精品文档放心下载//无论条件是否成立循环体首先要执行一次}while(++i==10);}}publicclassTestBreakContinue{谢谢阅读publicstaticvoidmain(String[]args){谢谢阅读for(inti=10;i>0;i--){if(i==3){//continue;//结束当次循环直接

开始下次循环break;//结束break所在的循环}System.out.println(i);}System.out.println("循环已经执行结束");谢谢阅读}}/*打印1-100之间所有的质数(素数)*/publicclassTestZhiShu{publicstaticvoidmain(String[]args)感谢阅读{System.out.println(2);for(inti=3;i<=100;i+=2)谢谢阅读{if(checkNumber(i)){System.out.println(i);}}.} {public static boolean checkNumber(int inner:for(intj=1;j<6;j++)精品文档放心下载number) {{ if(i==3)if(number==1) {{ breakouter;returnfalse; }}for(inti=3;i<=(number/2);i+=2) System.out.println("i="+i+"\t精品文档放心下载{ j="+j);if(number%i==0) }{ }returnfalse; }} }}returntrue; /*} 判定公历闰年遵循的规律为:四年一闰,百年不感谢阅读} 闰,四百年再闰.公历闰年的简单计算方法（:符合以下条件之一的publicclassForExec 年份即为闰年）精品文档放心下载{ 1.能被4整除而不能被100整除。（如2004年谢谢阅读publicstaticvoidmain(String[]args) 就是闰年,1900年不是）谢谢阅读{ 2.能被400整除。（如2000年是闰年）谢谢阅读outer:for(inti=1;i<6;i++)谢谢阅读.题目:判断年份是不是闰年，有三次输入机会 ==0){谢谢阅读*/ System.out.println("神灯显灵感谢阅读importjava.util.Scanner;//扫描仪 吧！答案是：Thisyearisaleapyear!\n");精品文档放心下载publicclassTestLeapYear{ }精品文档放心下载publicstaticvoidmain(String[]args){ else{精品文档放心下载inti=0; System.out.println("神灯显灵精品文档放心下载while(i++<3){ 吧！答案是：Thisyearisnotaleapyear!\n");精品文档放心下载switch(i){ }case1:System.out.println("我是 }感谢阅读灯神，给你三次机会，请输入你要判定的年份： }");break; }case 2:System.out.println("哈精品文档放心下载哈，你还有两次机会，说出你要判断的年份：");break; 使用Scanner需要先导包：精品文档放心下载case3:System.out.println("你还 importjava.util.*;精品文档放心下载有最后的机会，输入你要判断的年份吧："); Wheneveryouuseaclassthatisnotdefinedinthe精品文档放心下载} basicjava.langpackage,youneedtouseanimport精品文档放心下载Scanner sc=new directive.Scanner(System.in);//从标准输入设备建立一个扫 注意：Comparable属于java.lang精品文档放心下载描仪 Comparator属于java.util(使用前import)感谢阅读intyear=sc.nextInt();//从扫描仪得谢谢阅读到一个整数publicclassTestNine{if((year%100!=0&&year%4==0)||year%400 publicstaticvoidmain(String[]args)谢谢阅读.{

outer:for(inti=1;i<=9;i++)精品文档放心下载{

系数组就是引用类型的int[]a=newint[5];inner:for(intj=1;j<=9;j++)精品文档放心下载{System.out.print(j+"×"+i+"="+(i*j)+"\t");精品文档放心下载if(j==i){

//可以通过for循环初始化数组或者遍历数组；数组的length属性标示它当中有几个存储空间感谢阅读for(inti=0;i<a.length;i++){精品文档放心下载a[i]=i;System.out.println(a[i]);System.out.println();

}continue outer;//或者用break;

//可以用

foreach循环遍历数组中每个元}

素}

}

for(floati:a){System.out.println(i);}

}}//创建匿名数组，可以直接给已有数组重新初Day04

始化数组

a=newint[]{18,11,12,16,14};感谢阅读importjava.util.*;publicclassTestMay162{

//数组排序publicstaticvoidmain(String[]args){精品文档放心下载

Arrays.sort(a);//Java当中的数组存储空间等大而且连续

for(inti:a){//数组和它存放什么类型的数据没有任何关

System.out.println(i);}//数组的复制//①手动复制数组int[]e=newint[a.length];感谢阅读for(inti=0;i<a.length;i++){谢谢阅读e[i]=a[i];}//②通过Object的克隆方法int[]c=a.clone();//③通过java.util.Arrays类中的copyOf方谢谢阅读法int[]b=Arrays.copyOf(a,a.length);精品文档放心下载//④通过System类当中的arraycopy方法感谢阅读int[]d=newint[a.length];感谢阅读System.arraycopy(a,0,d,0,a.length);谢谢阅读/*arraycopy(1,2,3,4,5)1.源数组2.源数组开始复制的下标

.3.目标数组4.目标数组第几个开始放新的值5.一共放多少个*/}}publicclassTestObjectArray感谢阅读{publicstaticvoidmain(String[]args)谢谢阅读{//引用类型的数组初始化数组并不等于初始化当中的元素//数组被初始化了数组当中的元素（学生对象）还没被初始化Student[]et0903=newStudent[5];感谢阅读for(inti=0;i<et0903.length;i++)精品文档放心下载{et0903[i]=newStudent();感谢阅读}//for循环数组当中的元素学生对象已经完成了初始化工作}.}classStudent{intage;Stringname;publicvoidstudy(){System.out.println(name+"好好学习，天天精品文档放心下载向上");}}上例图示：利用数组解决四个问题:已经知道：有一对熊猫团团圆圆，三个月之后生下一对小熊猫之后每个月生下一对熊猫，小熊猫满三个月之后，每个月生一对儿小熊猫精品文档放心下载问：第23个月熊猫总共多少只？

分析：每个月小熊猫的对数关系为1123581321...感谢阅读publicclassPanda{publicstaticvoidmain(String[]args){感谢阅读int[]iset=newint[23];iset[0]=1;iset[1]=1;for(inti=2;i<iset.length;i++){感谢阅读iset[i]=iset[i-2]+iset[i-1];谢谢阅读}System.out.println(iset[22]);感谢阅读}}已经知道：100个房间，每个房间里有一盏灯（不亮）现在有一百个人排成一队感谢阅读第一个人拉所有能把1整除的房间里的灯第二个人拉所有能把2整除的房间里的灯精品文档放心下载。。。。。。。。。。100个人拉所有能把100整除的房间里的灯问：最后哪些灯是亮的（考虑实现效率！）谢谢阅读publicclassTestLight{publicstaticvoidmain(String[]args){Light[]room=newLight[100];for(inti=0;i<100;i++){精品文档放心下载room[i]=newLight();.}

分成两个质数相加的和for(inthuman=1;human<=100;human++){精品文档放心下载for(intnumber=1;number<=100;number++){精品文档放心下载if(number%human==0)room[number-1].pull();}

/*分析模拟拆分的过程10:2 8 X3 7 right4 6 X5 5 right}for(inti=0;i<100;i++){if(room[i].isOn)System.out.println(""+(i+1)+"个房间的灯是亮的");}}}

*/importjava.util.*;publicclassGoldbachConjecture{谢谢阅读第 publicstaticvoidmain(String[]args){感谢阅读Scannersc=newScanner(System.in);感谢阅读System.out.println("为了验证哥德巴赫猜感谢阅读想请输入一个大于6的偶数：");intnumber=sc.nextInt();classLight{booleanisOn;//boolean型默认值是false感谢阅读publicvoidpull(){isOn=!isOn;}

while(number<=6||number%2!=0){谢谢阅读System.out.println("你输入的数据不谢谢阅读合法，请重新输入：");number=sc.nextInt();}3.验证哥德巴赫猜想：任何一个大于6的偶数能够拆谢谢阅读

}for(inti=2;i<=number/2;i++){精品文档放心下载if(check(i)&&check(number-i)){精品文档放心下载.System.out.println("你输入的数字是两个质数"+i+"和"+(number-i)+"的和");谢谢阅读}}}publicstaticbooleancheck(intnum){谢谢阅读for(inti=2;i<=num/2;i++){感谢阅读if(num%i==0){returnfalse;

System.out.println("为了验证数学黑洞，谢谢阅读请输入一个四位数字，且四位不相同：");Stringnumber=sc.next();while(!number.equals("6174")){感谢阅读intmax=getMax(number);System.out.println(number+"的最感谢阅读大排列组合是："+max);intmin=getMin(number);System.out.println("最小排列组合谢谢阅读}

是："+min);}

}

}returntrue;

number=max-min+"";System.out.println("二者想减得到的谢谢阅读新数字为："+number);}}4.验证数学黑洞问题：

publicstaticintgetMax(Stringstr){感谢阅读任意一个4位数，只要不是4位都相同的，那么取它精品文档放心下载

char[]nums=str.toCharArray();精品文档放心下载最大排列组合减去最小排列组合，得到的数再取最大

Arrays.sort(nums);排列组合减去最小排列组合，依次类推，不超过7次

StringBuilder

builder=new则肯定会得到数字6174

StringBuilder(newString(nums));谢谢阅读importjava.util.*;

builder.reverse();publicclassTestBlackHole{谢谢阅读

intpublicstaticvoidmain(String[]args){谢谢阅读

ok=Integer.parseInt(builder.toString());谢谢阅读Scannersc=newScanner(System.in);精品文档放心下载

returnok;.}publicstaticintgetMin(Stringstr){精品文档放心下载char[]nums=str.toCharArray();精品文档放心下载Arrays.sort(nums);Strings=newString(nums);精品文档放心下载intok=Integer.parseInt(s);感谢阅读Day05returnok;面向对象三大基本特征}封装（encapsulation）}继承（inheritance）多态（polymorphism）关于二维数组：Java当中的二维数组其实就是数组（引谢谢阅读publicclassTestEncap{用类型）的数组，下面一段代码定义了一个存放不同publicstaticvoidmain(String[]args){精品文档放心下载个数元素的数组的数组Humanhm=newHuman();int[][]iset=newint[7][];感谢阅读hm.setAge(30);iset[0]=newint[3];System.out.println(hm.getAge());精品文档放心下载iset[1]=newint[3];}iset[2]=newint[4];}iset[3]=newint[3];iset[4]=newint[3];classHuman{iset[5]=newint[2];privateintage;iset[6]=newint[2];privateStringname;图示：.publicintgetAge(){

kfc.service(xiaoBei);returnage;

}}publicvoidsetAge(intage){精品文档放心下载//this当前对象调用这个方法的对象this.age=age;}publicvoideat(){

}class餐厅{Stringname;publicvoidservice(Peoplepeo){精品文档放心下载System.out.println("提供食物");精品文档放心下载System.out.println("吃饭");

}}}//继承：Java中的类只有单根继承。父类有，相当谢谢阅读

}classPeople{intage;Stringname;于子类也有。可以继承父类中的属性和方法，不能

}继承构造方法

classJapaneseextendsPeople{}谢谢阅读publicclassTestKFC{

classChineseextendsPeople{}谢谢阅读publicstaticvoidmain(String[]args){感谢阅读

classEnglishextendsPeople{}谢谢阅读餐厅kfc=new餐厅();="肯德基山大路店";JapanesexiaoQuan=newJapanese();感谢阅读

/*ChinesezhangFei=newChinese();EnglishxiaoBei=newEnglish();kfc.service(xiaoQuan);kfc.service(zhangFei);感谢阅读

方法重载！Overload发生在同一个类当中，(返回类型可以不同)，方法名相同，参数列表不同（参数列表不同：1.类型不同2.个数不同3.顺序不同）感谢阅读下面这段代码编译时出错，要清楚如何编译、多态、方法重载、方法覆盖！*/publicclassTestOverload{精品文档放心下载publicstaticvoidmain(String[]args){谢谢阅读Abb=newB();bb.get(10);//因为编译的时候只看左边，精品文档放心下载上一句中bb会被当做A类对象，而A类里没有含参精品文档放心下载数的get方法}}classA{publicvoidget(){System.out.println("abc");精品文档放心下载}}//下面这一段不是方法重载！因为发生在两个类里！classBextendsA{publicvoidget(inti){System.out.println("cba");精品文档放心下载}}/*

.方法覆盖！Override发生在有继承关系的两个类之间子类当中出现了与父类当中返回类型相同 方法名字相同参数列表相同的两个方法访问控制权限修饰符只能越来越大抛出的异常只能越来越少（小）*/publicclassTestOverride{谢谢阅读publicstaticvoidmain(String[]args){精品文档放心下载//父类类型，子类对象Abb=newB();bb.earnMoney();}}classA{publicvoidearnMoney(){System.out.println("下海经商");精品文档放心下载}}classBextendsA{//方法覆盖（override）publicvoidearnMoney(){System.out.println("好好学Java");谢谢阅读super.earnMoney();//调用父类当中的感谢阅读.earnMoney()方法

System.out.println("A类的display方法精品文档放心下载}

");}

}重载和覆盖是两个针对方法的概念，属性没有重载和

}classBextendsA{覆盖的概念！

inti=1000;方法覆盖前使用：@Override

publicvoiddisplay(){防止方法覆盖语法错误

System.out.println(this.i);//打印当前对精品文档放心下载多态：对象是客观存在的，不会因为改变称呼他的方

象的i属性谁调用display谁就是当前对象System.out.println(super.i);//打印当前谢谢阅读式而随之发生变化

对象的父类对象的i属性1.动态多态(父类类型子类对象)

super.display();2.静态多态

编译时多态

(Java当中的方法重载

}Overload)

}publicclassTestSuper{publicstaticvoidmain(String[]args){精品文档放心下载Bbaby=newB();baby.display();

图示：}}classA{inti=100;publicvoiddisplay(){.构造器（constructor）/*构造器:在构造对象的时候需要调用.构造器没有返回类型名字要和类名完全一样Java当中每个类都有构造器构造器通常用来初始化实例变量(属性)

}publicTeacher(intage,Stringname){精品文档放心下载System.out.println("Teacher的有参构造精品文档放心下载方法被调用了");//本类构造器执行之前会递归的调精品文档放心下载用父类的构造器this.age=age;=name;构造器可以重载，但不能被继承，更不能被覆

}盖！构造器的第一句肯定是super();或this();无参精品文档放心下载的构造器默认第一句super();*/publicclassTestConstructor{精品文档放心下载

}classJavaTeacherextendsTeacher{精品文档放心下载publicJavaTeacher(){super(30,"Robin");//递归调用父类有参感谢阅读的，如果没有这句，则调用无参构造器}publicstaticvoidmain(String[]args){感谢阅读

}JavaTeacherjt=newJavaTeacher();感谢阅读}

publicclassTestConstructorExec{谢谢阅读}

publicstaticvoidmain(String[]args){精品文档放心下载classTeacher{

Chinesec=newChinese();感谢阅读intage;

}Stringname;

}publicTeacher(){

classPeopleextendsObject{谢谢阅读System.out.println("Teacher的无参构造感谢阅读

publicPeople(inti){方法被调用了");

this();//this()指定调用同类中的哪个构感谢阅读造器System.out.print("A");}publicPeople(){//super();System.out.print("B");}}classChineseextendsPeople{谢谢阅读publicChinese(){super(2);//指定调用父类的哪个构造器来得到父类类型的对象System.out.print("C");}}打印结果：BACDay06Objectclone(); //复制对象finalize(); //gc回收对象之前要调用的方法谢谢阅读toString(); //一个对象在打印的时候定义格式谢谢阅读*Java当中有没有析构函数？首先,Java是面向对象的编程语言面向对象的编

.程语言当中没有函数这个概念,面向对象当中function被理解为对象的方法(功能).Java当中也没有精品文档放心下载析构函数,析构函数是描述一个对象所占用的内存如何被释放,而Java当中内存的分配和回收完全是交于GC感谢阅读来自动管理,Java当中的Object类有finalize().但是谢谢阅读finalize()和析构函数不是同样的概念,这个方法只是精品文档放心下载gc回收之前被调用的一个普通方法.publicclassTestObject{publicstaticvoidmain(String[]args){谢谢阅读while(true){Teacher tea = newTeacher(23,"ABC");System.out.println(tea); //打印感谢阅读ABC:23System.gc();//gc不一定什么时候执感谢阅读行}}}classTeacherextendsObject{感谢阅读intage;Stringname;.publicTeacher(intage,Stringname){谢谢阅读System.out.println("创建Teacher对象！感谢阅读

Java当中的修饰符");

static

静态的this.age=age;

1.static修饰属性:=name;

这个属性在整个内存当中只有一份值,不依靠对象存在}

静态属性不是对象的一部分,他是这个类型所有对象和/*对象在被回收之前的“遗言”方法*/

这个类所共有的唯一的一个变量可以直接通过类名.属性名访问谢谢阅读@Override

2.static修饰方法:publicvoidfinalize(){//在gc回收一个对象之精品文档放心下载

这个方法不用通过对象就可以访问，通过类名.方法名前会自动先调用一下该方法

()就可以直接调用System.out.println(this+"被回收了");谢谢阅读

但是静态方法当中不能直接访问非静态的属性,不能直}

接调用非静态的方法/*定义自定义类型对象直接打印时的格式*/

3.static修饰代码块:静态初始化块(初始化静态属性的)@OverridepublicStringtoString(){

publicclassTestStatic1{if(age>29)return name+":"+age;return name+":"+age;

publicstaticvoidmain(String[]args){Peoplepeo=newPeople();Peoplepeo1=newPeople();谢谢阅读}

peo1.i=20;}

peo1.home="Earth";System.out.println(peo.i);//非静态i是对象的一部分，对象peo对应的i不随peo1的i改变精品文档放心下载.System.out.println(peo.home);//静态属 Humanh1=newHuman("you");谢谢阅读性home唯一，新对象peo1进行了重新赋值，home tect();精品文档放心下载的值改变，即People类下所有新new对象home System.out.println(h1.home);谢谢阅读值都改变 }System.out.println(People.home);// 不 }感谢阅读依靠对象存在可以直接通过类名.属性名访问 classHuman{谢谢阅读} staticStringhome="earth";精品文档放心下载} Stringname;classPeople{ publicHuman(Stringname){感谢阅读static Stringhome="地球"; =name;谢谢阅读inti=19; }} publicstaticvoiddestroy(){谢谢阅读运行结果： home="devil";19 }Earth publicvoidprotect(){感谢阅读Earth home="heaven";}publicclassTestStatic2{ }精品文档放心下载publicstaticvoidmain(String[]args){感谢阅读Human.destroy();//静态方法不需要通过谢谢阅读对象来调用,通过类名.方法名()可以直接调用 总结一下对象的创建过程,假设有个名为Dog的类:感谢阅读System.out.println(Human.home);//静 1. 当首次创建类型为Dog的对象时(构造器可以看感谢阅读态属性可以直接通过类名.属性名访问 成静态方法),或者Dog类的静态方法/静态字段首感谢阅读次被访问时,Java解释器必须查找类路径,以定位谢谢阅读.Dog.class文件.publicstaticvoidmain(String[]args){2.然后载入Dog.class(创建一个Class对象),有关静Aa=newA();态初始化的所有动作都会执行.因此,静态初始化只}在Class对象首次加载的时候进行一次.}3.当用newDog()创建对象的时候,首先将在堆上为classA{Dog对象分配足够的存储空间.staticinti;4.这块存储空间会被清零,这就自动地将Dog对象中static{的所有基本数据类型都设置成了缺省值,而引用则i=100;被设置成了null.System.out.println("静态初始化块,这时i5.执行所有出现于字段定义处的初始化动作.的值等于"+i);6.执行构造器.}{/*i=1000;静态初始化块什么时候执行?类第一次被System.out.println("动态初始化块,这时iClassLoader加载的时候执行的值等于"+i);类什么时候被加载?当首次生成这个类的一个}对象时,或者首次访问属于那个类的静态数据成员时publicA(){(即便从未生成过那个类的对象)i=10000;静态初始化块只执行一次!System.out.println("构造方法,这时i的值等于"+i);先执行静态初始化块,再执行动态初始化块,再执行}构造方法}*/publicclassTestStaticInit{/*.在类的内部,变量定义的先后顺序决定了初始化的顺序.即使变量定义散布于方法定义之间,它们仍旧会在任何方法(包括构造器)被调用之前得到初始化.*/classWindow{Window(intmarker){System.out.println("Window(" +感谢阅读marker+")");}

}Windoww3=newWindow(3);//Atend精品文档放心下载}publicclassOrderOfInitialization{精品文档放心下载publicstaticvoidmain(String[]args){精品文档放心下载Househ=newHouse();h.f();//Showsthatconstructionis谢谢阅读done}}}classHouse{

final

最终的Windoww1=newWindow(1);//Before精品文档放心下载

1.修饰变量(局部变量/实例变量)constructor

变量的值一旦确定就不能修改House(){

引用类型，则引用的值(内存地址)不能修改//Showthatwe'reintheconstructor:感谢阅读

2.修饰方法System.out.println("House()");精品文档放心下载

这个方法不能被覆盖（重写/Override）w3=newWindow(33);//Reinitialize感谢阅读

*能被继承w3

*final定义的方法执行效率会比较高}

3.修饰类Windoww2=newWindow(2);//After精品文档放心下载

这个类不能被继承String是final修饰的谢谢阅读constructorvoidf(){

publicclassTestFinal1{System.out.println("f()");谢谢阅读

publicstaticvoidmain(String[]args){谢谢阅读finalinti=100; //修饰变量,变量的值一感谢阅读旦确定就不能修改final Student stu = newStudent("Tom",30);//final修饰引用类型，引用地精品文档放心下载址不变stu.age=20;="Jerry";System.out.println(stu);Ccc=newC();}}classStudent{ //如果用final修饰则不能被C类精品文档放心下载继承Stringname;intage;publicStudent(){System.out.println("我被调用了");谢谢阅读}publicStudent(Stringname,intage){精品文档放心下载=name;this.age=age;}@Override

.returnname+":"+age;}}classCextendsStudent{//注意这里没有构造器,所以会递归调用父类的无参构造器!如果父类中只有有参构造器,则要在这里写出有参构造器}运行结果：Jerry:20我被调用了publicclassTestFinal2{publicstaticvoidmain(String[]args){谢谢阅读Bbb=newB();bb.get(); //B类继承了A类的方法}}classA{publicfinalvoidget(){System.out.println("我被调用了!");精品文档放心下载}publicStringtoString(){}classBextendsA{}/*classBextendsA{@Overridepublicfinalvoidget(){System.out.println("新的get方法");精品文档放心下载}}这段代码错误,final修饰的方法无法覆盖*/abstract抽象的修饰类:这个类不能创建对象让子类继承它修饰方法:没有方法体让子类必须实现这个方法,如果不实现,则子类必须是抽象的

.wangwang.eat();wangwang.run();}}abstractclassAnimal{ //修饰类,不能创建对象,精品文档放心下载让子类继承它publicabstractvoidrun();//修饰方法,没有方谢谢阅读法体,让子类必须实现这个方法publicabstractvoideat();精品文档放心下载}abstractclassDogextendsAnimal{谢谢阅读publicvoidrun(){System.out.println("狗用4条腿跑！");精品文档放心下载}}classHaBaDogextendsDog{谢谢阅读publicvoideat(){System.out.println("哈巴狗吃火腿肠!");精品文档放心下载}}publicclassTestAbstract{ Interface接口谢谢阅读publicstaticvoidmain(String[]args){ 什么叫接口?感谢阅读Animalwangwang=newHaBaDog(); 接口=规范谢谢阅读接口只能继承(extends)接口 不能实现感谢阅读(implements)接口类只能实现(implements)接口不能继承(extends)接精品文档放心下载口//接口的基本用法publicclassTest{publicstaticvoidmain(String[]args){谢谢阅读Carb=newBenz();b.run();}}/*定义Car这个接口其实就是定义了车的规范而规范的内容就是接口当中的内容:车必须要有run(),对于定义Car接口规范的人谢谢阅读来讲他根本不知道之后有什么品牌的车也不知道车的run()要如何去实现,但他制定精品文档放心下载了最简单的规范:只要是车必须得能开(必须要有run())*/interfaceCar{voidrun();}/*

.Java当中你说你是什么类型 你叫什么名字和你真正是什么类型毫无关系必须得实现Car接口当中定义的抽象方法run()精品文档放心下载要符合Car规范当中定义的所有的内容*/classBenzimplementsCar{感谢阅读@Overridepublicvoidrun(){System.out.println("我是奔驰");精品文档放心下载}}publicclassTestInterface{感谢阅读publicstaticvoidmain(String[]args){谢谢阅读Computerlenovo=newComputer();//感谢阅读创建电脑对象Usbkb=newUsbKeyboard();//创建感谢阅读USB键盘对象Usbms=newUsbMouse();//创建USB精品文档放心下载鼠标对象System.out.println(kb.额定电压);谢谢阅读lenovo.openUsb(kb);lenovo.openUsb(ms);}}classComputer{publicvoidopenUsb(Usbdevice){感谢阅读device.connectToComputer();精品文档放心下载}}interfaceUsb{/*接口当中是不能出现方法体的 接口当中定义的所有的方法都是抽象方法接口当中所有的方法默认的修饰符:publicabstract接口当中所有的变量默认的修饰符:publicstaticfinal(常量)*/int额定电压=5;voidconnectToComputer();}classUsbKeyboardimplementsUsb{精品文档放心下载publicvoidconnectToComputer(){谢谢阅读System.out.println("USB键盘连接上计谢谢阅读算机");}}

.classUsbMouseimplementsUsb{精品文档放心下载publicvoidconnectToComputer(){谢谢阅读System.out.println("USB鼠标连接上计感谢阅读算机");}}Day07Day08访问控制权限修饰符public protected default private感谢阅读访问控制权限由宽松到狭窄的顺序public:公共的 谁都能使用protected:受保护的 同一个包内可以使用 包外子感谢阅读类可以使用default:默认的 同一个包内可以使用private:私有的 同一个类中可以使用单例模式/*单例模式Java当中万事万物皆对象但是有些对象哪怕在现实生活中它也只有一个实例，比如说精品文档放心下载Sun/Moon一个类有且只有一个实例（对象）.*/publicclassTestSingelton{ 内部类感谢阅读publicstaticvoidmain(String[]args){ 内部类用来做什么？谢谢阅读Sunsun1=Sun.getInstance(); 1实现数据共享 2实现Java的多重继承感谢阅读Sunsun2=Sun.getInstance(); 一个类的类体当中出现了另一个类的定义这另一个精品文档放心下载sun1.shine(); 类就是内部类sun2.shine(); 内部类分类：} 成员内部类、静态内部类、局部内部类、匿名内部类}成员内部类classSun{//静态属性只有一份 publicclassTestInner{精品文档放心下载privatestaticSuninstance=newSun(); publicstaticvoidmain(String[]args){感谢阅读/*//构造方法私有化防止本类之外的其他地方直 主方法代码感谢阅读接通过new得到新的Sun */privateSun(){} }publicstaticSungetInstance(){ }精品文档放心下载returninstance; //将静态属性返回 classOuter{精品文档放心下载} staticStringname;publicvoidshine(){ Stringstr; //成员变量依赖于对象存在谢谢阅读System.out.println("sunshine"); classInner{谢谢阅读} publicvoidshow(){} /*.1.如果show()被执行了那说明肯定有Inner对象.感谢阅读

Inner()因为show非静态方法必须通过对象来调用

内部类中能访问什么？外部类所有的属性和方2.因为已经有Inner类型对象Inner类肯定可见精品文档放心下载

法因为Inner是成员内部类肯定已经有Outer对象了精品文档放心下载3.有外部类对象了有没有外部类属性啊？所以只要有了成员内部类对象就可以访问外部类的所有属性和方法*/System.out.println(name);System.out.println(str);}}}

*/classA{//成员变量staticintj;intk;//成员内部类classB{publicvoidchange(){j=100;k=1000;display();get();publicclassTestMemberInner{感谢阅读

}publicstaticvoidmain(String[]args){谢谢阅读

}A.Bab=newA().new