项目式笔记java课件心得+实践3.docx
《项目式笔记java课件心得+实践3.docx》由会员分享，可在线阅读，更多相关《项目式笔记java课件心得+实践3.docx（18页珍藏版）》请在冰豆网上搜索。
项目式笔记java课件心得+实践3
JAVA笔记心得+实践
一、基础篇
1、Day9笔记
……..匿名对象
使用方式之一：
当对对象的方法只调用一次时，可以用匿名对象来完成。
这样写比较简化。
若对一个对象进行多个成员调用时，必须给这个对象起个名字。
使用方式之二：
可以将匿名对象作为实际参数进行传递。
classCar
{
Stringcolor="red";
intnum=4;
voidrun（）
{
System.out.println（color+"..."+num）;
}
}
classCarDemo
{
publicstaticvoidmain（String[]args）
{
newCar（）.num=5;
newCar（）.color="blue";
newCar（）.run（）;
//结果为red4即修改匿名对象没有任何意义，乜有指向，所以没有调用。
//创造了三个堆内存空间。
//原理当使用newCar（）后，就在堆中分配一块内存有初始化默认值之后，通过显示修改成员变量值后就成为垃圾了，因为没有调用的记录地址的栈变量，这样用匿名对象就没有意义了。
//但是调用其方法还是可以的。
//.匿名对象
//使用方式之一：
当对对象的方法只调用一次时，可以用匿名对象来完成。
这样写比较简化。
若对一个对象进行多个成员调用时，必须给这个对象起个名字。
//Carq=newCar（）;
//show（q）;
//如果想让堆中成垃圾，明确即可q=null；
show（newCar（））;//当show函数执行完就释放空间，栈中的c释放，没有指向了，则堆中的空间的car内容成了垃圾。
}
//需求：
汽车修配厂，对汽车进行改装，将来的车修改成黑车，三个轮胎。
//则先定义功能：
只需要改车，所以void类型。
未知内容，什么车car
publicstaticvoidshow（Carc）
{
c.num=3;
c.color="black";
c.run（）;
}
}
。
。
。
。
。
。
。
。
。
封装：
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
封装好处：
将变化隔离，便于使用，提高重用性，提高安全性。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。
方法名若有多个单词组成第一个单词首字母小写，其余单词首字母大写。
/*
private:
私有，权限修饰符：
用于修饰类中的成员（或者成员变量，成员函数）私有只在本类中有效。
将age私有化以后，类以外即使建立了对象也不能直接访问。
但人应该有年龄，就要在person类中提供对应访问age的方式。
之所以对外提供访问方式，就因为在访问方式中（如函数中）加入逻辑判断语句。
对访问的数据进行操作，提高代码的健壮性。
*/
classPerson
{
privateintage;//变量要不设置要不获取所以定义为setAge
publicvoidsetAge（inta）
{
if（a>0&&a<130）
{age=a;
speak（）;
}
else
System.out.println（“failage”）;
}
publicintgetAge（）
{
returnage；
}
voidspeak（）
{
System.out.println（"age="+age）;
}
}
classPersonDemo
{
publicstaticvoidmain（String[]args）
{
//创建对象
Personp=newPerson（）;
//p.age=-20;//为了不能直接访问。
所以把类属性私有化。
p.setAge（20）;
p.speak（）;
}
}
。
。
。
。
。
封装不是私有，私有仅仅是封装的一种表现形式。
private关键字常用之一：
将成员变量私有化，对外提供set和get方法对其进行访问，提高对数据访问的安全性。
局部变量在栈中没有初始化就不能参与运算，而堆中会默认有初始化值。
。
。
。
。
构造函数：
特点：
函数名与类名相同。
不用定义返回值类型，（与void有些区别）。
不可以写return语句。
classPerson2
{
Person2（）
{
System.out.println（"personrun"）;
}//不写的话系统会加上person（）（）；
}
classPersonDemo2
{
publicstaticvoidmain（String[]args）
{
Person2p=newPerson2（）;
newPerson2（）;
}
}//结果打印两次personrun
//因为类中方法名与new的对象名一致。
所以产生构造函数，构造函数对象一建立就会调用与之对应的构造函数，
//构造函数的作用，可以用于给对象进行初始化。
当一个类中没有定义构造函数时，那么系统会默认给构造函数加入一个空参数的构造函数。
当类中自定义了构造函数，默认的构造函数就没有了。
构造函数也是函数，就具有重载的功能，即同名但参数列表不同即可。
函数如果都具有某个功能，将某个功能单独编一个函数，经行调用即可。
classPerson2
{
privateStringname;
privateintage;
Person2（）
{
System.out.println（"A:
name="+name）;
cry（）;
}
Person2（Stringn）//函数重载
{
name=n;
System.out.println（"B:
name="+name）;
cry（）;
}
Person2（Stringn,inta）//函数重载
{
name=n;
age=a;
System.out.println（"B:
name="+name+"age="+age）;
cry（）;
}
publicvoidcry（）
{
System.out.println（"cry...."）;
}
}
classPersonDemo2
{
publicstaticvoidmain（String[]args）
{
Person2p1=newPerson2（）;
Person2p2=newPerson2（"haohualei"）;//可以让其哭两次，但是不是同一对象了，是两个人了。
p1.cry（）;
p1.cry（）;//同一个对象可以哭两次。
一般方法
}
}
/*
构造函数与一般函数在写法上有不同。
在运行上也有不同，构造函数是在对象一建立就运行。
给对象初始化。
而一般方法是对象调用才执行。
给对象添加对象应该具备的功能。
一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
*/
。
。
。
。
。
classPerson2
{
privateStringname;
privateintage;
Person2（）
{
System.out.println（"A:
name="+name）;
cry（）;
}
Person2（Stringname）//函数重载如果改为Person2（Stringname）则name=name；前者就不是成员变量了，因为局部中都定义同一个名字都为局部变量了。
结果就不会获取“haohualei”了。
怎么区分用this.
{
this.name=name;
System.out.println（"B:
name="+name）;
cry（）;
}
publicvoidsetName（Stringn）
{
name=n;
}
publicStringgetName（）
{
returnname;
}
}
classPersonDemo2
{
publicstaticvoidmain（String[]args）
{
Person2p1=newPerson2（）;
Person2p2=newPerson2（"haohualei"）;//可以让其哭两次，但是不是同一对象了，是两个人了。
Person2p3=newPerson2（"yuli"）；yuli赋给了person2（stringname）函数所属对象p3的name值。
因为p3在调用person2（）函数。
p2.setName（"yuli"）;
System.out.println（p2.getName（））;//如果想改名字，利用set方法进行。
}
}
//this看上去，是用于区分局部变量和成员变量同名的情况。
this代表它所在函数所属对象的引用。
简单说，哪个对象在调用this所在的函数，this就代表那个对象。
//什么时候定义构造函数：
当分析失误失误，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
。
。
。
。
构造代码块在类中定义没名字的代码块{System.out.println（“person”）
其作用：
给对象进行初始化。
对象一建立就运行，而且优先于构造函数执行。
构造代码块与构造函数的区别：
构造代码块是给所有对象进行统一初始化。
而构造函数，是给对应的对象进行初始化。
都执行构造代码块。
在构造代码块中定义不同对象共性的初始化内容，
。
。
。
。
一个类中如果所有的构造函数都被私有化之后，就意味着这个类就不可能创建对象了，因为对象都不能初始化动作了。
//this看上去，是用于区分局部变量和成员变量同名的情况。
this代表它所在函数所属对象的引用。
2、Day10笔记：
….。
。
。
。
。
/*this的应用：
当定义类中功能（函数）时，该函数内部要用到调用该函数的对象时，
这时用this来表示这个对象。
但凡本类功能内部使用到本类对象，都用this表示。
*/
classPerson
{
privateintage=20;
Person（intage）
{
this.age=age;
}
//需求：
给人定义一个用于比较年龄是否相同的功能。
也就是是否是同龄人。
publicbooleancompare（Personp）//参数为对象不是intage因为，人作为对象，人具有这个功能，不用两个人做参数。
因为我与别人比，不止两个人比。
{
/*if（this.age==p.age）
returntrue;
else
returnfalse;
*/
//因为boolean型就是返回false和true的所以，进行直接写表达式即可
returnthis.age==p.age;
}
}
classThisDemo1
{
publicstaticvoidmain（String[]args）
{
Personp1=newPerson（20）;
Personp2=newPerson（25）;
booleanb=pare（p2）;
System.out.println（b）;
}
}
//、构造函数间调用，不能用对象直接引用，而是要用this。
this语句用于构造函数间进行互相调用只能用this语句，当然传参要与函数参数一致。
。
this一定是某个对象的引用。
this语句只能定义在构造函数的第一行。
因为初始化要先执行。
一般函数不能调用构造函数，因为this语句不用于一般函数。
。
。
。
。
。
。
。
。
。
。
。
。
static关键字：
用于修饰成员（成员变量和成员函数）：
被修饰后的成员具备以下特点;
即开辟的static空间共享空间随着类的加载而加载随着类的消失而消失。
说明它的生命周期最长。
优先于对象存在，被所有对象所共享。
可以直接被类名调用。
使用注意：
静态方法只能访问静态成员。
静态方法中不可以写this，super关键字。
主函数是静态的。
。
。
。
。
。
当类中加私有后，需要用setget方法来进行访问。
静态修饰内容被对象所共享，即创建每个对象不必要都有这个内容了，并且节约了空间。
当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。
格式：
类名.静态成员。
classPerson
{
Stringname;//当类创建后下面一句话在，而此句话不在，只有当创建对象后，name才存在。
简称实例变量即对象变量。
staticStringcountry;//共享了国籍也就是创建对象后，不在每个对象都有国籍了，而是共享了，每个对象的栈空间就节约了。
简称类变量。
这个变量在，还没有对象。
publicvoidshow（）
{
System.out.println（name+":
:
"+country）;
}
}
classStaticDemo
{
publicstaticvoidmain（String[]args）
{
Personp=newPerson（）;
p.name="zhan";
p.country="CN";
p.show（）;
System.out.println（p.country）;
System.out.println（"---------"）;
System.out.println（Person.country）;
}
}
特有内容随着对象存储。
数据如果对多个对象共享则定义static，不建议多个静态，因为生命周期长与对象，所以消耗内存。
共享的数据。
类中的方法等也都存在与，方法区=共享区=数据区，
实例变量和类变量的区别：
1.存放位置：
类变量随着累的加载而存在于方法区中。
实例变量随着对象的建立而存在于堆内存中。
2.生命周期：
类变量生命周期最长，随着类的消失而消失。
实例变量生命周期随着对象的消失而消失。
。
。
。
。
静态使用注意事项：
1.静态方法只能访问静态成员（方法和变量）。
因为对象还没建立。
所以实例变量不能访问。
2.非静态方法既可以访问静态也可以访问非静态。
因为非静态中对象已经建立。
3.静态方法中不可以定义this（必须有对象），super关键字。
因为静态优先于对象存在，
4.静态不能访问非静态
静态利弊：
利：
对对象的共享数据进行单独空间的存储，节省空间。
没必要每一个都存储一份。
可以被类名直接调用。
弊：
生命周期过长。
访问出现局限性，（静态虽好，只能访问静态）
主函数是固定一个格式的，jvm识别。
引用数据类型就两个值，要么指向具体值，要么指向为空（null）。
jvm在调用主函数时，传入的是newString[0]的实体值，即对象。
。
。
。
。
什么时候定义静态函数？
当功能内部没有访问到非静态数据，（对象所特有的数据，因对象而存在的数据）则该功能可以定义成静态的。
。
。
。
现在类中定义若干功能，之后再另写一个文件创建刚才类对象，调用类中定义的方法，两个文件，编译先编译类定义的文件在编译使用这个类所产生对象的文件，之后再运行。
也可以进行直接编译适用对象类，前提，工具类必须在使用类同一目录下。
。
。
。
对象是用于封装数据的，额款式，但arraytool对象并没有封装特有数据。
操作数组的每一个方法都没有用到arrayTool对象中的特有数据。
即调用工具中的方法完全是由用户传进的参数。
所以使程序更严谨，是不需要对象的。
这时，可以将工具类中的方法都定义为static的，可以通过类名直接调用。
将方法都静态后，可以方便与使用，但是该类还是可以被其他程序建立对象的。
如果建立，对象一点用也没有还占用空间，所以为了更为严谨，强制让该类不能建立对象。
可以通过将构造函数私有化完成。
。
privateArrayTool（）{}没有；因为到{}已经结束。
。
。
。
。
当arrayTool不在与使用arrayToolDemo不在同一目录下时，可以在dos窗口设置setclasspath=.;c:
\myclass进行.为当前找，如果没有再找tool所在的目录c：
\myclass中找。
。
。
。
生成javadoc.exe会自动生成文档。
格式如下。
之后再dos中输入 javadoc–dmyhelp–author–versionPerson.java
注意Person的类必须是public才能自动提取文档。
文档格式如下：
/*
this的应用：
当定义类中功能（函数）时，该函数内部要用到调用该函数的对象时，
这时用this来表示这个对象。
但凡本类功能内部使用到本类对象，都用this表示。
@author张三
@versionV1.1
*/
publicclassPerson
{
privateintage=20;
Person（intage）
{
this.age=age;
}
/*
功能：
给人定义一个用于比较年龄是否相同的功能。
也就是是否是同龄人
@paramp接收一个Person类型的对象
@return会返回一个该对象中年龄是否相同的boolean值。
*/
publicbooleancompare（Personp）//参数为对象不是intage因为，人作为对象，人具有这个功能，不用两个人做参数。
因为我与别人比，不止两个人比。
{
returnthis.age==p.age;
}
}
生成的myhelp文件夹中先看index.html的文件。
一个类中默认的会有空参数的构造函数。
默认的构造函数权限与所属类的一致，若类被public修饰，则默认的构造函数也带public修饰符。
若类没有被public修饰，则默认的构造函数也没有public修饰。
默认的构造函数的权限是随着类的变化而变化的。
看文档中函数是static则，对象不用建立。
。
。
。
。
静态代码块：
classStaticCode
{
static//格式
{
System.out.println（"a"）;
}
}
classStaticCodeDemo
{
static
{
System.out.println（"b"）;
}
publicstaticvoidmain（String[]args）
{
newStaticCode（）;
newStaticCode（）;//不再执行，因为已经加载到类中，只执行一次。
System.out.println（"over"）;
}
static
{
System.out.println（"c"）;
}
}//结果：
bcaover
//静态代码块随着类的加载而执行，并执行一次，并优先于主函数。
静态代码块不常用，用于给类进行初始化。
。
。
。
。
空参数构造函数默认不写时才会称默认，写时就是自定义了。
。
。
。
static中不能写this静态的不能访问非静态的。
。
。
{
System.out.println（“c”+this.num）;//可以这样访问因为这是构造代码块，是给对象初始化的，所以能用this，（用于创建对象。
）
}
。
。
。
。
Personp=newPerson（“zhangsan”,20）;
该句话做什么事情：
1.因为new用到了Person.class所以会先找到Person.class文件并加载到内存中。
2.执行该类中的static代码块。
如果有的话，给Person.class类进行初始化。
3.在堆内存中开辟空间，分配内存地址。
4.在堆内存中家里对象的特有属性，并进行默认初始化。
5.对属性进行显式初始化。
6.对对象进行构造代码块初始化。
7.对对象进行对应的构造函数初始化。
8将内存地址付给栈内存中的变量。
非静态的调用应该用类名.方法静态的不用this
。
。
。
。
设计模式：
解决某一类问题最行之有效的方法。
java中有23种设计模式，
单例设计模式：
解决一个类在内存只存在一个对象。
。
。
。
。
方法被调用只有两种方式：
一：
对象二：
类名。
用类名调用，方法必须静态。
….一般类中的变量要私有化，通过方法去访问。
/*
单例设计模式：
解决一个类在内存只存在一个对象。
想要保证对象唯一：
1.为避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
2.还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三步怎么用代码体现？
1.将构造函数私有化。
2.在类中创建一个本类对象。
3.提供一个方法可以获取到该对象。
*/
classSingle
{
privateintnum;
publicvoidsetNum（intnum）
{
this.num=num;
}
publicintgetNum（）
{
returnnum;
}
//privateSingle（）{}
privatestaticSingles=newSingle（）;//方法要访问类中的成员，所以用静态访问静态的变量。
所以static。
//s为类中的成员变量。
所以一般类中的变量要私有化。
publicstaticSinglegetInstance（）//方法被调用只有两种方式：
一：
对象二：
类名
//。
用类名调用，方法必须静态。
{
returns;
}//红色部分为使对象为唯一的三部曲。
}
classSingleDemo
{
publicstaticvoidmain（String[]args）
{
//Singless=Single.getIntance（）;//用类名调用方法，返回一个类的对象。
/*
Singles1=Single.getInstance（）;
Singles2=Single.getInstance（）;
s1.setNum（30）;
System.out.println（s2.getNum（））;//结果为30。
因为程序中有一个对象，三个引用
升级会员 