[t]第4章: 类与对象[/t]

[t]4.1编程语言的几个发展阶段[/t]
[t]4.1.1面向机器语言[/t]
.....
[t]4.1.2面向过程语言[/t]
.....
[t]4.1.3面向对象语言[/t]

1）核心是“对象”
特点：封装性，继承，多态

[t]4.2 类[/t]

1）类的定义：
class 类名
{
类体
}

[t]4.2.1类声明[/t]
class People{
.....
}

[t]4.2.2 类体[/t]
类体的内容包括: 变量的声明和方法的定义;

[t]4.2.3 成员变量[/t]
成员变量的类型: 基本类型（整形，浮点型，字符型，逻辑类型），和引用型（数组，对象，接口）。
class Factory

{

float a[]; Workman zhang; //对象

}

class Workman

{

double x;

}

[t]4.2.4 方法[/t]

方法头{
方法体的内容
}
1.方法头
2.方法体
方法体的内容包括：局部变量的声明和java语句。
3.区分成员变量和局部变量
如果局部变量的名字和成员变量的名字相同，则成员变量将被隐藏。
class Tom{
int x=10,y;
void f()
{
int x=5;
y=x+x;
}
}
4.局部变量没有默认值，需要初始化。
[t]4.2.5 ....[/t]
[t]4.2.6 类的UML图[/t]
UML图属于结构图，常用于描述一个系统的静态结构。

[t]4.3 构造方法与对象的创建[/t]
1）当程序用类创建对象时需使用它的构造方法。
2）类中的构造方法必须和它所在的类名字完全相同，而且没有类型
3）允许一个类中编写若干个构造方法，但必须参数不同（参数的个数不同，或者参数的个数相同，但参数列表中对应的
某个参数的类型不同）。
4）若类中没有编写构造方法，则系统会提供一个默认的构造方法。
5)构造方法的作用是为类的成员变量进行初始化。
例子:
class Point{
int x,y;
Point(){
x=1;
y=1;
}
Point(int a,int b){
x=a;
y=b;
}
}

[t]4.3.2 创建对象[/t]
*创建对象包括对象的声明和为对象分配变量。
1.对象的声明
类名对象名
Lader lader
2.为声明的对象分配变量
使用new运算符和类的构造方法为声明的对象分配变量，即创建对象。
Lader lader=new Lader();
Lader lader=new Lader(10,20);
3. 对象的内存模型
一个类通过new运算符可以创建多个不同的对象，这些对象将分配不同的内存空间，再调用构造方法
对类的成员变量进行初始化，并返回一个引用给对应的对象。改变其中一个对象的状态不会影响其他对象
的状态。

[t]4.3.3 使用对象[/t]
*抽象的目的是产生类，而类的目的是创建具有属性和行为的对象。对象不仅可以操作自己的变量改
变状态，而且能调用类中的方法产生一定的行为。
*对象负责存放引用，以确保对象可以操作分配给该对象的变量以及调用类中的方法。

1.对象操作自己的变量（体现对象的属性）
对象.变量;
2.对象调用类中的方法（体现对象的行为）
对象.方法;
3.体现封装
当对象调用方法是，方法中出现的成员变量就是指分配给该对象的变量。

