第六章总结

类和对象

对象

类 

类是封装对象的属性和行为的载体,反过来说具有相同属性和行为的一类实体被称为类，例如鸟类封装了所有鸟类的共同属性和应具有的行为：

、

2.封装

简单来说把静态属性和动态属性封装到一个盒子（类）里的那个动作

面向对象程序设计具有以下特点：封装性，继承性和多态性

封装是面向对象编程的核心思想，将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装思想。

采用封装思想保证了类内部数据结构的完整性，使用类的用户不能轻易地直接操作类的数据结构，只能执行类允许公开的数据，这样子就避免了外部操作对内部数据的影响，提高了程序可维护性，使用类实现封装特性如图：

3.继承

父类继承子类（类与类的 继承）

继承就是子类继承父类的特征（属性）和行为，使得子类对象具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为，继承可以使得子类具有父类别的各种属性和方法，而不需要再次重复编写代码，从而简单快速化，在子类继承父类的同时，，可以重新定义一些属性，并重新写方法，即覆盖父类原有的属性和方法，使父类别不同的功能。

类继承父类可以获得父类的功能，提高代码的复用性

子类可以重写（覆盖）某些父类的功能

子类除了可以继承父类的功能之外，还可以额外添加子类独有的功能，一般来说，子类要比父类强大（你的是我的，我的还是我的）；

4.多态

展现不同多种的形态出现(将父类对象应用与子类的特征就是多态)

多态也是面向对象中一项主要的特征，多态性体现了程序的可扩展性，代码的复用性。

使用图形类来说明多态，每个图形都有拥有绘制自已的能力，这个能力可以看作该类具有的行为，将子类的对象统一看作父类的实例对象，这样子当绘制图形时，简单地调用父类也就是图形类绘制图形方法即可绘制任何图形，这就是多态的最基本思想

提到多态，就不得不提到抽象类和接口，因为多态的实现并不依赖具体类，而是依赖抽象类和接口。在多态的机制中，比抽象类更方便的是将抽象类定义为接口，由抽象方法组成的集合就是接口。

多态的条件：

继承或实现

方法的重写

父类引用指向子类对象

（二）类

（1）成员变量

它包含getName和setName（）

以下快速生成getName和setName（）的方法

勾选需要生产成getName和setName的变量然后按下‘Generate’即可

1）成员变量

【例6.1】为书添加书名属性

定义成员方法的语法格式如下：

权限修饰符 返回值类型 方法名（参数类型 参数名）{
....
return 返回值；
}

一个成员方法可以有参数，这个参数可以为对象，也可以是基本数据类型的变量，同时成员方法返回值和不返回值的选择，如果方法需要返回值，可以在方法中使用return关键字，使用关键字后，方法的执行将被终止

（2）权限修饰符

java中的权限修饰符主要包括private,public和protected，这些修饰符控制着类和类的成员变量，以及成员变量的访问，表中表述了private，protected，public以及默认的default修饰符的修饰权限。

1. 局部变量

如果在一个成员方法里定义一个变量，那么这个变量就称为局部变量，局部变量是在方法被执行时创建，在方法执行结束时销毁，局部变量在使用时必须进行赋值操作或被初始化，否则出现编译错误。

【例6.2】交换两个整数的值

public class ChangDemo {
 public static int[] exchange(int[] arr) {
  int tmp = arr[0];   //创建局部变量tmp，保存数组第一个元素的值
  arr[0] = arr[1];   //第二个元素值赋给第一个元素
  arr[1] = tmp;    //第二个元素值改为tmp
  return arr;
 }
 
 public static void main(String[] args) {
  int arr[] = {17,29};
  System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
  arr = exchange(arr);
  System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
 }
}

输出结果：

（2）this关键字

this关键字用于表示本类的当前对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类，this关键字只能在本类的使用

public void setName(string name){
this.name=name;
}
其实，this除了可以调用成员变量和成员方法，还可以作为方法的返回值，如：

public Book getBook（）{
return this;
}
(3)类的构造方法

在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法，构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的，当类实例化一个对象时，类都会自动调用构造方法。

构造方法的特点如下：

构造方法没有返回值

构造方法的名称要与本类的名称相同

构造方法的定义语法格式如下：

public Book{
...//构造方法体
}
【例6.3】“构造”鸡蛋灌饼

public EggCake(int eggCount) {   //参数为鸡蛋灌饼里蛋的个数的构造方法
  this.eggCount = eggCount;  //参数eggCount的值付给属性eggCount
 }
 
 public EggCake() {               //无参数构造方法，默认给饼加一个蛋
  this(1);     //调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1
 }
 
 public static void main(String[] args) {
  EggCake cake1 = new EggCake();
  System.out.println("顾客不要求加蛋的数量，饼里会有"+cake1.eggCount+"个蛋。");
  EggCake cake2 = new EggCake(2);
  System.out.println("顾客要求加蛋的数量，饼里会有"+cake2.eggCount+"个蛋。");
 }
}

输出结果： 

（三）静态变量和静态方法

在介绍静态变量和静态方法前，首先需要介绍static关键字，因为由static修饰的变量和方法称为静态变量和静态方法。

被声明为static的变量和方法被称为静态成员，静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和“.”运算符调用静态成员，语法：类名.静态类成员。

例6.4】创建并调用静态属性和静态变量

public class StaticDemo {
 static double PI = 3.1415;  //在类中定义静态变量
 
 public static void method() {  //在类中定义静态方法
  System.out.println("这是静态方法");
 }
 public static void main(String[]args) {
  System.out.println(StaticDemo.PI);   //调用静态变量
  StaticDemo.method();    //调用静态方法
 }
}

输出结果：

静态成员与静态方法的作用通常为了提供共享数据或方法，尽管使用这种方式调用静态成员比较方便，但静态成员同样遵循public，private和protected修饰符的约束

