Java语言基础14-22--从抽象到类

从抽象到类

抽象的关键是抓住事物的两个方面：属性和功能。在实际生活中，我们每时每刻都与具体的事物在打交道，如我们用的钢笔、骑的自行车、乘坐的公交汽车等等。我们现在就可以对经常见到的卡车、公交汽车、小轿车进行抽象，找出它们共有的属性和功能，这里只会列举出部分：
属性：运行速度、发动机的功率。（静态的出厂卖的参数是属性，动态可以用来实现具体的功能，自己的理解）
功能:加速、减速、获取运行速度、设置发动机功率、获取发动机功率。
抽象的目的是从具体的实例中抽取共有属性和功能形成一种数据类型，比如我们的机动车类Vehicle，那么一个具体的轿车就是Vehicle类的一个实例，即对象。一个对象将自己的数据和对这些数据的操作合理有效的封装在一起，如我们的轿车调用“减速”改变的就是自己的运行速度。

 

一、类

类是组成Java程序的基本要素。

类封装了一类对象的状态和方法。

类是用来定义对象的模板。

类的实现包括两部分：类声明和类体。基本格式为：
class 类名 {
   类体的内容
}
class是关键字，用来定义类。

“class 类名”是类的声明部分，类名必须是合法的Java标识符。

两个大括号以及之间的内容是类体。

 

1、类声明

class Vehicle {
   ……
}
其中的“class Vehicle”称作类声明；“Vehicle”是类名。 
给类命名时，遵守下列编程风格（这不是语法要求的，但应当遵守）：
（1）如果类名使用拉丁字母，那么名字的首字母使用大写字母，如。
（2）类名最好容易识别、见名知意。当类名由几个“单词”复合而成时，每个单词的首字母使用大写。 
 

2、类体

类声明之后的一对大括号“{”，“}”以及它们之间的内容称作类体，大括号之间的内容称作类体的内容。 

类体的内容由两部分构：一部分是变量的声明，用来刻画属性；另一部分是方法的定义，用来刻画功能。 

 

3、成员变量

类体分为两部分：一部分是变量的声明，另一部分是方法的定义。
变量声明部分所声明的变量被称做域变量或成员变量
a、成员变量的类型：成员变量的类型可以是Java中的任何一种数据类型，包括基本类型：整型、浮点型、字符型；引用类型：数组、对象和接口。
b、成员变量的有效范围：成员变量在整个类内都有效，其有效性与它在类体中书写的先后位置无关。 
（3）编程风格
a、一行只声明一个变量。 
b、变量的名字符合标识符规定。 
c、变量名字见名知意，避免容易混淆的变量名字。

 

4、方法

方法的定义包括两部分：方法声明和方法体。

一般格式为：

方法声明部分 {
         方法体的内容
    }

4.1 方法声明

方法声明包括方法名和方法的返回类型，如：
    double getSpeed() {
    return speed;
    }   
注：方法的返回类型、方法的参数、方法的名字
（1）return语句的作用：
   a、返回一个值，这个值可以是任意类型。
   b、使程序返回到操作系统（即终止程序）
（2）java中对于一个函数，不论有没有返回值类型，都可以带有return 语句。但是区别在于，return 语句是否可以返回一个值（这取决与该函数的返回值类型）。
   a、如果函数有返回值类型（即返回值类型不为void ），则必须带有返回相应类型值的return 语句。
   b、如果函数没有返回值（即返回值类型为void ），则函数中return 语句（如果存在return语句！）的后面不能加任何的变量。（该情况下的函数中也可以没有return 语句，但是如果有的话，return 只能作为返回操作系统的作用使用。）

4.2 方法体

方法声明之后的一对大括号“{” ，“}”以及之间的内容称作方法的方法体。方法体的内容包括局部变量的声明和Java语句。
在方法体中声明的变量和方法的参数被称作局部变量。
局部变量只在声明它的方法内有效，而且与其声明的位置有关。方法的参数在整个方法内有效，方法内的局部变量从声明它的位置之后开始有效。如果局部变量的声明是在一个复合语句中，那么该局部变量的有效范围是该复合语。

 

5、注意事项

（1）如果局部变量的名字与成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效。
如果想在该方法中使用被隐藏的成员变量，必须使用关键字this  。 
（2）类体的内容由两部分构成：一部分是变量的声明，另一部分是方法的定义。 

对成员变量的操作只能放在方法中，方法可以对成员变量和该方法体中声明的局部变量进行操作。

在声明成员变量时可以同时赋予初值，但是不可以在类体中有单独的赋值语句（不可以有变量的声明和方法的定义以外的其它语句）。

 

二、构造方法与对象的创建

类是面向对象语言中最重用的一种数据类型，那么就可以用它来声明变量。在面向对象语言中，用类声明的变量被称作对象。

