第六章 类和对象
面向对象概述
对象
现实世界中，随处可见的一种事物就是对象。对象是事物存在的实体，如人、书桌、计算机、高楼大厦等。通常都会将对象划分为两个部分，即静态部分与动态部分。·静态部分就是不能动的部分，这个部分被称为“属性”，任何对象都会具备其自身属性，如一个人，其属性包括高矮、胖瘦、性别、年龄等。动态部分即对象可执行的动作，这部分称为“行为”，同样一个人，其可以哭泣、微笑、说话、行走，这些都是个人具备的行为。
类
类就是对象的设计图
不能将一个事物描述成一类事物，如一只鸟不能称为鸟类。但如果要给某一类事物一个统称，就需要用到类这个概念。
类就是同一类事物的通常。类是封装对象的属性和行为的载体，反过来说，具有相同属性和行为的一类实体被称为类。例如，鸟类封装了所有鸟的共同属性和具有的行为。
封装
面向对象程序设计具有以下特点：封装性、继承性、多态性。
封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。
采用封装的思想保证了类内部数据结构的完整性，使用类的用户不能轻易地直接操作类的数据结构，只能执行类允许公开的数据。这样就避免了外部操作对内部数据的影响，提高了程序的可维护性。
继承
类与类之间同样具有关系，这种关系被称为关联。关联主要描述两个类之间的一般二元关系。例如,一个百货公司类与销售类就是一个关系，学生类与教师类也是一个关联。
当处理一个问题时，可以将一些有用的类保留下来，在遇到同样的问题时拿来复用。鸽子类保留了鸟类的属性和行为，这样就节省了定义鸟和鸽子共同具有的属性和行为的时间，这就是继承的基本思想。
继承性主要利用特定对象之间的共有属性。例如，平行四边形是四边形，正方形、矩形也都是四边形，平行四边形类与四边形具有共同特性，就是拥有4个边，可以将平行四边形类看作四边形类的延伸，平行四边形类复用了四边形类的属性和行为，同时添加了平行四边形独有的属性和行为，如平行四边形的对边平行且相等。这里可可以将平行四边形类看作是从四边形类中继承的。在 Java 语言中，将类似于平行四边形类的类称为子类 将类似于四边形类的类称为父类或超类。值得注意的是，可以 说平行四边形是特殊的四边形，但不能能说四边形是平行四边形，也就是说子类的实例都是父类的实例，但不能说父类的实例是子类的实例。图6.6阐明了图形类之间的继承关系。
一个类处于继承体系中，它既可以是其他类的父类，为其他类提供属性和行为，也可以是其他类的子类，继承父类的属性和方法。
多态
继承、父类和子类，其实将父类对象应用于子类的特性就是多态。
多态性允许以统一的风格编写程序，以处理种类繁多的已存在的类及相关类。改统一风格可以由父类来实现，根据父类统一风格的处理，可以实例化之类的对象。这样就降低了维护的难度 ，节省了时间。
类
成员变量
在java中，对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均是成员变量作用范围。
例6.1：
public class Book {//类
private String name;//String类型的成员变量
public String getName() {//name的Getter方法
return name;
}
public void setName(String name) {//name的Setter方法
this.name=name;//将参数值赋予类中的成员变量
}
}
在上面这个实例中可以 看到，在JAVA语言中需要使用class关键词来定义类，Book是类的名称。同时在
Book类中定义了一个成员变量，成员变量的类型为String类型。
成员方法
在Java语言中，使用成员方法对应于类的行为。以Book类为例，它包括getName()和setName()两个方法，定义成员方法的语法格式如下：
权限修饰符 返回值类型 方法名(参数类型 参数名){
... //方法体
return 返回值
}
3：权限修饰符
Java中的权限修饰符主要包括private、public和protected，这些修饰符控制着对类和类的成员变量以及成员方法的访问。
使用getter(获取)和setter(设置)方法：this表示这个类
但是有很多个的时候就会很麻烦，比如：几十个，上百个。那么就需要用编译器来实现便捷方法。
4、局部变量
如果在成员方法内定一个变量，那么这个变量被称为局部变量。实际上方法中的形参也可作为一个局部变量。例如在例6.1的Book类中定义setName（String name）方法，String name这个形参就被看作是局部变量。
局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。
例6.2：在ChangeDemo类中创建静态的exchange（）方法，该方法可以将数组参数arr的前两个元素值互换，通过在方法中定义一个保存临时数据的局部变量tmp,利用tmp交换两个元素的值。
public class ChangeDemo {
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) {
// TODO Auto-generated method stub
int arr[]= {17,29};
System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
arr=exchange(arr);
System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
}
} 运行结果：
5、局部变量的有效范围
可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。图6.7描述了局部变量的作用范围。
6、this关键字
this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键词只能在本类中使用。
例如，例6.1的Book类中定义setName()方法代码如下：
public void setName(String name){ //定义一个setName()方法
this.name=name; //将参数值赋予类中的成员变量
}
类的构造方法
在类中，除成员方法外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。
构造方法的特点如下：
构造方法没有返回值。
构造方法的名称要与本类的名称相同。
构造方法的定义语法格式如下：
public Book(){
... //构造方法体
}
public：构造方法修饰符；Book：构造方法的名称。
在构造方法中可以为成员变量赋值，这样当实例化一个本类对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。
例6.3：当顾客购买鸡蛋灌饼时，如果要求加两个蛋，店家就给饼加两个蛋；不要时，店家会默认给饼加一个蛋。创建鸡蛋灌饼类，使用this关键字，在无参数构造方式中调用有构造方法，实现上加述加蛋过程。代码如下：
public class EggCake {
int eggcake;//鸡蛋灌饼里蛋的个数
public EggCake(int eggCount) {//参数为鸡蛋灌饼里蛋的个数的构造方法
this.eggcake=eggCount;//将参数eggCount大的值付给属性eggCount
}
public EggCake() {//无参数构造方法，默认给饼加一个蛋
//调用参数为鸡蛋灌饼里蛋的个数的构造方法，并设置鸡蛋灌饼里蛋的个数为1
this(1);
}
public static void main(String[] args) {
// TODO Auto-generated method stub
EggCake cake1=new EggCake();
System.out.println("顾客不要求加蛋的数量，饼里会有"+cake1.eggcake+"个蛋。");
EggCake cake2=new EggCake(2);
System.out.println("顾客要求加2个蛋，饼里会有"+cake2.eggcake+"个蛋。");
}
}
运行结果：
静态变量和静态方法
由static修饰的变量和方法被称为静态变量和动态方法。被声明为static的变量和方法被称为静态成员。静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和”.“运算符调用静态成员。语法如下：
类名.静态类成员
例6.4：创建StaticDemo类，在类中使用static关键字定义一个属性和一个方法，并在主方法中条用。
public class StaticDemo {
//静态变量
static double PI=3.1415926;//在类中定义静态变量
//静态常量
static final int i=3;
//静态方法
static void method() {//在类中定义静态方法
System.out.println("静态方法");
}
//静态代码块
static
{
//1
//2
//3
//4
//5
}
public static void main(String[] arge) {
System.out.println(StaticDemo.PI);//调用静态变量
System.out.println(StaticDemo.i);//调用静态常量
StaticDemo.method();//调用静态方法
}
运行结果：
静态变量与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等。尽管使用这种方式调用静态成员比较方便，但静态成员同样遵循着public、private和protected修饰符的约束。
在Cust类中创建一个静态整数类型属性count，在构造方法中让count自增。
public class Cust {//顾客类
static int count=0;//共享的属性：人数
String name;//名称属性
public Cust(String name) {
this.name=name;//记录名称
count++;//人数递增
}
public static void main(String[] args) {
// TODO Auto-generated method stub
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关键字要注意的几点：
1、在静态方法中不可使用this关键字。
2、在静态方法中不可以直接调用非静态方法。
3、局部变量不可以使用static关键字声明。
4、主方法必须用static声明。
5、只有内部类可以使用static关键字声明。
类的主方法
主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java编译器通过主方法来执行程序。主方法的语法如下：
public static void main(String[] args) {
...... //方法体
}
在主方法的定义中可以看到其具有以下特点：
1、主方法是静态的，所以如要直接在主方法中条用其他方法，则该方法必须也是静态的。
2、主方法没有返回值。
3、主方法的形参为数组。其中，args[0]~[n]分别代表程序的第一个参数到n个参数，可以使用args.length获取参数的个数。
例6.6：在项目创建part类，在主方法中编写一下代码，并在Eclipse中设置程序参数。
public class MainDemo {
public static void main(String[] args) {//定义主方法
// TODO Auto-generated method stub
for(int i=0;i运行代码前先要在 Eclipse中设置运行参数，步骤如下：
1、在Eclipse中的Maindem.Java文件上单击鼠标右键，在弹出的快捷菜单中选择“运行方式”/“运行配置”(英文版为Run As/Run Configrations),弹出“运行配置”(Run Configrations)对话框。
2、在“运行配置”对话框中选择“自变量”(Arguments)选择卡，在“项目”(Program arguments)文本框中输入相应的参数，每个参数间按Enter键隔开。
3、单击“运行”按钮，查看控制台运行结果。运行结果：
如果不按照以上步骤操作，直接运行源码，则不会输出任何结果。
对象
Java是一门面向对象的程序设计语言，对象是由类实例化而来的，所有问题都通过对象来处理。对象可以通过操作类的属性和方法来解决相应的问题，所以了解对象的产生、操作和消亡是十分必要的。
1、对象的创建
对象可以认为是在一类事物中抽象出某一个特例，可以通过这个特例来处理这类事物出现的问题。在Java语言中，通过new操作符来创建对象。准确的来说，可以在Java语言中使用new操作符调用构造方法创建对象。语法如下：
Test test = new Test();
Test test = new Test("a");
test对象被创建出来时，就是一个对象的引用，这个应用在内存中为对象分配了储存空间。在Java语言中，初始化与创建是被捆绑在一起的.
每个对象都是互相独立的，在内存中占据独立的内存地址，并且每个对象都具有自己的生命周期，当一个对象的生命周期结束时，对象就变成垃圾，由Java虚拟机自带的垃圾回收机制处理，不能再被使用。
public class People {
//成员变量
private String name;//姓名
private int age;//年龄
private String sex;//性别
private double height;//身高
private double weight;//体重
//对外提供 getter 和 setter 方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
//成员方法
//写代码 方法名：code 传入参数 语言 返回参数:"某某某正在写代码"
public String code (String language) {
return name + "正在写"+ language + "代码";
}
//做个人介绍 方法名：introduce 传入参数为空
//返回参数：“某某某年龄X，性别X，身高X，体重X”
public String introduce () {
return name + "年龄" + age + ",性别" + sex +",身高" + height + ",体重" + weight ;
}
//查询BMI指数 方法名：getBMI 传入参数为空 返回参数：BMI指数
//BMI指数 = 体重/(身高*身高)
public double getBMI() {
return weight/(height*height);
}
//构造方法 无参数
public People() {
}
//构造方法 传入参数：姓名，年龄，性别
public People(String name,int age, String sex) {
this.name =name;
this.age = age;
this.sex = sex;
}
//构造方法 传入参数：姓名，年龄，性别，身高，体重
public People(String name, int age, String sex, double height, double weight) {
super();
this.name = name;
this.age = age;
this.sex = sex;
this.height = height;
this.weight = weight;
}
}
2、访问对象的属性和行为
用户使用new操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。对象的属性和行为在类中是通过类的成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应的获取了对象的属性和行为。
public class EggCake {
String name;//名字
String color;//颜色
String vioce;//叫声
public EggCake(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) {
EggCake d1=new EggCake("毛毛","白色","汪汪汪");
System.out.print(d1.name+"的颜色是"+d1.color);//访问对象的属性
System.out.print("叫起来的声音：");
d1.call();//访问对象的行为
EggCake d2=new EggCake("灰灰","灰色","嗷呜~");
System.out.print(d2.name+"的颜色是"+d2.color);
System.out.print("叫起来的声音：");
d2.call();
}
}运行结果：
3、对象的引用
在Java语言中，尽管一切都可以看作对象，但真正的操作标识符实际上是一个引用，那么引用在Java中是如何体现的呢？语法如下：
类名 对象的引用变量
例如，一个People类的引用可以使用以下代码：
People tom;
引用与对象相关联的语法如下：
People tom = new People();
简单来说，tom是new People()”代理人“。
new People().getClass();
等价于：
People tom = new People();
tom.getClass();
4、对象的销毁
每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收，在其他语言中，需要用户手动回收废弃的对象， Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源。
每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收，在其他语言中，需要用户手动回收废弃的对象， Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源。
1、对象引用超过其作用范围，这个对象将被视为垃圾
2、将对象赋值为null
虽然Java的垃圾回收机制已经很完善，但垃圾回收器只能回收那些由new操作符创建的对象。由于垃圾回收不受人为控制，具体执行时间也不确定，所以 finalize()方法也就无法执行。
课后作业：
public class Dog {
// TODO Auto-generated method stub
//成员变量
String sex;//性别 公/母
String mane;//姓名
String colour;//颜色
String cry;//叫声
//对外提供getter和setter方法
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public String getMane() {
return mane;
}
public void setMane(String mane) {
this.mane = mane;
}
public String getColour() {
return colour;
}
public void setColour(String colour) {
this.colour = colour;
}
public String getCry() {
return cry;
}
public void setCry(String cry) {
this.cry = cry;
}
//成员方法
//自我介绍 方法名：introduce 传入参数为空 返回参数"x狗xx是x色的"
//方法名：bark 传入参数“x狗xx正在xxx叫”
public String introduce() {
return sex+"狗"+mane+"是"+colour+"的";
}
public String bark() {
return sex+"狗"+mane+"正在"+cry+"叫";
}
//构造方法 无参
public Dog()
{
}
//构造函数 三个参数：性别 名字 颜色
public void Dog(String sex, String mane, String colour) {
this.sex = sex;
this.mane = mane;
this.colour = colour;
}
//构造函数 四个参数：性别 名字 颜色 叫声
public Dog(String sex, String mane, String colour, String cry) {
this.sex = sex;
this.mane = mane;
this.colour = colour;
this.cry = cry;
}
}