【例6.5】统计顾客总人数

public class Cust {                //顾客类
 static int count = 0;          //共享的属性：人数
 String name;                   //名称属性
public Cust(String name) {
 this.name = name;    //记录名称
 count++;      //人数递增
}
public static void main(String[]args) {
 Cust c1 = new Cust("tom");
 System.out.println("我是第"+Cust.count+"名客户，我叫"+c1.name);
 Cust c2 = new Cust("张三");
 System.out.println("我是第"+Cust.count+"名客户，我叫"+c2.name);
 Cust c3 = new Cust("狗蛋儿");
 System.out.println("我是第"+Cust.count+"名客户，我叫"+c3.name);
}
}

如果在执行类中，希望先执行类的初始化操作，可以使用static定义一个静态区域，这块区域也称为静态代码块，当类文件被执行时，会首先执行static块中的程序，并且只会执行一次，静态代码块的语法如下：

public class example{
static {
//代码块
//代码块
......
}
}

(四)类的主方法

主方法是类的入口点，它定义了程序从何处开始，主方法提供对程序流向的控制，java编译器通过主方法来执行程序，主方法的语法如下：

public static void main(String[]args){
                                      //方法体

}

主方法具有以下特性：

主方法是静态的，所以如果要直接在主方法中调用其他方法，则该方法必须也是静态的

主方法没有返回值

主方法的形参为数组，其中，args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length获取参数的个数

【例6.6】读取主方法的参数值

package liudanyuan;

public class lei6_6 {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  for(int i = 0;i<args.length;i++) {
   System.out.println(args[i]);
  }
 }

}

 输出结果：

运行代码前，先要在eclipse中设置运行参数，步骤如下：

1，在eclipse中的MianDemo.java文件上单击鼠标右键，在弹出的快捷菜单中选择泽“运行方式”/“运行配置”（英文版为Run As/Run Configrations），弹出“运行配置”(Run Configrations)对话框

2，在“运行配置”对话框中选择“自变量”（Arguments）选项卡，在“项目”(Progran argumrnts)文本框输入相对应的参数，每个参数间按enter键隔开，

3，单击“运行”按钮，查看控制台运行结果，结果如上：

如果不按以上操作，直接运行源码，则不会输出如何结果。

 

（五）对象

（1）对象的创建

在前面中讲解过对象，对象可以认为是在一类事物中抽象某一个特例，可以通过这个特例来处理这类事物出现的问题，在java语言中，通过new操作符来创建对象，在讲解构造方法时介绍过，每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程。准确的说，可以在java语言中使用new操作符调用构造方法创建对象，语法如下：

Tset tset=new Tset();
Tset tese=new Tset("a");

其参数声明如下表：

test构造方法的参数test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间，可以在构造方法中初始化成员变量，当创建对象时，自动调用构造方法。也就是说，在 Java语言中，初始化与创建是被捆绑在一起的。每个对象都是相互独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成垃圾，由 Java 虚拟机自带的垃圾回收机制处理，不能再被使用(对于垃圾回收机制的知识)。

【例6.7】创建人类并创建其对象

public class Dog {    //狗
 String name;    //名字
 String Color;    //颜色
 String vioce;    //声音
 
 public Dog(String name,String color,String vioce) {
  this.name = name;
  this.Color = color;
  this.vioce = vioce;
 }
 
 public void call() {     //叫
  System.out.println(vioce);
 }
 
 public static void main(String[]args) {
  Dog d1 = new Dog("毛毛","白色","汪汪汪");
  System.out.print(d1.name+"的颜色是"+d1.Color);  //访问对象的属性
  System.out.print(",叫起来的声音：");
  d1.call();          //访问对象的行为
  
  Dog d2 = new Dog("灰灰","灰色","嗷呜~");
  System.out.print(d2.name+"的颜色是"+d2.Color);
  System.out.print(",叫起来的声音：");
  d2.call();
  
 }
}

输出结果：

（2）访问对象的属性和行为

用户使用new操作符创建一个对象之后，可以使用“对象.类成员”来获取对象的属性和行为，前面已提到过，对象的属性和行为在类中是通过类的成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应地获取了对象的属性和行为。

【例6.8】描述狗的特征

（3）对象的引用

在java中，尽管一切都可以看作对象，但真正的操作标识符实质上是一个引用，那么引用在java中是如何体现的呢，语法如下：

类名 对象的引用变量
例如，一个people类的引用可以使用以下代码:
people tom;
通常一个引用不一定需要有一个对象关联，引用与对象相关联的语法如下：
people tom=new people();

 在上述代码中，各个单词的含义如图：

实际上真正的对象是“new people（）”这段代码，为了方便开发者保存，，调用对象，于是创建了一个people类型，名叫tom的引用变量。既然tom是new people的“代理人”,那么“new people（）”对象能做的事情，tom也能做，如下面代码：

new people().getClass();
等价于
people tom=new people();
tom.getclass();

(4)对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收。在其他语言中，需要用户手动回收废弃的对象。Java 拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源。

在学习垃圾回收机制之前，读者首先需要了解何种对象会被 Java 虚拟机视为“垃圾”。主要包括以下两种情况:

1.对象引用超过其作用范围，这个对象将被视为垃圾

 2.将对象赋值为null，如图所示：

 但垃圾系统只能回收new操作符创建的对象，某些对象不是通过new操作符在内存中获取存储空间的，这种对象无法被垃圾回收机制识别，在java中，提供了finalize（）方法，这个方法是object类的方法，它被声明为protected，用户可以在自已的类中定义这个方法，如果用户在类中定义了finalize（)方法，在垃圾回收会首先调用该方法，在下一次垃圾回收动作发生时，才真正回收被对象占用的内存