和基本数据类型不同，在用类声明对象后，还必须要创建对象，即为声明的对象分配变量(确定对象所具有的属性)，当使用一个类创建一个对象时，也称给出了这个类的一个实例。

通俗的讲，类是创建对象的“模板”，没有类就没有对象。构造方法和对象的创建密切相关。

 

1、构造方法

构造方法是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型。

PS：构造方法没有类型，且不是void。void是一种类型，叫做无返回值。
允许一个类中编写若干个构造方法，但必须保证他们的参数不同，即参数的个数不同，或者是参数的类型不同。 
  需要注意的是
（1） 如果类中没有编写构造方法，系统会默认该类只有一个构造方法，该默认的构造方法是无参数的，且方法体中没有语句。
（2）如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法 。 

 

2、创建对象

（1）对象的声明
一般格式为：
类的名字  对象名字;如：
 Vehicle car;
 这里Vehicle是一个类的名字，car是我们声明的对象的名字。

（2）为声明的对象分配内存 
使用new运算符和类的构造方法为声明的对象分配变量，即创建对象。如果类中没有构造方法，系统会调用默认的构造方法，默认的构造方法是无参数的，且方法体中没有语句。如：
 car=new Vehiclee(); 

2.1 内存模型

（1）声明对象时的内存模型 
   Vehicle car1 ；

这时的car1是空对象，空对象不能使用，因为它还没有得到实体，必须再进行为对象分配变量的步骤。
（2）对象分配内存后的内存模型
  car1 = new Vehicle(); 

在这里做了以下两件事：
a、Vehicle类中的成员变量speed和power被分配内存空间，然后执行构造方法中的语句。如果成员变量在声明时没有指定初值，所使用的构造方法也没有对成员变量进行初始化操作，那么对于整数类型，默认初值是0；对于浮点型，默认初值是0.0；对于boolean型，默认初值是false；对于引用类型，默认初值是null。
b、new运算符在为变量speed和power分配内存以后，将得到一个引用，这个引用是一个十六进制数，包含有给这些成员变量所分配的内存位置等重要信息，如果将该引用赋值到对象变量car1中，就确保了car1得到了名字为speed和power的变量。
（3）创建多个不同的对象

 

3、使用对象

对象不仅可以操作自己的变量改变状态，而且能调用类中的方法产生一定的行为。
    通过使用运算符“.”，对象可以实现对自己变量的访问和方法的调用。 
（1）对象操作自己的变量（对象的属性）
    对象.变量; 
（2）对象调用类中的方法（对象的功能） 
  对象.方法; 
（3）体现封装 
     当对象调用方法时，方法中出现的成员变量就是指分配给该对象的变量。 

 

4、对象的引用和实体

类是体现封装的一种数据类型，类声明的变量称做对象，对象中负责存放引用，以确保对象可以操作分配给该对象的变量以及调用类中的方法。分配给对象的变量习惯地称做对象的实体。 
（1）避免使用空对象
       没有实体的对象称作空对象，空对象不能使用，即不能让一个空对象去调用方法产生行为。
（2）垃圾收集
一个类声明的两个对象如果具有相同的引用，那么二者就具有完全相同的实体，而且Java有所谓“垃圾收集”机制，这种机制周期地检测某个实体是否已不再被任何对象所拥有（引用），如果发现这样的实体，就释放实体占有的内存。

4.1 内存模型

Vehicle carOne  =  new Vehicle ();
Vehicle carTwo  =  new Vehicle (); 
carOne.speedUp(60);
carTwo.speedUp(90); 

carOne = carTwo 

 

三、参数传值

方法中最重要的部分之一就是方法的参数，参数属于局部变量，

当对象调用方法时，参数被分配内存空间，并要求调用者向参数专递值，即方法被调用时，参数变量必须有具体的值。

1、传值机制

在Java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者指定的值的拷贝。

例如，如果向方法的int型参数x传递一个int值，那么参数x得到的值是传递的值的拷贝。

2、基本数据类型的传值

对于基本数据类型的参数，向该参数传递的值的级别不可以高于该参数的级别 。

例如，int可以传给long，long不可以传给float。

3、引用类型参数的传值

当参数是引用类型时，“传值”传递的是变量中存放的“引用”，而不是变量所引用的实体。（有点类似C++中的地址）

4、可变参数

可变参数是指在声明方法时不给出参数列表中从某项直至最后一项参数的名字和个数，但这些参数的类型必须相同。

可变参数使用“…”表示若干个参数，这些参数的类型必须相同，最后一个参数必须是参数列表中的最后一个参数。

例如： public void f(int … x) 那么，方法f的参数列表中，从第1个至最后一个参数都是int型，但连续出现的int型参数的个数不确定。

称x是方法f的参数列表中的可变参数的“参数代表”。 

