欢迎您的光临,本博所发布之文章皆为作者亲测通过,如有错误,欢迎通过各种方式指正。由于本站位于香港虚拟主机,故速度比较慢。

教程  Java语言学习—第五章 类与对象[Java基础]

Java 原创 357 0评论

内容概要

1.类的定义与对象的创建

2.引用赋值

3.成员方法

4.局部变量和成员变量

5.this引用

6.静态变量和静态方法

7.包的导入与访问控制符

8.重载与构造函数

9.类的初始化  

 

1.类的定义与对象的创建

对象封装了一个客观实体的属性与行为,我们把它的属性称为成员变量,而把它的动作称为成员方法

为了创建对象,我们要有一个框架模板,我们称框架模板就是类

对象是类的实例,在创建对象之前,必须首先定义类

创建类实例: class Man{ 变量与方法的定义 },花括号内是 类体部分,可以在花括号内定义所需有的变量与方法。在此,我们只要为Man类声明成员变量。

class Man{int height;int age;}..//花括号分别表示类的开始和结束。height和age表示成员变量。

现在,我们为Man类创建一个Man类的对象。创建对象首先要给对象起个名字。如对象名为man1。 Man man1;//man1只是个对象的名字而不是对象。

下面创建对象:man1=new Man(); //new是“新建”的意思,整条语句的含义就是创建新的Man类的对象。创建一个对象也需要一个行为动作,我们将这个动作称为构造函数,上面的 Man()就是构造函数。

当然,声明对象(为对象命名)与创建对象可以同时进行, 所以创建对象可写成:Man man1=new Man();

创建对象完成后,就可以使用它了。eg:man1.height=180;man1.age=20;

上面的描述代码综合如下:文件名:Class1.Java

