JAVA学习体会.docx
- 文档编号:3306118
- 上传时间:2022-11-21
- 格式:DOCX
- 页数:58
- 大小:38.59KB
JAVA学习体会.docx
《JAVA学习体会.docx》由会员分享,可在线阅读,更多相关《JAVA学习体会.docx(58页珍藏版)》请在冰豆网上搜索。
JAVA学习体会
1.JAVA语言严格区分大小写。
如:
system与System是两个不同的概念,后者为正确的系统变量。
2.环境变量一定要设置好。
编译时用javacxx.java,一定要带上后缀.java,成功后将生成xx.class
运行时用javayy(yy为xx中定义的类名),也要注意区分大小写!
注意若一个.java文件中可能有多个类时,则只执行有main{}函数的那一个。
3.注意每行语句后面的;号不能漏掉。
4.关于错误信息“类A是公共的,应在名为A.java的文件中声明”的含义包括:
1、如果类A被声明为公共的(public),那么必须将类A保存在名为A.java的文件中,文件名和类名必须完全一致,包括大小写。
2、反之,在一个文件中最多包含一个顶级的公共类,并且该公共类的名字与文件名相同。
比如文件A.java中,允许定义一个或多个类,但最多允许一个顶级的公共类,此类名为A。
此处强调的顶级的意思是,允许非顶级的公共类存在,如内部公共类等。
4.任何一个类对象被生成时一定会调用该类的构造函数,如下面的例子
classA
{
privateinti;
//privatestaticintcnt=0;//结果为0,1,2,3
//publicstaticintcnt=0;//结果为0,1,2,3
//publicintcnt=0;//编译错误
publicA()
{
++cnt;
}
publicA(inti)
{
this.i=i;
++cnt;
}
publicstaticintgetCnt()
{
//return返回的是A对象的个数;
returncnt;
}
}
publicclassTestStatic_1
{
publicstaticvoidmain(String[]args)
{
System.out.printf("当前时刻A对象的个数是:
%d\n",A.getCnt());
Aaa1=newA();
System.out.printf("当前时刻A对象的个数是:
%d\n",A.getCnt());
Aaa2=newA();
System.out.printf("当前时刻A对象的个数是:
%d\n",A.getCnt());
Aaa3=newA();
System.out.printf("当前时刻A对象的个数是:
%d\n",A.getCnt());
}
}
程序执行的结果为0,1,2,3,
5.类的成员可以是变量、函数,也可以是类对象,在类的内部,成员函数可以直接调用成员(无论是private或public)。
6.子类内部可以访问父类非私有的成员,私有成员无法被子类方法访问。
通过子类对象名只能访问从父类继承过来的非私有成员
7.私有不能被继承,私有物理上已经被继承过来,只不过逻辑上程序员不能去访问它。
因此继承必须慎重,否则会浪费内存
8.要执行的main函数的标准写法:
publicclassxxx
{
publicstaticvoidmain(String[]args)
{
….
}
…
}
程序执行时,用javaxxx方式,其中xxx不能在同目录下出现.java文件重名(即有不允许有xxx.java),否则编译出错。
5.构造函数的名称与类名一定要相同,如下面中的两个publicB()为构造函数,均无返回值,且都用于初始化类B的成员变量I,j,和flag,唯一不同的是一个带形参,一个不带形参。
而voidshow()为类B的成员函数
一个类中的成员变量:
1、如果在定义的时候不初始化,则它的值是系统自动分配好的默认值!
如int型为零boolean型是false
2、如果在定义的同时赋初值,则是可以的,也就是说该值是生效的.注意在C++中则不可以,在C++中一个类的数据成员不能在定义的同时初始化,它只能在构造函数中初始化
3、如果在定义的同时赋初值,当然生效,但如果在构造函数中又改变了定义时赋的初值,则该数据成员最终的值就是构造函数中修改之后的那个值,因为:
系统会先执行定义时赋的初值,然后再执行构造函数中赋的初值
classB(类名)
{
inti;
intj=10;
booleanflag;
publicB()(构造函数,无返回值,用于初始化类B的成员变量I,j,和flag)
{
System.out.println("以前的值是"+i+""+j+""+flag);
i=88;
j=88;
flag=true;
}
publicB(intx,intk,booleanf)(构造函数名,且无返回值,用于初始化类B的成员变量I,j,和flag)
{
i=x;
j=k;
flag=f;
}
voidshow()
{
System.out.println("i="+i);
System.out.println("j="+j);
System.out.println("flag="+flag);
}
}
6.所谓函数的重载,指的是在一个类中允许多个名字相同的成员函数存在,但有一个前提就是:
这些函数要么形参的个数不同,要么形参的类型不同,要么两者都不同,不允许两个函数只是函数的返回值不一样,其他都一样的情况出现,这构不成函数的重载,并且编译时会报错。
因为计算机在执行函数时无法确定。
如:
classA
{
intadd(inti,intj)
{
returni+j;
}
//如果两个函数只是函数的返回值不一样,其他都一样,这构不成函数的重载,并且编译时会报错!
//doubleadd(inti,intj)该函数与上一个函数不能重载!
//{
//return6.0;
//}
intadd(inti,intj,intk)
{
returni+j+k;
}
doubleadd(inti,doublex,intj)
{
returni+x+j;
}
}
7.每执行New操作,都将自动重新对类成员变量进行初始化->执行构造函数-而成员函数则不会自动执行!
classStudent{
publicstaticintcnt=0;
privateStringsname;
privateintsage;
publicStudent(){
cnt++;
}
publicStudent(Stringname,intage){
this.sname=name;this.sage=age;cnt++;
}
}
publicclassTestStatic_1{
publicstaticvoidmain(String[]args){
System.out.println("St="+St);
Studentst1=newStudent("zhangsan",20);
Studentst2=newStudent("lisi",30);
System.out.printf("Student类总共构造了%d个对象!
\n",St);
}
}
结果:
cnt分别为0和2
以下两个例子说明构造函数及类赋值的意义
例子A的执行结果为无,因为类初始化不会自动执行成员函数,本例中类A没有构造函数,因此在执行Aaa=newA();语句中不会执行A中的成员函数f()和g().
classA
{
privateinti=10;
privatevoidf()
{
System.out.printf("%d\n",i);
g();
}
publicvoidg()
{
}
}
classM
{
publicstaticvoidmain(String[]args)
{
Aaa=newA();
}
}
例子B的执行结果为20,说明了类bb1和bb2相等的情况。
若屏蔽红色部分,只保留兰色部分,则执行结果为10,说明不同的类在初始化时是互不影响的.,即类bb1的初始化与类bb2无关。
classB
{
publicinti=10;
publicvoidshow()
{
System.out.printf("%d\n",i);
}
}
classM
{
publicstaticvoidmain(String[]args)
{
Bbb1=newB();
Bbb2=newB();
bb1=bb2;
bb1.i=20;
bb2.show();
//bb1.i=20;
//bb2.show();
}
}
8.关于This运算符的作用
this表示当前时刻正在调用show方法的对象,可以理解成表示一个具体的类实例.在类中定义的所有成员变量x,实际上都可以写为this.x,一般情况下this是省略的,只有当类实例化调用构造函数的形参与成员变量名字相同时,this运算符是不可以省略的,否则将出错。
程序执行结果为100,200
classA
{
privateinti;
publicA(inti)
{
this.i=i;//将形参i赋给该构造方法本次运行所创建的那个新对象的i数据成员this.i
}
publicvoidshow(){
System.out.println("i="+i);
//this表示当前时刻正在调用show方法的对象
//this可以省略
}
}
publicclassTestThis
{
publicstaticvoidmain(String[]args){
Aaa1=newA(100);
//类aa1实例子化的方法,表示是类A的一个实例子,100表示将100传递给构造函数中的变量
aa1.show();
Aaa2=newA(200);
aa2.show();
}
}
9.This的例子
classA
{
publicinti=99;
publicA(inti)
{
System.out.printf("%d\n",this.i);//此时i为99
this.i=i;//this代表当前时刻正在创建的对象
System.out.printf("%d\n",i);
}
publicvoidshow()
{
System.out.printf("%d\n",this.i);//this代表正在调用show方法的对象
}
}
//以下程序执行结果为:
99
2
2,
//具体过程为:
i初始化赋值为99,在执行构造函数时未初始化时为99,参数传递后变为2,执行成员函数show()时又输出一次2
publicclassTestThis_2
{
publicstaticvoidmain(String[]args)
{
Aaa=newA
(2);
aa.show();
//System.out.printf("%d\n",aa.i);
}
}
10.关于变量的初始化问题
下面的例子中类A中定义的成员变量I,flag可以初始化赋值,也可以不初始化,系统会根据该变量的类型自动初始化赋值.而成员函数中(本例中show())的变量(又称为局部变量)局部变量编译器是不会自动进行初始化的,java要求所有的局部变量在使用之前都必须的初始化。
所以红色部分加入编译时将出错误。
应将intk改为intk=2;即可。
classA
{
publicinti=2;
publicbooleanflag=true;
//也可以写为下面两句,不会影响本程序的执行结果
//publicinti;
//publicbooleanflag;
//也可以写为下面两句,不会影响本程序的执行结果
//inti;
//booleanflag;
//也可以写为下面两句,不会影响本程序的执行结果
//privateinti;
//privatebooleanflag;
publicA(intj,booleanf)
{
i=j;
flag=f;
}
publicvoidshow()
{
System.out.printf("%d\n",i);
System.out.printf("%b\n",flag);//boolean用%b或%B来输出
}
}
classTestConst_2
{
publicstaticvoidmain(String[]args)
{
Aaa=newA(88,false);
aa.show();
//intk;//局部变量编译器是不会自动进行初始化的,java要求所有的局部变量在使用之前都必须的初始化,比如inkk=2;
//System.out.printf("%d\n",k);
}
}
11关于Public和Private修饰符的作用
以下的例子执行结果为:
Name=张三,age=30
Name=雷平,age=40
Name=雷平,age=40
Student.Name=李四,Student.age=22
bb.Name=李四,bb.age=22
cc.Name=李四,cc.age=22
如果采用兰色的语句,则编译出错,因为用Private修饰的变量是无法用Student.name/Student.age来访问的。
同时也说明类Student在实例化bb
后其成员变量的值由张三,30变为雷平,40,再实例化cc后变为李四,22.
而对于类Student,其publicstatic成员变量name、age而言,经过两次New后,无论是基类Student还是子类bb,cc,最后这些变量的值都变为最后一次New的值,即覆盖式赋值:
Student.Name=李四,Student.age=22bb.Name=李四,bb.age=22
cc.Name=李四,cc.age=22。
注意此处成员变量必须声明为publicstatic否则程序将编译出错。
classStudent
{
//privatestaticStringname="张三";
//privatestaticintage=30;
publicstaticStringname="张三";
publicstaticintage=30;
publicStudent(Stringname,intage)
{
this.name=name;
this.age=age;
}
publicvoidshowInformation()
{
System.out.printf("name=%s,age=%d\n",this.name,this.age);
}
}
classAA
{
publicstaticvoidmain(String[]args)
{
System.out.printf("name=%s,age=%d\n",Student.name,Student.age);
Studentbb=newStudent("雷平",40);
bb.showInformation();
System.out.printf("name=%s,age=%d\n",Student.name,Student.age);
Studentcc=newStudent("李四",22);
//cc.showInformation();
System.out.printf("Student.name=%s,Student.age=%d\n",Student.name,Student.age);
System.out.printf("bb.name=%s,bb.age=%d\n",bb.name,bb.age);
System.out.printf("cc.name=%s,cc.age=%d\n",cc.name,cc.age);
}
}
12本例子中类A没有构造函数,系统将自动执行一个空的构造函数(什么也不做),程序执行结果
20
成员变量i值的变化如下:
初始化10aa1、aa2、aa3后为10aa1.i=20后所有的类中的i均为20,所以结果为:
10
20
20
/*下面的程序证明了:
A类的多个对象公用一个static属性i*/
classA
{
publicstaticinti=10;
publicvoidshow()
{
System.out.printf("%d\n",i);
}
}
classM
{
publicstaticvoidmain(String[]args)
{
Aaa1=newA();
Aaa2=newA();
Aaa3=newA();
System.out.printf("%d\n",aa3.i);
aa1.i=20;
aa2.show();
System.out.printf("%d\n",aa3.i);
}
}
13.下面程序证明了即使没有定义子类(没有对象),仍然可以直接通过类名的方式访问该类内部的static类型的成员变量和成员函数(同时也必须满足public);当然更可以通过类对象名的方式访问(红色部分)
classA
{
publicstaticinti=10;
publicstaticvoidf()
{
System.out.printf("2009年5月29日15:
15:
50");
}
}
classTestStatic_2
{
publicstaticvoidmain(String[]args)
{
System.out.printf("%d\n",A.i);//直接访问基类的成员变量
A.f();//直接访问基类的成员函数
//Aaa=newA();
//aa.f();
//System.out.printf("%d\n",aa.i);
}
}
14程序证明了只有非private的static成员才可以通过类名的方式访问,static只是表明了该成员具有了可以通过类名访问的潜在特征,但是否可以通过类名访问,还必须满足一个条件:
该成员必须是非private
本例中如果成员变量i和成员函数f()虽然为static,但为private,仍然不可以直接访问。
本例中由于都是private,所以编译出错。
classA
{
privatestaticinti=10;
privatestaticvoidf()
{
System.out.printf("2009年5月29日15:
15:
50\n");
}
}
classTestStatic_4
{
publicstaticvoidmain(String[]args)
{
A.f();
A.i=22;
}
}
15.
静态方法(指基类名、或基类中带有static修饰的函数)不能访问非静态成员(指没有static修饰的变量和函数.);只能访问静态成员(指有public和static修饰的变量和函数)
非静态方法(指子类名、或基类中没有static修饰的函数)可以访问非静态成员(指没有static修饰的变量和函数.)和静态成员(指有public和static修饰的变量和函数)
下面的例子说明了:
静态方法不能访问非静态成员;非静态方法可以访问静态成员;此处类的成员包括成员变量和成员函数
classA
{
privatestaticinti=10;
publicintj=99;//非静态变量
publicstaticvoidf()//静态函数
{
//g();//error静态方法f()不能访问非静态成员g()
//j=22;//error
System.out.printf("FFFF\n");
}
publicvoidg()//非静态函数(无static)
{
//f();//OK说明非静态方法g()可以访问静态成员f()
System.out.printf("GGGG\n");
System.out.printf("%d\n",i);
System.out.printf("%d\n",j);
}
}
classTestStatic_5
{
publicstaticvoidmain(String[]args)
{
Aaa=newA();
aa.g();//ok非静态方法可以访问非静态成员
//A.g();//error静态方法不能访问非静态成员(包括变量和函数)
}
}
16.关于类的继承
以下例子说明:
先定义一个类Human及其成员函数laugh()和cry()(注意这两个成员函数均为public),然后再定义一个类Student继承其父类Human,并有自己的成员函数doHomework()(也为public);最后对子类Student实例化,调用上述三个成员函数。
classHuman
{
//人笑
publicvoidlaugh()
{
System.out.println("笑!
");
}
//人哭
publicvoidcry()
{
System.out.println("哭!
");
}
}
classStudentextendsHuman//定义一个类Stud
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- JAVA 学习体会