参数代表可以通过下标运算来表示参数列表中的具体参数，即x[0]，x[1]…x[m]分别表示x代表的第1个至第m个参数。

（使用方法和数组完全相同）

 

四、实例成员与类成员

1、实例变量与类变量的声明

在之前的学习类的时候我们知道类体中包括成员变量的声明和方法的定义，而成员变量又可以细分为实例变量和类变量。

在声明成员变量时，用关键字static给予修饰的称作类变量，否则称作实例变量（类变量也称为static变量，静态变量）。
class Dog {
   float x;      //实例变量
   static int y;   //类变量
  } 

 

2、实例变量与类变量的区别

（1）不同对象的实例变量互不相同 
我们已经知道，一个类通过使用new运算符可以创建多个不同的对象，这些对象将被分配不同的成员变量。

再准确的说，就是分配给不同对象的实例变量占有不同的内存空间，改变其中一个对象的实例变量不会影响其他对象的实例变量。
（2）所有对象共享类变量
如果类中有类变量，当使用new运算符创建多个不同的对象时，分配给这些对象的类变量占有相同的一处内存，改变其中一个对象的类变量就会影响其他对象的类变量。
（3）通过类名直接访问类变量 
当Java程序执行时，类的字节码文件被加载到内存中，如果该类还没有创建对象，那么类中的实例变量就不会被分配内存。

但是，类中的类变量，在该类被加载到内存中时，就分配了相应的内存空间。

如果该类创建对象，那么不同对象的实例变量互不相同，即分配不同的内存空间，但是类变量就不再重新分配内存，

所有的对象共享类变量，即所有的对象的类变量是相同的一处内存空间，类变量的内存空间直到程序退出运行，才会释放所占有的内存。

 

3、实例方法和类方法的定义

类中的方法也可分为实例方法和类方法。

方法声明时，方法类型前面不加关键字static修饰的是实例方法、加static关键字修饰的是类方法(静态方法)。
class A {
   int a;
   float max(float x,float y) {  //实例方法
     …
   }
   static float jerry() {       //类方法
     … 
   }
   static void speak(String s) { //类方法
     … 
   }
} 

 

4、实例方法和类方法的区别

（1）对象调用实例方法
当对象调用实例方法时，该方法中出现的实例变量就是分配给该对象的实例变量；

该方法中出现的类变量也是分配给该对象的变量，只不过这个变量和所有的其他对象共享而已。
（2）类名调用类方法
类方法不仅可以被类创建的任何对象调用执行，也可以直接通过类名调用。

和实例方法不同的是，类方法不可以操作实例变量，这是因为在类创建对象之前，实例成员变量还没有分配内存。

 

五、方法重载和this关键字

1、方法重载

方法重载的意思是：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者是参数的个数不同，或者是参数的类型不同。
 class A {
   float add(int a,int b) {
      return a+b;
   }
   float add(long a,int b) {
      return a+b;
   }
   double add(double a,int b) {
      return a+b;
   }
}

 

2、this关键字

this是Java的一个关键字，表示某个对象。this可以出现在实例方法和构造方法中，但不可以出现在类方法中。
实例方法可以操作类的成员变量，当实例成员变量在实例方法中出现时，默认的格式是：
this.成员变量;
当static成员变量在实例方法中出现时，默认的格式是：
类名.成员变量;
当一个对象调用方法时，方法中的实例成员变量就是指分配给该对象的实例成员变量，而static变量则和其他对象共享。

因此，通常情况下，可以省略实例成员变量名字前面的“this.”，以及static变量前面的“类名.”。
但是，当实例成员变量的名字和局部变量的名字相同时，成员变量前面的“this.”或“类名.”就不可以省略。  
注：this不能出现在类方法中，这是因为，类方法可以通过类名直接调用，这时，可能还没有任何对象诞生。

 

六、包和import语句

1、包

1.1 包语句

通过关键字package声明包语句。
        package语句作为Java源文件的第一条语句，为该源文件中声明的类指定包名。
 package语句的一般格式为：
     package 包名; 
例如：
    package sunrise;
          package sun.com.cn; 

 

1.2 有包名的类的存储目录

如果一个类有包名，那么就不能在任意位置存放它，否则虚拟机将无法加载这样的类。 
     程序如果使用了包语句,例如：package tom.jiafei;
 那么存储文件的目录结构中必须包含有如下的结构    
   …\tom\jiafei
 如：
  c:\1000\tom\jiafei
 并且要将源文件编译得到的类的字节码文件保存在目录c:\1000\tom\jiafei中（源文件可以任意存放）。

 

1.3 运行有包名的主类

如果主类的包名是tom.jiafei，那么主类的字节码一定存放在…\tom\jiefei目录中，运行时必须到tom\jiefei的上一层（即tom的父目录）目录中去运行主类。
假设tom\jiefei的上一层目录是1000，那么，必须如下格式来运行：
  C:\1000\java tom.jiafei.主类名 

 