[t]4.34 对象的引用和实体[/t]
1.避免使用空对象
没有实体(即没有为该对象分配变量)的对象称为空对象。空对象不能使用。。。。
2.引用
一个类声明的两个对象如果具有相同的引用，那么二者就有完全相同的变量(实体），
object2=objiect1;
3.垃圾收集
java的垃圾收集机制，会周期的检测某个实体是否已不再被任何对象所拥有，如果发现
这样的实体，就释放实体占有的内存。
例如:
Point p1=new Point(5,15);
Point p2=new Point(8.18);
p1=p2;
此时，系统将取消原来分配给p1的变量。如果想让java虚拟机立即进行垃圾回收操作，可以
使用System.gc();

[t]4.4 类与程序的基本结构[/t]
。。。。。

[t]4.5.1参数传值[/t]

在java中，方法的所有参数都是“传值”的，也就是说，方法中参数变量的值是调用者
指定的值得拷贝。
[t]4.5.2 基本数据类型参数的传值[/t]
。。。。
[t]4.5.3 引用类型参数的传值[/t]
当参数是“引用类型”（数组，对象，接口）时，“传值”传递的是变量中存放的引用，
而不是变量所引用的实体。
对于两个相同类型的引用型变量，如果具有同样的引用，就会有同样的实体，因此，如果
改变参数变量所引用的实体，就会导致原变量的实体发生同样的变化，但是，改变参数中存放的
引用不会影响向其传值的变量中存放的“引用”，反之亦然。

【例子:】

-------Circle.java------
package com.yinyong;

public class Circle {
double radius,area; //radius为半径，area为面积
Circle(double r){ //构造函数对radius变量进行初始化
radius=r;
}

void setRadius(double r) //set方法修改radius变量
{
radius=r;
}

double getRadius(){ //get方法返回radius的值
return radius;
}

double getArea(){ //getArea方法求面积
area=3.14*radius*radius;
return area;
}

}
-------Circular.java------

package com.yinyong;

public class Circular {
Circle bottom; //Circle对象
double height; //圆锥的高
Circular(Circle c,double h){ //构造方法对bottom和height初始化
bottom=c;
height=h;
}
double getVolme(){ //求圆锥体积的方法
return bottom.getArea()*height/3.0;
}
double getBottomRadius(){ //得到bottom对象的半径
return bottom.getRadius();
}
public void setBottomRadius(double r){ //设置bottom对象的半径
bottom.setRadius(r);
}

}

-------Example4_8.java--------

package com.yinyong;

public class Example4_8 {
public static void main(String args[])
{
Circle circle =new Circle(10); //创建circle对象
System.out.println("main方法中Circle的引用:"+circle);
System.out.println("main方法中circle的半径:"+circle.getRadius());

Circular circular=new Circular(circle, 20); //将circle对象的引用以“传值”的方式传递给circular对象的bottom，因此bottom对象和circle对象有同样的
实体radius，并初始化height=20；
System.out.println("circular圆锥的bottom的引用:"+circular.bottom);
System.out.println("圆锥bottom的半径:"+circular.getBottomRadius());
System.out.println("圆锥的体积:"+circular.getVolme());

double r=8888;
System.out.println("圆锥改变bottom的半径:"+r);
circular.setBottomRadius(r);
System.out.println("圆锥bottom的半径:"+circular.getBottomRadius());
System.out.println("圆锥的体积:"+circular.getVolme());
System.out.println("main方法中的circle的半径:"+circle.getRadius());
System.out.println("main方法中circle的引用将发生变化");

circle=new Circle(1000); //重新创建circle对象
System.out.println("现在main方法中circle的引用:"+circle); //此时circle对象的引用发生变化
System.out.println("main方法中circle的半径："+circle.getRadius());
System.out.println("但是不影响circular圆锥中bottom的引用");
System.out.println("circular圆锥的bottom的引用："+circular.bottom);
System.out.println("circular圆锥的bottom的radius不变："+circular.bottom.radius);
System.out.println("circular圆锥的bottom的体积也不变："+circular.getVolme());
}
}
[t]4.6 对象的组合[/t]
[t]4.6.1 组合与复用[/t]
如果一个对象a组合了对象b，那么对象a就可以委托对象b调用其方法，即对象a可以以
组合的方式复用对象b的方法。
组合对象复用方法特点：
（1）通过组合对象来复用方法也称为“黑盒”复用，因为当前对象只能委托所包含的
对象调用其方法。
（2）当前对象随时可以更换所包含的对象，即对象与所包含的对象属于若耦合关系。

[t]4.6.1 类的关联关系和依赖关系的UML图[/t]
1.关联关系
如果A类中成员变量是用B类声明的对象，那么A和B的关系是关联关系，称A类的对象
关联于B类的对象或A类的对象组合了B类的对象。
2.依赖关系
如果A类中某个方法参数是用B类声明的对象或某个方法返回的数据类型是B类的对象，
那么A和B的关系是依赖关系。称A依赖于B。

4.7 实例成员与类成员
4.7.1 实例变量和类变量的声明。
成员变量分为：实例变量和类变量(static)。
例:
class Dog{
float x; //实例变量
static int y; //类变量
}
区别:
1.不同对象的实例变量互不相同
2.所有对象共享类变量
new运算符创建多个不同对象时，分配给这些对象的这个类变量占有相同一处内存，
改变其中一个对象的这个类变量会影响其他对象的这个类变量。
3.通过类名直接访问类变量
当java程序执行时，类的字节码文件被加载到内存，如果该类没有创建对象，
类中的实例变量将不会分配内存，但是，类中的类变量，在类被加载到内存时，就
分配了相应的内存空间。如果该类创建对象，将不再为类变量重新分配内存，所有
对象共享类变量。类变量的内存空间直到程序退出运行，才释放占有的内存。

[t]4.7.3 实例方法和类方法的定义[/t]
1.类中的方法分为实例方法和类方法(static)。
例子：
class A{
int a;
float max(float x,float y) //实例方法
{
......
}
static void speak(String s){ //类方法
......
}
}

2.两者区别
1.对象调用实例方法
当类的字节码文件被加载到内存时，类的实例方法不会分配入口地址，只有该类创建
对象后，类中的实例方法才分配入口地址，从而实例方法可以被类创建的任何对象调用执行
。需要注意的是，当我们创建第一个对象时，类中的实例方法就分配了内存地址，当再创建
对象时，不再分配入口地址，也就是说，方法的入口地址被所有对象共享，当所有的对象不
存在时，方法的入口地址才被取消。
实例方法可以才做实例变量和类变量。

2.类名调用类方法
对于类中的类方法，在该类被加载到内存时，就分配了相应的入口地址，从而类方法
不仅可以被类创建的任何对象调用执行，也可以通过类名调用。类方法的入口地址直到程
序退出才被取消。
类方法不能操作实例变量，因为在类创建对象之前，实例变量还没有分配内存。

3.设计类方法原则
如果一个方法不需要操作类中的任何实例变量，就可以考虑将这样的方法设计成static方法。

[t]4.8 方法重载[/t]
1.java中存在两种多态：重载(Overload)和重写(Override)。重写是与继承有关的多态。。。
2.什么是方法重载？
一个类中可以有多个方法具有同样的名字，但这些方法的参数必须不同。
参数的个数不同。
参数的个数相同，但是参数列表中对应的某个参数的类型不同。

[t]4.9 this关键字[/t]
this是java的关键字，表示某个对象。

[t]4.9.1 在构造方法中使用this[/t]
this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。
class People{
String s;
People(String s){
name=s;
this.init();
}
void init(){
.....
}
}
[t]4.9.1 在实例方法中使用this[/t]
class A{
int x;
static int y;
void f(){
this.x=100; //this.成员变量
A.y=200; //类名.成员变量;
}
}

[t]4.10 包[/t]
包是java语言有效的管理类的一个机制，不同java源文件中可能出现名字相同的类，如果
想区分这些类，就需要使用包名。包名的目的是有效的区分名字相同的类，不同java源文件中两
个类名字相同时，他们可以通过隶属于不同的包来互相区分。
[t]4.10.1 包语句[/t]
package 包名;
package com.bcoder;
目录格式: E:\workplace\工程名\src\com\bcoder\源文件
[t]4.11 import语句[/t]

一个类如果需要另一个类声明的对象作为自己的成员或方法中的局部变量，而这两个类不在同一包中，
那么就需要使用import语句。
[t]4.11.1 引入类库中的类[/t]
用户编写的类肯定和类库中的类不在同一包中。如果用户需要类库中的类就必须使用import语句。使用
import语句可以引入包中的类。
java提供130多个包，比如：
java.lang 包含所有的基本语言类
java.swing 包含抽象窗口工具集中的图形，文本，窗口GUI类
java.io 包含所有的输入输出类
java.util 包含实用类
java.sql 包含操作数据库的类
java.net 包含所有实现网络功能的类
引入一个包中所有的类
import java.util.*;
引入util中Date类
import java.util.Date;
注: 1.java.lang包是java语言的核心类库，它包含了运行java程序必不可少的系统类，
系统自动为程序引入java.lang包含的类（System类Math类等）。
2.如果是用import语句引入整个包中的类，那么可能会增加编译时间，但不会影响
程序的运行时间，因为程序执行时，只是将程序真正使用的类字节码加载到内存。

[t]引入自定义包中的类[/t]
。。。。
[t]4.12.1访问权限[/t]
1）所谓访问权限是指：对象是否可以通过“.”运算符操作自己的变量或者调用类中的方法。
2）访问限制修饰符有private、protected、和public，用来修饰成员变量或者方法。
3）需要注意的是，在编写类的时候，类中的实例方法总可以操作该类中的实例变量和类变量，
类方法总是可以操作该类中的类变量，与访问限制符没有关系。

[t]4.12.2 私有变量和私有方法[/t]
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); //非法
}
}