class Man{int height;int age;}
public class Class1{ ........................................//定义class1类
public static void main(String[] args){....................//最先执行
Man man1=new Man();..........................................//声明以及创建对象
man1.height=180; man1.age=20;................................//为man1的height和age赋值
System.out.println(man1.height);System.out.println(man1.age); //输出man1的height和age

Java语言的约定如下:一个文件中,只允许存在一个public类,并且public类的类名要与文件名保持一致,并且只有包含main()方法所在的类才能成为一个public类。 上面的例子中,public类名为Class1与文件名保持一致,并且Class中包含main()方法。

像man1这样的对象名也被称为”“引用”或“引用变量”,man1.height,其中man1是对象名,点后面的height是对象,利用对象名可以访问对象,即通过man1可以访问对象的成员变量height,并为其赋值为180.这就说明man1引用了对象。

 

2.引用赋值

以后我们将对象名称称为引用(变量)。因为引用代表对象,所以也可以把引用称为对象

请看:Man man1=new Man(); Man man2; man2=man1;最后一句把一个引用(man1)赋给另一个引用(man2),那么这两个引用(man1和man2)将引用同一个对象。

即man1.height与man2.height是引用的同一个对象。

 

3.成员方法

方法(Method)又称为函数(Function),在Java中定义方法的格式如下:

返回值类型 方法名(形式参数){

方法体;

}

//返回值类型值方法返回值的数据类型。

main()方法是静态方法(static),一般比其他方法要先执行。


(1)void返回类型:空,没有返回值,main方法一般是没有返回值的。eg:

void printInt(int x){.....................//x1
System.out.println(“整数=”+X); ......//x2

//无法像下面这样调用它:y=对象.printInt(10);//错误。应该像下面这样调用printInt()方法:对象.printInt(10); 这样进行调用,会给x1行的形式参数x赋值10,然后执行x2行。当方法结束时,自动返回到调用之处,不带任何值。

eg:Class2.java
public class Calss2{
void printInt(int x){
System.out.println(“整数=”+X); }
public static void main(String[] args){ 
Class2 aaa=new Class2(); 
aaa.printInt(10);
System.out.println("你好");
aaa.printInt(20);
 } 
}

即使是无返回值的void函数,我们也要在其中使用“return”语句。使函数完整。直接使用 return;

(2)无参函数:指形式参数为空,没有形式参数的方法。

eg:void hello(){System.out.println("你好");} //hello()是一个无参方法,业务返回值,调用它时像这样:对象.hello();

(3)多参方法:指有多个形式参数的方法,这个形式参数之间使用逗号分隔。

int sum(int a,int b){ return a+b;}

如果想下面那样调用它,会把返回值30赋给变量x:x=对象.sum(10,20);

 

4.局部变量和成员变量

局部变量在方法内部声明,并且只能在方法内部使用。局部变量在外层使用时被分配内存,并且在方法执行完毕后自动释放内存而消亡。方法中的形式参数是局部变量的一种。

int ten(int a){int x=10; return a*x;} //变量a与x都是局部变量,它们只能在方法内部使用。如果不调用ten()方法,局部变量a与x就不会存在。只有调用它是系统才会给它分配内存。在使用局部变量之前,必须首先对其进行初始化。初始化是指在声明它们的同时就给它们赋值。

成员变量时在类的内部声明,成员变量会自动初始化,局部变量一定要先初始化才可以使用。

 

5.this引用

this是一个自身引用,eg:

class Hi{
int a;//a是成员变量。
void setA(int b){this.a=b; }//x1,b是局部变量
int getA(){
return this.a;
}
}

//this.a表示变量a是对象自身的成员变量,而没有带this的变量b是局部变量。所以setA()方法将使用局部变量b接收外界的值,并把它赋给成员变量a。

再次,修改setA()方法如下:void setA(int a){ this.a=a;}//this.a表示变量a是对象自身的成员变量,而没有带this的变量a是指局部变量,在局部变量与成员变量同名的情况下,变量之前没有this的是局部变量。有this的是成员变量。

在一个成员方法中,可以调用另一个成员方法。

public class Class3{
void hi(){ hello();}// x1
void hello(){System.out.println("Hello~~");}
public static main(String [] args){ 
Class1 ob=new Class1(); 
ob.hi()
}
}

//观察x1行,在hi()方法中调用了hello()方法。在调用成员方法时要使用“对象.hello()”语句。编译此行代码时,将对x1作如下修改。

this.hello(); //调用对象自身的hello()

 

6.静态变量和静态方法

静态成员变量在不创建类的对象的情况下,也可以使用,它是所有对象共有的变量。普通成员变量(non-static)只有在创建类的对象后才能被使用。而静态变量可以不先创建对象而直接使用。

静态变量的声明如下:static int a; 我们可以向下面这样引用静态变量。类.a=10;对象.a=20;

public class Class3{
static int a; int b; //a是静态变量,b是成员变量。
public static void main(String [] args){
Class3.a=10; //x1
Class3 ob1=new Class3(); 
Class3 ob2=new Class3();
System.out.println(ob1.a);
ob1.a=20;System.out.println(ob2.a);
ob2.a=30;System.out.println(Class3.a);
}}

//运行结果:10 20 30.ob1.a,ob2.a都是指同一个变量,即静态变量a。静态变量可以像x1行那样使用,所有也称为“类变量”。


静态变量在不创建对象的情况下也可以被调用,main()方法是静态方法,它在程序执行时,由JVM自动调用,而不需要创建对象。


我们可以像下面这样定义一个静态方法。即定义静态方法时,在返回值类型前面加上static关键字。

static int return123(){ return 123;}

可以用下面两种方法调用静态方法。x、y是接收返回值的变量,它们不是必须的。

int x=类.return123(); int y=对象.return123();

public class Class4{ 
static int return123(){ return 123;}
}
public static void main(String [] args){
System.out.println(Calss4.return123());//类引用
Class4 ob=new Class4();
System.out.println(ob.return123());//对象引用
}}//结果:123 123

:有static的方法只能访问带static的方法和变量,只能使用static的变量,否则都可以访问;不要调用main()方法。

只有在对象存在的条件下,我们才可以使用成员变量与成员方法。然后,静态方法则不需要首先创建对象,可以直接调用它。

eg:

public class Class5{
static int a; //static变量
static void hello(){System.out.println("你好");} //static方法
static void setA(int b){a=b;//static变量;hello();//static方法}//在静态方法中调用另一个静态方法
void printA(){System.out.println(a);//a是static变量 hello();//static方法}//在非静态方法中调用static方法hello()
public static void main(String[] args){
Class5.setA(100); //x1
Class5 ob=new Class5(); ob.printA();
}}//main方法是静态的,也是Class5的方法,所以x1行中可以将类名省去,写成:setA(100);

 

7.包的导入与访问控制符

pacckage的字面上含有:捆、束。包指接口和类的集合,或者说包是接口和类的容器。Java中的包与目录类似。

为了在其他的包中能使用所定义的类,必须使用import关键字,在那个包中导入要使用的类。import含为:导入,引入。

Date类存在于java.util包中,是一个与日期有关的类。你要使用这个类,必须首先导入java.util.Date类。

import java.util.Date;
public class Class6 {
public static void main(String[] args){
Date d=new Date();
System.out.println(d);
}
}

String中的System类位于java.lang包中。java.lang包是java语言的核心类库,包含了运行java程序必不可少的系统类。每个java程序运行时会自动导入这个包,此包是缺省的。import java.lang。*; // *表示所有的类。


访问控制符(access modifier)种类如下:

出现在成员变量与成员方法之前的访问控制符:private 、public 、 default(friendly)、 protected

出现在类之前的访问控制符有:public、default(friendly)

在定义类的变量或方法是,如果访问控制符是private的,则只能在该类的内部使用,带有private的是类的私有成员。其他的类中就不能访问它们,就是所谓的隐藏性,或者说是封装性。封装的内部发生的事件对外是不可见的,但实现了该有的功能,体现了封装的好处。没有经过封装的程序不能称之为面向对象程序设计。

public class Class7 {
private int num;
void setNum(int a){.............. .//x1,接口
num=a;............................//仅在类内部使用,相当于this.num=a;
}
int getNum(){..................... //x2,接口,相当于return this.num;
return num;
}}
public class Class8{ 
public static void main(String[] args){ 
Class7 ob=new Class7();
ob.setNum(10);....................//改变num值,但num对外不可见
System.out.println(ob.getNum());
}
}

上面x1和x2行的setNum()方法与getNum()方法的访问控制符被省略了。我们把这种省略访问控制符的成员称为default或friendly成员。default成员可以被同一个包中的类访问,其他包则不能访问。public是公有成员,所有类都可以访问它。对应protected成员,不仅同一个包中的类可以访问它,而且位于另一个包中的子类也可以访问它。

访问控制符的含义:private:仅在类内部可以访问; public 所有类都可以访问 ; default(friendly):只有同一个包中的类才能访问;protected:不仅同一个包中的类可以访问它,而且位于其他包中的子类也可以访问它。

 

8.重载与构造函数

重载(overload)是指在同一个类中定义多个同名但内容不相同的成员方法。

void hi(){
System.out.println("你好__");
}
void hi(String name){
System.out.println(name+"先生,你好");
}
void hi(String name,String name2){
System.out.println(name+"先生,你好"+name2+"先生,你好2...");
}

上面3个方法中名字都是hi,但是它们的形式参数的个数及数据类型都不相同。我们把这种方法称为重载。

注:方法重载时,形式参数的个数及数据类型一定不要相同,否则会发生编译错误。

如果不对成员变量进行初始化,相同将自动为基本数据类型变量赋值为0,为引用变量赋值为null。

public class Class9 {
int a;
String b;
public static void main(String[] args){
Class9 ob=new Class9();
System.out.println(ob.a+""+ob.b);
}
}

//成员变量a和b没有初始化,a的值为0,b的值为null

上面的黑体部分:Class9 ob=new Class9();中的Class9()就是所谓的构造函数,使用它调用一个方法。构造函数是在创建对象的瞬间调用执行的特殊函数。构造函数的名字与类名一致,他没有任何返回值,并且其前不允许有void关键字。我们把编译器为我们创建的无参构造函数称为缺省(default)构造函数。缺省构造函数没有参数。也没有函数体,即它不做任何事情,其唯一功能就是创建对象。

public class Class10 {
int a;
public Class10(){.............................................//x1
a=10;
}
public static void main(String[] args){
Class10 ob=new Class10();.....................................//x2
System.out.println(ob.a);
}
}

// x1行的函数是构造函数,x2行创建Class10类的对象时,它就会得到执行,所以会有ob.a=10;

构造函数一定要在其他类中被调用,所以其访问控制符一般为public。

也可以为其指定不同的控制符,但要记住:构造函数没有返回值,并且名字也要和类名保持一致。

上面例子中,创建Class10类的对象,成员变量a就会被赋值为10。即使再创建另外一个对象,其成员变量a仍然会被赋值10.那么怎么区分彼此吧不同呢?——解决之道就是:重载构造函数。

public class Class10 {
int a;
public Class10(){.............................................//x1
a=10;
}
public Class10(int a){........................................//x2
this.a=a;
}
public static void main(String[] args){
Class10 ob=new Class10();.....................................//x3
Class10 ob2=new Class10(20);..................................//x4
Class10 ob3=new Class10(30);..................................//x5
System.out.println(ob.a);
System.out.println(ob2.a);
}
}

//x3行调用x1行的构造函数,x4,x5行调用x2行的构造函数

注:如果x1,x2行函数前有void修饰符,则他们不是构造函数,而是一个普普通通的方法。

调用构造函数时,编译器会创建缺省的无参构造函数。如果我们定义了有参构造函数,编译器就不会再创建缺省的构造函数,我们必须按照定义的有参构造函数那样调用它,否则会出错的。


this():

我们可以在一个构造函数内调用其他被重载的构造函数。实现这一目的的手段是:this()

public class Class10 {
public Class10(){ ............................//x1
System.out.println("你好");................... //x2
}
public Class10(String s){...................//x3
this(); .......................................//x4,调用了Class10(),程序转向x1行
System.out.println(s);........................ //x5
}
public Class10(int a){.......................//x6
this("高兴"); .................................//x7,调用了Class30(String s),程序转向x2行
System.out.println(a);........................ //x8
}
public static void main(String[] args){
Class10 ob2=new Class10(20);................//x9
System.out.println(ob2); ......................//x10
}
}

程序执行的顺序是:x9→x6→x7→x3→x4→x1→x2→x5→x8→x10

记住一点:方法调用执行完毕后,就会返回到方法的调用处。

this()调用的限制:程序中,构造方法必须首先执行,所以this()调用必须是花括号内的第一条语句。

普遍方法只有在对象创建以后才能被调用,因此我们不能再普通方法中使用this(...),构造函数的调用只能用于创建对象。

 

9.类的初始化

我们不仅可以用构造函数初始化成员变量,也可以用其他方法。比如在定义类的同时给成员变量赋值,那么我们在创建该类的对象时,成员变量就会被赋入指定的值。

public class Class10 {
int a=10;.......................................//x1
static int b=20;................................//x2
public static void main(String[] args){
Class10 ob=new Class10();...................//x3
System.out.println(ob.a);
System.out.println(Class10.b);
}
}

//我们知道:成员变量只有在创建对象后,才会被分配内存。给还未分配内存的成员变量赋值行得通吗,当然行不通。实质上,x1行的语句只有在创建对象后才会被执行,从而给成员变量a赋值。

静态块:static{...},在类被加载到内存时会被执行。

public class Class10 {
static int a;
static{....................................x1
System.out.println("Hi...");...............x2
a=30; ................................... .x3,只能是static成员
}
public static void main(String[] args){
System.out.println("哈~~");.......................x4
System.out.println(a);............................x5
}
}

main()方法(静态方法)在类加载到内存后,才会被执行。所以,它比静态块执行得要晚。非静态成员变量不能在静态方法中使用,同样也不能在静态块中使用。static{...}主要用来初始化静态变量及静态方法。

实例块:instance指类的实例、类的对象,实例化就是指创建类的对象。广泛来说,对象就是类的实例。我们知道构造函数也是在创建类的对象时被执行,但二者相比,实例块要先于构造函数执行。

public class Class10 {
int a;
{.....................................//x1,实例块的开始
System.out.println("实例块");
a=10;
}.....................................//x2,实例块的结束
Class10(int a){
System.out.println("构造函数");
this.a=a;
}
public static void main(String[] args){
Class10 ob=new Class10(30);
System.out.println(ob.a);
}
}

//程序设计中,我们一般很少用实例块,而用的较多的是构造函数。

 

问题思考:

(1)定义一个满足要求的Point类,并创建对象进行测试。Point类拥有X坐标、y坐标,并提供获取坐标及改变坐标的方法。

(2)定义一个Rectangle(矩形)类,满足下面要求并创建对象进行测试。矩形类具有坐标及大小属性,并提供返回其宽度及改变宽度和高度的方法。


转载请注明: ITTXX.CN--分享互联网 » Java语言学习—第五章 类与对象[Java基础]

最后更新:2018-09-27 18:02:18

赞 (0) or 分享 ()
游客 发表我的评论   换个身份
取消评论

表情
(0)个小伙伴在吐槽