2、import语句

2.1 引入类库中的类

使用import语句可以引入包中的类。在编写源文件的时候，除了自己编写的类以外，经常需要使用Java提供的许多类，这些类可能在不同的包中。

在学习Java语言时，使用已经存在的类，避免一切从头做起，这也是面向对象编程的一个重要方面。
为了能够使用Java提供给我们的类，可以使用import语句引入包中类。

在一个Java源程序中可以有多个import语句，它们必须写在package语句（假如有package语句的话）和源文件中类的定义之间。

Java为我们提供了大约130多个包，比如：
java.lang           包含所有的基本语言类
javax.swing       包含抽象窗口工具集中的图形、文本、窗口GUI类
java.io               包含所有的输入输出类
java.util             包含实用类
java.sql             包含操作数据库的类
java.nex            包含所有实现网络功能的类
java.applet        包含所有实现Java applet的类

 

2.2 引入自定义包中的类

用户程序可以使用tom.jiafei包中的类
如：import tom.jiafei.*;
        使用非类库中有包名的类，也要使用import语句。

 

2.3 使用无包名的类

之前，我们在源文件中一直没有使用包语句，因此各个源文件得到的类都没有包名。

如果一个源文件中的类想使用无名包中的类，只要将这个无包名的类的字节码和当前类保存在同一目录中即可。

 

2.4 避免类名混淆

（1）区分无包名和有包名的类
        如果一个源文件使用了一个无名包中的A类，同时又用import语句引入了某个有包名的同名的类，如tom.jiafei中的A类，就可能引起类名的混淆。 
（2）区分有包名的类
       如果一个源文件引入了两个包中同名的类，那么在使用该类时，不允许省略包名 。

 

七、访问权限

当用一个类创建了一个对象之后，该对象可以通过“.”运算符操作自己的变量、使用类中的方法，但对象操作自己的变量和使用类中的方法是有一定限制的。  
所谓访问权限是指对象是否可以通过“.”运算符操作自己的变量或通过“.”运算符使用类中的方法。 
访问限制修饰符有private、protected和public，都是Java的关键字，用来修饰成员变量或方法。 

1、私有变量和私有方法

用关键字private修饰的成员变量和方法称为私有变量和私有方法。 
对于私有成员变量或方法，只有在本类中创建该类的对象时，这个对象才能访问自己的私有成员变量和类中的私有方法。
 class Tom {
    private float weight; 
    private float f(float a,float b){  
        return a+b;
    }     
}
class Jerry {
   void g() {
       Tom cat=new Tom();
       cat.weight=23f;    //非法
       float sum=cat.f(3,4);   //非法
    }
}

 

2、共有变量和共有方法

用public修饰的成员变量和方法被称为共有变量和共有方法 。 
我们在任何一个类中用类Tom 创建了一个对象后，该对象能访问自己的public变量和类中的public方法（也可以通过类名来操作成员变量、方法） 。
class Tom {
    public float weight;  
    public float f(float a,float b) {  
         return a+b;
    }  
}
class Jerry {
  void g() { 
        Tom cat=new Tom();
         cat.weight=23f;     //合法
         float sum=cat.f(3,4);   //合法
    }
}

 

3、受保护的变量和方法

用protected修饰的成员变量和方法被称为受保护的成员变量和受保护的方法 。
我们在任何一个类中用类Tom 创建了一个对象后，如果这个类和类Tom在同一个包中，那么该对象能访问自己的protected变量和类中的protected方法。
class Tom { 
    protected  float weight;              
    protected float f(float a,float b) {   
        return a+b;
    }     
}
class Jerry {  
   void g() {
        Tom cat=new Tom();
        cat.weight=23f;      //合法
        float sum=cat.f(3,4); //合法
    }

 

4、友好变量和友好方法

不用private、public、protected修饰的成员变量和方法被称为友好变量和友好方法。
我们在任何一个类中用类Tom 创建了一个对象后，如果这个类和类Tom在同一个包中，那么该对象能访问自己的友好变量和类中的友好方法。
class Tom { 
    protected  float weight;              
    protected float f(float a,float b) {   
        return a+b;
    }     
}
class Jerry {  
   void g() {
        Tom cat=new Tom();
        cat.weight=23f;      //合法
        float sum=cat.f(3,4); //合法
    }

 

5、public类与友好类

类声明时，如果在关键字class前面加上public关键字，就称这样的类是一个public 类 。
可以在任何另外一个类中，使用public类创建对象。 
如果一个类不加public修饰，这样的类被称作友好类。
在另外一个类中使用友好类创建对象时，要保证它们是在同一包中。
注：
（1）不能用protected和private修饰类
（2）访问限制修饰符按访问权限从高到低的排列顺序是：public、ptotected、友好的、private。