** 如果Tom类中某个成员是私有变量（静态成员变量）private static float weight;，
那么在另外一个类中，也不能通过类名Tom来操作这个私有类变量。如果Tom类中某个方法为
私有类方法， private static float f(float a,float b)那再另一个类中也不能通过类名Tom
来调用这个私有方法。

[t]4.12.3 共有变量和共有方法[/t]
1）用public修饰的成员变量和方法被称为共有变量和共有方法。
2）在任何一个类中创建对象后，该对象都能访问自己的public变量和类中的public方法。
3）public范围是指整个项目，所有的类都可以访问，不管在哪个包里。
4.12.4 友好变量和友好方法
1）不用private，public，protected修饰符修饰的成员变量和方法被称为友好变量和友好方法。
2）友好变量的范围在同一包中，如果源文件使用import语句引入了另一个包中的类，并用该类创
建了一个对象，那么该类的这个对象不能访问自己的友好变量和友好方法。

[t]4.12.5 受保护的成员变量和方法[/t]
1）用protected修饰的成员变量和方法称为受保护的成员变量和方法
[t]4.12.6 基本类型的类封装[/t]
1. java提供基本数据类型包括: boolean、byte、short、int、long、float、和double。java同时
提供了与基本数据类型相关的类，实现了对基本数据类型的封装。这些类在java.lang包中，分别是:Byte、
Integer、Short、Long、Float、Double和Character类。
[t]4.14 对象数组[/t]
1)对象数组:即数组的元素是对象。
Student [] stu;
stu=new Student();
//上述代码定义了数组stu有10个元素，且每个元素都是Student类型的对象。但这些对象都是空对象，需要为
每个数组元素创建对象。例如: stu[0]=new Student();

未经允许不得转载：Bcoder资源网 » 【jAVA基础知识】第4章：类与对象